可变参数模板示例

Question

考虑下面的代码，我不明白为什么必须定义 print 的空函数。

#include <iostream>
using namespace std;

void print()
{   
}   

    template <typename T, typename... Types>
void print (const T& firstArg, const Types&... args)
{   
    cout << firstArg << endl; // print first argument
    print(args...); // call print() for remaining arguments
}

int main()
{   
    int i=1;
    int  j=2;
    char c = 'T';
    print(i,"hello",j,i,c,"word");

}   

Answer 1

正确的方式：

可变参数模板与 induction 严格相关，这是一个数学概念。

编译器解析以下函数调用

print('a', 3, 4.0f);

进入

std::cout<< 'a' <<std::endl;
print(3, 4.0f);

解析成

std::cout<< 'a' <<std::endl;
std::cout<< 3 <<std::endl;
print( 4.0f);

解析成

std::cout<< 'a' <<std::endl;
std::cout<< 3 <<std::endl;
std::cout<< 4.0f <<std::endl;
print();

此时它会搜索匹配为空函数的函数重载。

• 具有 1 个或多个参数的所有函数都与可变参数模板匹配
• 所有没有参数的函数都匹配到空函数

罪魁祸首是，对于每种可能的参数组合，您必须只有 1 个函数。

---

错误 1：

执行以下操作会出错

template< typename T>
void print( const T& arg) // first version
{   
    cout<< arg<<endl;
}   

template <typename T, typename... Types>
void print (const T& firstArg, const Types&... args) // second version
{   
    cout << firstArg << endl; // print first argument
    print(args...); // call print() for remaining arguments
}

因为当您调用print 时，编译器不知道要调用哪个函数。

print(3) 是指“第一”还是“第二”版本？两者都是有效的，因为第一个有 1 个参数，第二个也可以接受一个参数。

print(3); // error, ambiguous, which one you want to call, the 1st or the 2nd?

---

错误 2：

以下内容无论如何都会出错

// No empty function

template <typename T, typename... Types>
void print (const T& firstArg, const Types&... args) 
{   
    cout << firstArg << endl; // print first argument
    print(args...); // call print() for remaining arguments
}

事实上，如果你单独使用它而不用编译器就可以了

 print('k', 0, 6.5);

解析成

 std::cout<<'k'<<std::endl;
 print(0, 6.5);

解析成

 std::cout<<'k'<<std::endl;
 std::cout<< 0 <<std::endl;
 print( 6.5);

解析成

 std::cout<<'k'<<std::endl;
 std::cout<< 0 <<std::endl;
 std::cout<< 6.5 <<std::endl;
 print(); //Oops error, no function 'print' to call with no arguments

正如您在上次尝试中看到的那样，编译器尝试不带参数地调用 print()。但是，如果这样的函数不存在，它不会被调用，这就是为什么你应该提供那个空函数（别担心，编译器会优化代码，所以空函数不会降低性能）。

Answer 2

如果你没有空的 print 函数，想象一下有 2 个参数的调用：

1. print (a, b) => cout
2. print (b) => cout

哎呀，print() 不存在，因为只有至少一个参数的print 存在！所以你需要一个不带参数的print。

print 没有任何参数是你的最终调用

Answer 3

因为（使用非常“简单”的解释）可变参数模板机制的工作原理类似于递归（它是不是递归，但这是理解的最简单方法它），它“消耗”可变参数列表，因此您必须定义一个“stop”函数，当“消耗”参数列表为“空”。这是我发现这个非常复杂的概念最容易理解的解释。

在第一步（main）中，您将获得一个具有参数的函数：(int, const char*, int, int, char, const char*)

然后在可变参数函数本身中慢慢处理可变参数参数，让您进入第二步(const char*, int, int, char, const char*)然后(int, int, char, const char*)等等......直到你到达最后一个元素(const char*)，当这个也在下一步处理你最终得到()，编译器需要这个函数作为“终结者”

（是的，这是非常非技术性的，听起来像青蛙爷爷给小青蛙讲故事......）

Answer 4

递归是编程可变参数模板最通用的方法，但它远非唯一的方法。对于像这样的简单用例，直接在花括号初始化器列表中进行包扩展会更短，并且编译速度可能更快。

template <typename... Types>
void print (const Types&... args)
{   
    using expander = int[];
    (void) expander { 0, (void(cout << args << endl), 0) ...};
}

在 C++17 中，我们将能够使用折叠表达式：

template <typename... Types>
void print (const Types&... args)
{   
    (void(cout << args << endl) , ...);
}

Answer 5

为了补充其他答案，我想展示编译器必须为模板调用生成什么。

nm -g -C ./a.out（非优化构建）给出：

void print<char [5]>(char const (&) [5])
void print<char [5]>(char const (&) [5])
void print<char [6], int, int, char, char [5]>(char const (&) [6], int const&, int const&, char const&, char const (&) [5])
void print<char [6], int, int, char, char [5]>(char const (&) [6], int const&, int const&, char const&, char const (&) [5])
void print<char, char [5]>(char const&, char const (&) [5])
void print<char, char [5]>(char const&, char const (&) [5])
void print<int, char [6], int, int, char, char [5]>(int const&, char const (&) [6], int const&, int const&, char const&, char const (&) [5])
void print<int, char, char [5]>(int const&, char const&, char const (&) [5])
void print<int, int, char, char [5]>(int const&, int const&, char const&, char const (&) [5])
void print<int, char [6], int, int, char, char [5]>(int const&, char const (&) [6], int const&, int const&, char const&, char const (&) [5])
void print<int, char, char [5]>(int const&, char const&, char const (&) [5])
void print<int, int, char, char [5]>(int const&, int const&, char const&, char const (&) [5])
print()

您可以看到print 函数的所有实例化。最终调用print()的函数是void print<char [5]>(char const (&) [5])>

可以看到，当传递一个空的参数包时，模板参数列表一定是空的。因此它只调用print()。如果您明确指定模板参数，例如print<T, Args...>(t, args...)，您将获得无限递归。