c++ - 具有嵌套可变参数模板的函数

Question

您能否使用接受任意元组列表的可变参数模板编写一个函数，每个元组具有一组不同的参数？所以你会有类似的东西:

template< /* some crazy variadic thing...*/ >
void func( ... ) {}

func(make_tuple(1,2), make_tuple("hello"));

SFINAE 助您一臂之力!进一步了解 Jeffery 的回答，我写了这个小片段。您可以将元组以外的类型放在 func 的参数列表中的任何位置，它会编译并运行，当它遇到第一个不是模板类的类型时，它只会破坏我的打印链。 seq 和gens 来自here .

template<typename T>
int print(T& t) {
        cout << t << " ";
        return 0;
}

template<typename... T> void dumby(T...) {}

// so other template classes don't cause error (see bar below)
template<typename... A>
void expand(A... a) {}

template<typename... A, int... S>
void expand(tuple<A...> a, seq<S...>) {
        dumby(print(get<S>(a))...);
        cout << endl;
}

template<class... Types>
void func(Types...) {}

template<template<typename...> class A, class... Types, class... tup_types>
void func(A<tup_types...> a, Types... args) {
        expand(a, typename gens<sizeof...(tup_types)>::type());

        func(args...);
}

template<typename... A> struct bar {};

int main () {
        func(make_tuple(0,1), make_tuple(2), 1, make_tuple("hello"), 0);
        func(make_tuple(0,1), bar<int,int>(), make_tuple(2), 1, make_tuple("hello"), 0);
}

我必须找到一个实际的用例来尝试，但我会称之为暂时的成功!

Answer 1

是的，只需使用一个带有元组的基本函数，然后使用可变模板/参数创建一个同名函数。

template<typename ... Types>
void func(const std::tuple<Types...> &Tuple){
    // work with tuple
}

template<typename TupleType, typename ... TupleTypes>
void func(const TupleType &arg, const TupleTypes &... args){
    func(arg);
    func(args...);
}

int main(){
    func(std::make_tuple(1, 2), std::make_tuple("hello"));
}

这会给你很大的灵 active ，因为你可以知道 tuple 和 throw 或 static_assert 或其他任何类型的数量当你遇到你不喜欢的东西时你会喜欢或者你可以更进一步，在函数上使用 std::enable_if 来只允许你的元组的某些条件!

如您所问，此函数仅适用于 std::tuple，但您可以通过更改第一个函数进一步扩展它以允许使用任何为其类型采用多个模板参数的容器到:

template<typename ... Types, template<typename...> class TupleType>
void func(const TupleType<Types...> &Tuple){
    // Work with any type inter-face-able like a tuple
}

编辑

这可以用 C++17 fold expressions 变得更简洁一点:

template<typename ... Ts>
void func(const std::tuple<Types...> &Tuple){
    // ...
}

template<typename ... Tuples>
void func(const Tuples &... tuples){
    (func(tuples), ...);
}