欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

C++可变参数模板

程序员文章站 2022-05-23 07:54:52
C++可变参数模板:普通模板只可以采取固定数量的模板参数。然而,有时候我们希望模板可以接收任意数量的模板参数,这个时候可以采用可变参数模板。 对于可变参数模板,其将包含至少一...

C++可变参数模板:普通模板只可以采取固定数量的模板参数。然而,有时候我们希望模板可以接收任意数量的模板参数,这个时候可以采用可变参数模板。

对于可变参数模板,其将包含至少一个模板参数包,模板参数包是可以接收0个或者多个参数的模板参数。相应地,存在函数参数包,意味着这个函数参数可以接收任意数量的参数。

使用规则

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

template
class Tuple
{};

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

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

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

template
class Tuple
{};

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

template
void f(Types ... args);

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

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

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

template
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}

可变参数函数模板实例

无法直接遍历传给可变参数模板的不同参数,但是可以借助递归的方式来使用可变参数模板。可变参数模板允许创建类型安全的可变长度参数列表。下面定义一个可变参数函数模板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
void processValues(T arg)
{
    handleValue(arg);
}

// 可变参数函数模板
template
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
void processValues(T &&arg)
{
    handleValue(std::forward(arg));
}

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

实现简化的printf函数

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

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

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

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

其方法基本与processValues()是一致的,其差别主要在于tprintf的第一个参数固定是const char*类型。