c++ - 可变参数模板 - 不同类型的扩展

Question

Andrei Alexandrescu 发表了精彩的演讲，题为:Variadic Templates are Funadic .

他展示了以下 3 个非常不同的扩展:

template <class... Ts> void fun( Ts... vs ) {
    gun( A<Ts...>::hun(vs)...);
    gun( A<Ts...>::hun(vs...));
    gun( A<Ts>::hun(vs)...);
}

他解释说:

调用 1:展开所有 Ts 以实例化 A 类，然后调用 hun(vs)然后在将它们传递给 gun

时再次展开所有参数

调用 2:分别展开所有 Ts 和所有 vs

调用 3:Expnads in lock step，即:展开 Ts 的参数 1 和 vs 的参数 1展开 Ts 的参数 2 和 vs 的参数 2展开 Ts 的参数 n 和 vs

的参数 n

关于可变参数模板的其他讨论似乎只涵盖了简单的可变参数类模板和可变参数函数，例如类型安全的 printf 等。我不确定这些不同类型的扩展如何影响代码以及每种类型的用处。

有没有人有一些例子来说明每种扩展的应用？

Answer 1

#include <iostream>
#include <memory>
#include <typeinfo>
#include <cstdlib>
#include <cxxabi.h>

template <typename T>
std::unique_ptr<char, void(*)(void*)>
type_name()
{
    return std::unique_ptr<char, void(*)(void*)>
           (
                __cxxabiv1::__cxa_demangle(typeid(T).name(), nullptr,
                                           nullptr, nullptr),
                std::free
           );
}

void display() {}

template <class T>
void
display()
{
    std::cout << type_name<T>().get() << ' ';
}

template <class T, class T2, class ...Tail>
void
display()
{
    std::cout << type_name<T>().get() << ' ';
    display<T2, Tail...>();
}

template <class... Ts>
struct A
{
    template <class... Us>
        static
        int
        hun(Us... us)
        {
            std::cout << "A<";
            display<Ts...>();
            std::cout << ">::hun(";
            display<Us...>();
            std::cout << ")\n";
            return 0;
        }
};

template <class ...T>
void gun(T...) {}

template <class... Ts> void fun( Ts... vs )
{
    std::cout << "gun( A<Ts...>::hun(vs)...);\n";
    gun( A<Ts...>::hun(vs)...);
    std::cout << "\ngun( A<Ts...>::hun(vs...));\n";
    gun( A<Ts...>::hun(vs...));
    std::cout << "\ngun( A<Ts>::hun(vs)...);\n";
    gun( A<Ts>::hun(vs)...);
}

int main()
{
    fun(1, 'a', 2.3);
}

输出:

gun( A<Ts...>::hun(vs)...);
A<int char double >::hun(int )
A<int char double >::hun(char )
A<int char double >::hun(double )

gun( A<Ts...>::hun(vs...));
A<int char double >::hun(int char double )

gun( A<Ts>::hun(vs)...);
A<int >::hun(int )
A<char >::hun(char )
A<double >::hun(double )