C 可变长参数 VS C++11 可变长模板

分类： C/C++语言2014-07-03 13:50 1088人阅读 评论(0) 收藏 举报

有些时候，我们定义一个函数，可能这个函数需要支持可变长参数，也就是说调用者可以传入任意个数的参数。比如C函数printf().

我们可以这么调用。

[cpp] view plaincopy

1. printf("name: %s, number: %d", "Obama", 1);  

那么这个函数是怎么实现的呢？其实C语言支持可变长参数的。

我们举个例子，

[cpp] view plaincopy

1. double Sum(int count, ...)  
2. {  
3.     va_list ap;  
4.     double sum = 0;  
5.   
6.     va_start(ap, count);  
7.   
8.     for (int i = 0; i < count; ++i)  
9.     {  
10.         double arg = va_arg(ap, double);  
11.         sum += arg;  
12.     }  
13.   
14.     va_end(ap);  
15.   
16.     return sum;  
17. }  

上面这个函数，接受变长参数，用来把所有输入参数累加起来。可以这么调：

[cpp] view plaincopy

1. double sum = Sum(4, 1.0, 2.0, 3.0, 4.0);  

计算结果是10，很好。

那么C语言的这个函数有什么问题呢？

1. 函数本身并不知道传进来几个参数，比如我现在多传一个参数，或者少传一个参数，那么函数本身是检测不到这个问题的。这就可能会导致未定义的错误。

2. 函数本身也不知道传进来的参数类型。以上面的例子，假如我把第二个参数1.0改成一个字符串，又如何？答案就是会得到未定义的错误，也就是不知道会发生什么。

3. 对于可变长参数，我们只能用__cdecl调用约定，因为只有调用者才知道传进来几个参数，那么也只有调用者才能维持栈平衡。如果是__stdcall,那么函数需要负责栈平衡，可是函数本身根本不知道有几个参数，函数调用结束后，根本不知道需要将几个参数pop out。（注：某些编译器如VS，如果用户写了个__stdcall的可变长参数函数，VS会自动转换成__cdecl的，当然这是编译器干的事情）

在C++语言里面，在C++11之前，C++也只是兼容了C的这种写法，而C++本身并没有更好的替代方案。其实对于C++这种强类型语言而言，C的这种可变长方案等于是开了个后门，函数居然不知道传进来的参数是什么类型。所以在C++11里面专门提供了对可变长参数的更现代化的支持，那就是可变长模板。

模板参数包(template parameter pack)

[cpp] view plaincopy

1. template<typename... A> class Car;  

typename...就表示一个模板参数包。可以这么来实例化模板：

[cpp] view plaincopy

1. Car<int, char> car;  

再来看一个更加具体的例子：

[cpp] view plaincopy

1. template<typename T1, typename T2> class Car{};  
2. template<typename... A> class BMW : public Car<A...>{};  
3. BMW<int, char> car;  

在这个例子里面，BMW是一个可变参数的模板，它继承于类Car. 那么BMW<int, char> car;在进行模板推导的时候，可以认为变成Car<int, char>了。这其中的功劳应该属于A...,

A...称之为包扩展(pack extension)，包扩展是可以传递的。比如继承的时候，或者直接在函数参数里面传递。然后当编译器进行推导的时候，就会对这个包扩展进行展开，上面的例子，A...就展开成了int, char。C++11定义了可以展开包的几个地方：

1. 表达式

2. 初始化列表

3. 基类描述列表

4. 类成员初始化列表

5. 模板参数列表

6. 通用属性列表

7. lamda函数的捕捉列表

其他地方是不能展开的。

针对上面的例子，如果我们改成BMW<int, char, int> car, 会如何呢？编译的时候就直接报错了，

Error 1  error C2977: 'Car' : too many template arguments d:\study\consoleapplication2\variablelengthparameters\variablelengthparameters.cpp271VariableLengthParameters
这是因为当展开的时候，A...变成了int, char, int了，可能基类根本就没有3个模板参数，所以推导就出错了。那如果这样的话，可变长参数还是啥意义呢？这等于每次的参数个数还是固定的啊。当然不会这么傻，其实C++11可以通过递归来实现真正的可变长的。看下面的代码。

[cpp] view plaincopy

1. template<typename... A> class BMW{};  
2.   
3. template<typename Head, typename... Tail>  
4. class BMW<Head, Tail...> : public BMW<Tail...>  
5. {  
6. public:  
7.     BMW()  
8.     {  
9.         printf("type: %s\n", typeid(Head).name());  
10.     }  
11. private:  
12.     Head head;  
13. };  
14.   
15. template<> class BMW<>{};  // 边界条件  
16.   
17. BMW<int, char, float> car;  

如果我们运行这段代码，会发现构造函数被调用了3次。第一次得到的类型是float，第二次是char，第三次是int。这就好像模板实例化的时候层层展开了。实际上也就是这么一回事情。这里使用了C++模板的特化来实现了递归，每递归一次就得到一个类型。看一下对象car里面有什么：

可以清晰的看到car里面有三个head。基类里面的head是float，第二个head是char，第三个head是int。

有了这个基础之后，我们就可以实现我们的可变长模板类了，std::tuple就是个很好的例子。可以看看它的源代码，这里就不再介绍了。

可变长模板不光可以用于类的定义，也可以用户函数模板。接下来，就用可变长参数来实现一个Sum函数，然后跟上面的C语言版本做对比。

可变长模板实现Sum函数

直接看代码：

[cpp] view plaincopy

1. template<typename T1, typename... T2> double Sum2(T1 p, T2... arg)  
2. {  
3.     double ret = p + Sum2(arg...);  
4.   
5.     return ret;  
6. }  
7.   
8. double Sum2()  // 边界条件  
9. {  
10.     return 0;  
11. }  

在上面的代码里面，可以很清楚的看到递归。

[cpp] view plaincopy

1. double ret2 = Sum2(1.0, 2.0, 3.0, 4.0);  

这条调用代码同样得到结果10.这样过程可以理解为，边界条件的函数先执行完毕，然后4.0的执行完毕，再3.0，2.0，1.0以此被执行完毕。一个典型的递归。

ok，那么跟C语言版本相比，又有哪些好处呢？

变长模板优点

之前提到的几个C语言版本的主要缺点：

1. 参数个数，那么对于模板来说，在模板推导的时候，就已经知道参数的个数了，也就是说在编译的时候就确定了，这样编译器就存在可能去优化代码。

2. 参数类型，推导的时候也已经确定了，模板函数就可以知道参数类型了。

3. 既然编译的时候就知道参数个数和参数类型了，那么调用约定也就没有限制了。

来实验一下第二点吧

[cpp] view plaincopy

1. int _tmain(int argc, _TCHAR* argv[])  
2. {  
3.     double ret1 = Sum(4, 1.0, 2.0, 3.0, 4.0, "abcd");  
4.     double ret2 = Sum2(1.0, 2.0, 3.0, 4.0, "abcd");  
5.       
6.       
7.     return 0;  
8. }  

Sum是C语言版本，最后一个参数传了个字符串，但是Sum函数是无法检测这个错误的。结果也就是未定义。

Sum2是个模板函数，最后一个参数也是字符串，在编译的时候就报错了，

Error 1  error C2111: '+' : pointer addition requires integral operandd:\study\consoleapplication2\variablelengthparameters\variablelengthparameters.cpp291VariableLengthParameters

double无法和字符串相加，这样在编译的时候就告诉我们这个错误了，我们就可以修复它，但是C语言的版本不会报错，代码也就失控了，不知道会得到什么结果。

怎么样，变长模板比C语言的变长参数好一些吧。

所以，我们还是尽可能使用C++11的变长模板吧。

最后一个问题，为什么使用变长参数呢？有些人可能会问，是不是可以把所有的参数放到一个list里面，然后函数遍历整个list，再相加呢？good point， 

如果所有的参数类型都一样，确实可以这么做，但是如果参数类型不一样呢？那怎么放到一个list里面？像C++这种强类型语言可能做不到吧，确实弱类型语言比如php，python等，确实可以这么做。根据我的理解，脚本语言等弱类型语言不需要变长参数吧，或者不重要。但是C++还是需要的，

用可变长模板就没这个问题了，就算参数类型不一样，只要对应的类型有对应的操作，就没问题。当然像上面的例子，如果没有重载+,那么编译的时候就报错，这不就是我们需要的吗?

转自：http://blog.csdn.net/zj510/article/details/36633603

C++11 可变参数模板

2013-11-18 07:56:00cnblogs.com-Todd Pointer-点击数:916

在C++11之前， 有两个典型的受制于模板功能不强而导致代码重复难看的问题， 那就 function object 和 tuple。 拿 function objects 来说， 需要一个返回类型参数及N个参数类型参数。 但因为变长参数模板不受支持，导致不得不重复书写7、8个模板类，但最终也只能支持7、8个参数的 function object。C++11中最终为我们带来了强大的变长 参数模板功能，这些问题也随之迎刃而解了。 

可变参数模板（Variadic Template）故名思义，即可以接受任意数量参数的类/函数模板。 其声明方式为

template<typename... Args>class VariadicTemplate;

当然non-type参数也是支持的比如 template<int... Args> class VariadicIntTemplate;

这里Args代表0-N个类型参数，也就是说VariadicTemplate<>也是有效的模板实例。

C++11 翻新了省略号(...)操作符来支持对这种模板参数的访问及使用。

类型展开

将所有模板参数展开在当前位置，用来调用其它模板、声明函数指针类型

template<typename ...Args>int foo() {    int (*p)(Args...) = bar<Args...>;    p(1, 0.5);    return bar<Args...>(1, 0.5); }

对于 foo<int, float> 实例，其 p 的类型为 int (*)(int, float) 而 return 语句将调用 bar<int, float>(1, 0.5)

此外还可以展开类型参数用来指定基类列表

template<typename... Args>class foo : Args...{};foo<bar, barz> f; // 该类继承 bar, barz 两个基类

Parameter Packs / Initialization Lists

通过省略号操作符可以声明参数包，这些参数包可以在函数的参数位置展开。

template<typename ...Args>void foo(Args... args) {}

当使用 foo<int, float> 时，其有两参数，一个整数，一个float，因此调用方法为 foo<int, float>(1, 0.1f);

此外还可以将参数包展开到构造函数的初始化列表

template<typename... Args>class foo : Args...{public:    foo(Args...args):Args(args)...{    }};foo<bar, barz> f(bar(), barz());

sizeof... operator

要获取模板变长参数的实参长度，使用 sizeof... 运算符，它也可以被用于 Parameter Packs

template<typename ... Args>size_t foo() {    return sizeof...(Args);}template<typename ... Args>size_t fooz(Args ...args) {    return sizeof...(args);}

以上就是变长参数的基本用法，但真正发挥作用，往往还要借助模板特化 (Template Specialization)

可变参数模板与模板特化

可变参数模板与普通模板一样，可以进行特化，从而实现一些有意义的模式

template<typename ... Args>void output(Args ... args) {}template<typename Arg0, typename ... Args>void output(Arg0 arg0, Args ... args) {    std::cout << arg0;    output<Args...>(args...);}template<>void output() {}/*------------------------------*/typedef decltype(std::cout) cout_type;auto endl = std::endl<cout_type::char_type, cout_type::traits_type>;output(1, 0.3, (void*)nullptr, "string", 'c', endl);

以上代码输出

10.30stringc

转自： http://www.th7.cn/Program/cp/201311/159661.shtml