315

分享到

C++11中的变长模板的示例详解

C++11变长模板 C++ 变长模板 C++11 模板 2023-02-06 12:02:27 315人浏览泡泡鱼

摘要

目录1.C99中的变长函数2.c++11中的变长函数3.详解变长模板3.1 更一般的SFINAE规则3.2 模板参数包的概念3.3 三个简单的例子3.4 函数参数包3.5 包扩展的进

1.C99中的变长函数

宏函数可以实现变长:就是采用C99中的变长宏__VA_ARGS__,如下所示为C99代码:

#include<stdio.h>
#define LOG(...){\
    fprintf(stderr,"%s: Line %d:\t",__FILE__,__LINE__);\
    fprintf(stderr,__VA_ARGS__);\
    fprintf(stderr,"\n");\
}
int main()
{
    int x=3;
    LOG("x=%d",x);//D:\study\c++\c++11\__VA_ARGS__.cpp: Line 10:    x=3
}

普通函数也可以实现变长

#include<stdio.h>
#include<stdarg.h>

double SumOfFloat(int count,...)
{
    va_list ap;
    double sum=0;
    va_start(ap,count);//使得ap初始化为参数列表的handle
    for(int i=0;i<count;i++)
        sum+=va_arg(ap,double);//每次读取sizeof(double)的字节
    va_end(ap);
    return sum;
}
int main()
{
    printf("%f\n",SumOfFloat(3,1.2f,3.4,5.6));//10.200000
}

注意看上面代码中,SumOfFloat中的第一个参数count,这就意味著,你必须告诉函数它的参数的具体个数,这就不太方便,例如SumOfFloat(3,1.2f,3.4,5.6)中的第一个参数3。

2.C++11中的变长函数

C++11实现上面功能的一种方法是:使用initializer_list作为函数形参

#include<iOStream>
#include<initializer_list>
using namespace std;

double SumOfFloat(const initializer_list<double>& l)
{
    double sum=0;
    for(auto &val:l)
        sum+=val;
    return sum;
}
int main()
{
    printf("%f\n",SumOfFloat({1.2f,3.4,5.6}));//10.200000
}

这种思路感觉有点投机取巧,不太好

另一种方法是使用变长模板

#include<iostream>
template<typename... T>double SumOfFloat(T...);//模板函数声明

template<typename ...Args>//递归定义
double SumOfFloat(double a,Args... args)
{
    return a+SumOfFloat(args...);
}

double SumOfFloat(double a){return a;}//边界条件
int main()
{
    printf("%f\n",SumOfFloat(1.2f,3.4,5.6));//10.200000
}

先不对上述代码做解释,只要知道<typename... T>中的T叫做模板参数包,它是类型的,是一种特殊的类型,它可以被推导为多个类型的pack。即SumOfFloat(1.2f,3.4,5.6)会将T推导为double,double,double的一种pack类型。

除此之外,必须知道这种设计必须是递归定义的。

3.详解变长模板

首先讲一个前置概念:SFINAE.

3.1 更一般的SFINAE规则

在C++98中,我们就有SFINAE法则:Substitution failure is not an error

即匹配失败不算失败,在C++中就是,即使模板展开失败,也不会报错

struct Test
{
    typedef int FOO;
};
template<typename T>
void foo(typename T::FOO){}

template<typename T>
void foo(T){}

int main()
{
    foo<Test>(10);
    foo<int>(10);
}

上面代码在C++98中也可以通过编译,上面foo(typename T::FOO)中typename显式的表示,T::FOO是一个类型,在foo<int>(10);中,编译器会尝试用第一个模板函数来匹配它,但是会发现int::FOO错误,但是编译器不会报错,这就是SFINAE

在C++11中对SFINAE规则做了放松,

template<int I>
struct A {};
char xxx(int);
char xxx(float);
template<typename T>A<sizeof(xxx((T)0))> f(T){}
int main()
{
    f(1);
}

有一些C++98编译器会对上式报错,这是因为它们认为模板参数过于复杂,即这里的sizeof(xxx((T)0)),不过现在的编译器都狠优秀,它们可以完成这种表达式的推导,C++11的标准是:只要表达式中没有出现外部于表达式本身的元素,编译器都可以完成推导

3.2 模板参数包的概念

接下来的内容会有一定难度。

我们知道,在C++98中模板参数有3种:类型的,非类型的,模板类型的。

template<typename T,int i,template<typename> class A>中T就是类型的,i是非类型的,A是模板类型的。

在C++11中,我们为了支持变长的模板,我们加入一种新的模板参数:模板参数包。

所以在C++11中模板参数有4种:类型的,非类型的,模板类型的和模板参数包。

而模板参数包又可以细分为3种:类型的模板参数包,非类型的模板参数包,模板类型的模板参数包。

模板参数包是一种pack,下面我们从模板推导角度来解释这种pack:

1.(类型的)模板参数包

template <typename T1,typename T2>class B{};
template <typename... A>class Template: private B<A...>{};
Template<X,Y> xy;

上面中,<typename...A>中A是 (类型的)模板参数包,它可以接收任意多个类型参数作为模板参数,具体来说,Template<X,Y>会将A推导为X和Y类型的pack。

B<A...>中A...是一种包扩展,它是模板参数包unpack的结果。由于A被推导为X和Y的pack,所以A...就被具体解释为X,Y,然后具体化为B<X,Y>。

如果我们使用Template<X,Y,Z> xyz就会引发推导错误,没有任何一个模板适配,这是因为此时A...被解释为3个类型:X,Y,Z,它无法和B匹配。

2.(非类型的)模板参数包

template<int i,long j,unsigned int k>class B{};
template<int ...A> struct Pack: private B<A...>{};
Pack<1,0,2> data;

<int ... A>中A是 (非类型的)模板参数包,它可以接收分离多个非类型参数作为模板参数,具体来说,Pack<1,0,2>会将A推导为整值1,0,2的pack,而B<A...>中A...是一种包扩展,由于A推导为整值1,0,2的pack,所以A...被具体解释为1,0,2,然后具体化为B<1,0,2>

3.(模板类型的)模板参数包

template <typename T> class A;
template <typename T> class B;
template<template<typename> class T1,template<typename> class T2> class C{};
template<template<typename> class ...T> struct Pack:private C<T...>{};
Pack<A,B> data;

<template<typename> class ...T>中T是 (模板类型的)模板参数包,它可以接收多个模板作为模板参数,具体来说,Pack<A,B>会将T推导为A和B的pack,而C<T...>中T...就是一种包扩展,由于T推导为A和B的pack,所以T...就被具体解释为A,B,然后具体化为C<A,B>

3.3 三个简单的例子

变长模板必须采用递归设计,下面是3个简单的例子,请仔细阅读。

1.(类型的)模板参数包的使用

下面给出C++11中tuple的简单实现,

template<typename... Elements> class tuple;//模板声明

template <typename Head,typename... Tail>//递归定义
class tuple<Head,Tail...>:private tuple<Tail...>
{
    Head head;
};
template<> class tuple<>{};//边界条件

同样也是递归定义,这种递归的设计就是变长模板最晦涩的地方。

当实例化tuple<double,int,char,float>类时,

第一次:Head被推导为double,Tail...被推导为int,char,float

第二次:Head被推导为int,Tail...被推导为char,float

第三次:Head被推导为char,Tail...被推导为float

第三次:Head被推导为float,Tail...被推导为空

最后由class tuple<>进行递归构造出模板

2.(非类型的)模板参数包的使用

#include<iostream>
using namespace std;

template<long... nums> struct Multiply;//模板声明

template<long first,long... last>//递归定义
struct Multiply<first,last...>
{
    static const long val=first*Multiply<last...>::val;
};
template <>//边界条件
struct Multiply<>
{
    static const long val=1;
};
int main()
{
    cout<<Multiply<2,3,4,5>::val<<endl;
    cout<<Multiply<22,44,66,88,9>::val<<endl;
}

上面这种编程方式,叫做模板元编程,他将乘法的计算放到模板推导过程中,就是把计算过程放在编译阶段,这样运行时就不需要计算了

3.(模板类型的)模板参数包的使用

template <typename T> class Module1{};
template <typename T> class Module2{};

template<typename I,template<typename>class ... B>struct Container;//模板声明
template<typename I,template<typename> class A,template<typename> class... B>
struct Container<I,A,B...>//递归定义
{
    A<I> a;
    Container<I,B...> b;
};
template<typename I> struct Container<I>{};//边界条件

int main()
{
    Container<int,Module1,Module2> a;
}

3.4 函数参数包

函数参数包是在写变长模板函数中的一个概念

函数参数包也是一种pack型变量,它也存在unpack,包扩展的概念。

void g(int,char,double);
template<typename ... T> 
void f(T... args)
{
    g(args...);
}
f(1,'c',1.2);

在<typename ... T>中的T是 (类型的)模板参数包。

在f(T... args)中T...叫做包扩展

在f(T... args)中的args是一种类型为T...的变量,它叫函数参数包

在g(args...)中的args...也是一种包扩展,它是将argsunpack后的产物

例如,这里f(1,'c',1.2)就会将T推导为int,char,double的pack,于是T...就被具体解释为int,char,double,然后args就是类型为T...的一种变量,args的值是1,'c',1.2的pack,则我们可以在f中调用g(args...)完成对args的unpack。

下面看一个,C++11中提案的prinf()函数的实现

#include<iostream>
#include<stdexcept>
using namespace std;

void Printf(const char*s)//边界条件
{
    while(*s)
    {
        if(*s=='%' && *++s!='%')//确保`%%`不出现
            throw runtime_error("invalid fORMat string: missing arguments");
        cout<<*s++;
    }
}
template<typename T,typename ...Args>//递归定义
void Printf(const char*s,T value,Args... args)
{
    while(*s)
    {
        if(*s=='%' && *++s!='%')//确保`%%`不出现
        {
            cout<<value;
            return Printf(++s,args...);
        }
        cout<<*s++;
    }
    throw runtime_error("extra arguments provided to Printf");
}
int main()
{
    Printf("hello %s\n",(string)"world");
}

变长模板的难点在于我们不知道参数的个数,我们必须采用递归定义,就像上面的Printf就是递归定义的,采用的是数学归纳法,可以细细品味一下上面那段代码。

3.5 包扩展的进阶

...符号可以放在意想不到的地方,例如:

template<typename... A> class T:private B<A>...{};//#1
template<typename... A> class T:private B<A...>{};//#2

对于实例化T<X,Y>,#1会被解释为

class T<X,Y> class T:private B<X>,private B<Y>{};

#2会被解释为

class T<X,Y> class T:private B<X,Y>{};

看一下下面这些例子:

#include<iostream>
using namespace std;

template<typename... T>
void DummyWrapper(T... t){};

template<typename T>
T pr(T t){
    cout<<t;
    return t;
}
template<typename... A>
void VTPrint(A... a)
{
    DummyWrapper(pr(a)...);
}
int main()
{
    VTPrint(1,", ",1.2,", abc\n");
}

上面这段代码,某些编译器(例如g++)的结果是逆序的:

, abc
1.2, 1

应该是,不同的编译器可能包扩展的顺序不太一样,有些的逆序的。

下面我们看一段晦涩难懂的代码

#include<iostream>
#include<tuple>
using namespace std;

template<typename A,typename B> 
struct S
{
    int a=1;
};

template<
    template<typename...> class T, typename... TArgs,
    template<typename...> class U, typename... UArgs
    >
    struct S< T<TArgs...> , U<UArgs...> >{int a=2;};

int main()
{
    S<int,float> p;
    S<tuple<int,char>,tuple<float>> s;
    //S<tuple,int,char,tuple,float> s;编译出错 
    cout<<s.a<<endl;//2
}

注意上面这段代码中,最终输出是2,奇怪的地方在于,S<tuple<int,char>,tuple<float>>如何匹配第二个模板呢?这种设计是约定俗称的,没有任何原因,记住上面这种巧妙的设计就行了。

3.6 sizeof...()的使用

sizeof...()其实狠简单的,它就是获得pack中的变量的个数,有些用的

#include<cassert>
#include<iostream>
using namespace std;

template<typename... A>
void Print(A... arg)
{
    assert(false);
}

void Print(int a1,int a2,int a3,int a4,int a5,int a6)
{
    cout<<a1<<", "<<a2<<", "<<a3<<", "<<a4<<", "<<a5<<", "<<a6<<endl;
}

template<class... A>int Vaargs(A... args)
{
    int size=sizeof...(args);//或者sizeof...(A)

    switch (size)
    {
        case 0:Print(99,99,99,99,99,99);
                break;
        case 1:Print(99,99,args...,99,99,99);
                break;
        case 2:Print(99,99,args...,99,99);
                break;
        case 3:Print(args...,99,99,99);
                break;
        case 4:Print(99,args...,99);
            break;
        case 5:Print(99,args...);
            break;
        case 6:Print(args...);
            break;
        default:
            Print(0,0,0,0,0,0);
    }
}
int main()
{
    Vaargs();//99, 99, 99, 99, 99, 99
    Vaargs(1);//99, 99, 1, 99, 99, 99 
    Vaargs(1,2);//99, 99, 1, 2, 99, 99
    Vaargs(1,2,3);//1, 2, 3, 99, 99, 99  
    Vaargs(1,2,3,4);//99, 1, 2, 3, 4, 99   
    Vaargs(1,2,3,4,5);//99, 1, 2, 3, 4, 5 
    Vaargs(1,2,3,4,5,6);//1, 2, 3, 4, 5, 6  
    Vaargs(1,2,3,4,5,6,7);//0, 0, 0, 0, 0, 0 
}

3.7 变长模板和完美转发的配合

#include<iostream>
using namespace std;

struct A
{
    A(){};
    A(const A&a){cout<<"Copy Constructed "<<__func__<<endl;}
    A(A&& a){cout<<"Move Constructed "<<__func__<<endl;}
};

struct B
{
    B(){};
    B(const B&b){cout<<"Copy Constructed "<<__func__<<endl;}
    B(B&& b){cout<<"Move Constructed "<<__func__<<endl;}
};

template<typename... T> struct  MultiTypes;//模板声明

template<typename T1,typename... T>//递归定义
struct MultiTypes<T1,T...>: public MultiTypes<T...>
{
    T1 t1;
    MultiTypes<T1,T...>(T1 a,T... b):t1(a),MultiTypes<T...>(b...)
    {
        cout<<"MultiTypes<T1,T...>(T1 a,T... b)"<<endl;
    }
};

template<> struct MultiTypes<>//边界条件
{
    MultiTypes<>(){cout<<"MultiTypes<>()"<<endl;}
};

template<template<typename...> class VariadicType,typename... Args>
VariadicType<Args...> Build(Args&& ... args)
{
    return VariadicType<Args...>(std::forward<Args>(args)...);
}

int main()
{
    A a;
    B b;
    Build<MultiTypes>(a,b);
    //等价于Build<MultiTypes,A,B>(a,b);
}