C++可变参数模板

可变参数模板

原文链接: http://blog.csdn.net/xiaohu2022/article/details/69076281

https://www.cnblogs.com/qicosmos/p/4325949.html

普通模板只可以采取固定数量的模板参数。然而，有时候我们希望模板可以接收任意数量的模板参数，这个时候可以采用可变参数模板。对于可变参数模板，其将包含至少一个模板参数包，模板参数包是可以接收0个或者多个参数的模板参数。相应地，存在函数参数包，意味着这个函数参数可以接收任意数量的参数。

可变模板参数---- C++11新特性

可变模板参数(variadic templates)是C++11新增的最强大的特性之一,它对参数进行了高度泛化,它能表示0到任意个数、任意类型的参数
由于可变模版参数比较抽象，使用起来需要一定的技巧，所以它也是C++11中最难理解和掌握的特性之一

参数包(parameter pack)

模板参数包，如:

　　template<typename… Args>class tuple;

Args标识符的左侧使用了省略号,在C++11中Args被称为“模板参数包”,表示可以接受任意多个参数作为模板参数,编译器将多个模板参数打包成“单个”的模板参数包.

函数参数包，如

　　template<typename…T> void f(T…args);

args被称为函数参数包,表示函数可以接受多个任意类型的参数.

在C++11标准中，要求函数参数包必须唯一，且是函数的最后一个参数; 模板参数包则没有

当声明一个变量(或标识符)为可变参数时，省略号位于该变量的左侧

当使用参数包时，省略号位于参数名称的右侧，表示立即展开该参数，这个过程也被称为解包

包扩展表达式

设args被声明为一个函数参数包，其扩展方式有

printArgs(args…)

相当于printArgs(args1,args2,…,argsN)

printArgs(args)…

相当于printArgs(args1),…, printArgs(argsN)

(printArgs(args),0)… 逗号表达式

这是一个逗号表达式。相当于(printArgs(args1),0),…(printArgs(argsN),0)

包扩展表达式“exp…”相当于将省略号左侧的参数包exp视为一个整体来进行扩展

使用规则

可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号“...”。比如我们常常这样声明一个可变模版参数：template<typename...>或者template<class...>，一个典型的可变模版参数的定义是这样的：

template <class... T>
void f(T... args);

上面的可变模版参数的定义当中，省略号的作用有两个：
1.声明一个参数包T... args，这个参数包中可以包含0到任意个模板参数；
2.在模板定义的右边，可以将参数包展开成一个一个独立的参数。

　　上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。

　　可变模版参数和普通的模版参数语义是一致的，所以可以应用于函数和类，即可变模版参数函数和可变模版参数类，然而，模版函数不支持偏特化，所以可变模版参数函数和可变模版参数类展开可变模版参数的方法还不尽相同，下面我们来分别看看他们展开可变模版参数的方法。

一个可变参数tuple类模板定义如下：

template<typename ... Types>
class Tuple
{};

可以用任意数量的类型来实例化Tuple：

Tuple<> t0;
Tuple<int> t1;
Tuple<int, string> t2;
// Tuple<0> error;  0 is not a type

如果想避免出现用0个模板参数来实例化可变参数模板，可以这样定义模板：

template<typename T, typename ... Types>
class Tuple
{};

此时在实例化时，必须传入至少一个模板参数，否则无法编译。
同样地，可以定义接收任意参数的可变参数函数模板：

template<typename ... Types>
void f(Types ... args);

// 一些合法的调用
f();
f(1);
f(3.4, "hello");

对于类模板来说，可变模板参数包必须是模板参数列表中的最后一个参数。但是对于函数模板来说，则没有这个限制，考虑下面的情况：

template<typename ... Ts, typename U>
class Invalid
{};   // 这是非法的定义，因为永远无法推断出U的类型

template<typename ... Ts, typename U>
void valid(U u, Ts ... args);  // 这是合法的，因为可以推断出U的类型
// void invalid(Ts ... args, U u); // 非法的，永远无法推断出U

valid(1.0, 1, 2, 3); // 此时，U的类型是double，Ts是{int, int, int}

可变参数函数模板实例

一个简单的可变模版参数函数：

template <class... T>
void f(T... args)
{    
    cout << sizeof...(args) << endl; //打印变参的个数
}

f();        //0
f(1, 2);    //2
f(1, 2.5, "");    //3

上面的例子中，f()没有传入参数，所以参数包为空，输出的size为0，后面两次调用分别传入两个和三个参数，故输出的size分别为2和3。由于可变模版参数的类型和个数是不固定的，所以我们可以传任意类型和个数的参数给函数f。这个例子只是简单的将可变模版参数的个数打印出来，如果我们需要将参数包中的每个参数打印出来的话就需要通过一些方法了。展开可变模版参数函数的方法一般有两种：一种是通过递归函数来展开参数包，另外一种是通过逗号表达式来展开参数包。下面来看看如何用这两种方法来展开参数包。

2.1.1递归函数方式展开参数包

无法直接遍历传给可变参数模板的不同参数，但是可以借助递归的方式来使用可变参数模板。可变参数模板允许创建类型安全的可变长度参数列表。下面定义一个可变参数函数模板processValues()，它允许以类型安全的方式接受不同类型的可变数目的参数。函数processValues()会处理可变参数列表中的每个值，对每个参数执行对应版本的handleValue()。

// 处理每个类型的实际函数
void handleValue(int value) { cout << "Integer: " << value << endl; }
void handleValue(double value) { cout << "Double: " << value << endl; }
void handleValue(string value) { cout << "String: " << value << endl; }

// 用于终止迭代的基函数
template<typename T>
void processValues(T arg)
{
    handleValue(arg);
}

// 可变参数函数模板
template<typename T, typename ... Ts>
void processValues(T arg, Ts ... args)
{
    handleValue(arg);
    processValues(args ...); // 解包，然后递归
}

可以看到这个例子用了三次... 运算符，但是有两层不同的含义。用在参数模板列表以及函数参数列表，其表示的是参数包。前面说到，参数包可以接受任意数量的参数。用在函数实际调用中的...运算符，它表示参数包扩展，此时会对args解包，展开各个参数，并用逗号分隔。模板总是至少需要一个参数，通过args...解包可以递归调用processValues()，这样每次调用都会至少用到一个模板参数。对于递归来说，需要终止条件，当解包后的参数只有一个时，调用接收一个参数模板的processValues()函数，从而终止整个递归。

假如对processValues()进行如下调用:

processsValues(1, 2.5, "test");

其产生的递归调用如下：

processsValues(1, 2.5, "test");
    handleValue(1);
    processsValues(2.5, "test");
        handleValue(2.5);
        processsValues("test");
            handleValue("test");

由于processValues()函数会根据实际类型推导自动调用正确版本的handleValue()函数，所以这种可变参数列表是完全类型安全的。如果调用processValues()函数带有的一个参数，无对应的handleValue()函数版本，那么编译器会产生一个错误。

前面的实现有一个致命的缺陷，那就是递归调用时参数是复制传值的，对于有些类型参数，其代价可能会很高。一个高效且合理的方式是按引用传值，但是对于字面量调用processValues()这样会存在问题，因为字面量仅允许传给const引用参数。比较幸运的是，我们可以考虑右值引用。使用std::forward()函数可以实现这样的处理，当把右值引用传递给processValues()函数时，它就传递为右值引用，但是如果把左值引用传递给processValues()函数时，它就传递为左值引用。下面是具体实现：

// 用于终止迭代的基函数
template<typename T>
void processValues(T &&arg)
{
    handleValue(std::forward<T>(arg));
}

// 可变参数函数模板
template<typename T, typename ... Ts>
void processValues(T&& arg, Ts&& ... args)
{
    handleValue(std::forward<T>(arg));
    processValues(std::forward<Ts>(args) ...); // 先使用forward函数处理后，再解包，然后递归
}

实现简化的printf函数

这里我们通过可变参数模板实现一个简化版本的printf函数：

// 基函数
void tprintf(const char* format)
{
    cout << format;
}

template<typename T, typename ... Ts>
void tprintf(const char* format, T&& value, Ts&& ... args)
{
    for (; *format != ''; ++format)
    {
        if (*format == '%')
        {
            cout << value;
            tprintf(format + 1, std::forward<Ts>(args) ...); // 递归
            return;
        }
        cout << *format;
    }
}
int main()
{

    tprintf("% world% %
", "Hello", '!', 2017);
    // output: Hello, world! 2017
    cin.ignore(10);
    return 0;
}

其方法基本与processValues()是一致的，但是由于tprintf的第一个参数固定是const char*类型。

2.1.2逗号表达式展开参数包

递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点,就是必须要一个重载的递归终止函数，即必须要有一个同名的终止函数来终止递归，这样可能会感觉稍有不便。有没有一种更简单的方式呢？其实还有一种方法可以不通过递归方式来展开参数包，这种方式需要借助逗号表达式和初始化列表。比如前面print的例子可以改成这样：

template <class T>
void printarg(T t)
{
   cout << t << endl;
}

template <class ...Args>
void expand(Args... args)
{
   int arr[] = {(printarg(args), 0)...};
}

expand(1,2,3,4);

References

[1] Marc Gregoire. Professional C++, Third Edition, 2016.
[2] cppreference parameter pack