C++中的变长参数

1、C+中的变长参数新参与的项目中，为了使用共享内存和自定义内存池，我们自己定义了MemNew函数，且在函数内部对于非pod类型自动执行构造函数。在需要的地方调用自定义的MemNew函数。这样就带来一个问题，使用stl的类都有默认构造函数，以及复制构造函数等。但使用共享内存和内存池的类可能没有默认构造函数，而是定义了多个参数的构造函数，于是如何将参数传入MemNew函数便成了问题。1.变长参数函数首先回顾一下较多使用的变长参数函数，最经典的便是printf。extern int printf(const char *format, .);以上是一个变长参数的函数声明。我们自己定义一个测试函数：复制

2、代码#include <stdarg.h>#include <stdio.h>int testparams(int count, .) va_list args; va_start(args, count); for (int i = 0; i < count; +i) int arg = va_arg(args, int); printf("arg %d = %d", i, arg); va_end(args); return 0;int main() testparams(3, 10, 11, 12); return 0;复制代码变长参数函

3、数的解析，使用到三个宏va_start,va_arg 和va_end，再看va_list的定义 typedef char* va_list; 只是一个char指针。这几个宏如何解析传入的参数呢？函数的调用，是一个压栈，保存，跳转的过程。简单的流程描述如下：把参数从右到左依次压入栈；调用call指令，把下一条要执行的指令的地址作为返回地址入栈；（被调用函数执行完后会回到该地址继续执行）当前的ebp（基址指针）入栈保存，然后把当前esp（栈顶指针）赋给ebp作为新函数栈帧的基址；执行被调用函数，局部变量等入栈；返回值放入eax，leave，ebp赋给esp，esp所存的地址赋给ebp；（这里可能需

4、要拷贝临时返回对象）从返回地址开始继续执行；（把返回地址所存的地址给eip） 由于开始的时候从右至左把参数压栈，va_start 传入最左侧的参数，往右的参数依次更早被压入栈，因此地址依次递增（栈顶地址最小）。va_arg传入当前需要获得的参数的类型，便可以利用 sizeof 计算偏移量，依次获取后面的参数值。复制代码 1 #define _INTSIZEOF(n) (sizeof(n) + sizeof(int) - 1) & (sizeof(int) - 1) 2 3 #define _ADDRESSOF(v) (&const_cast<char&>(r

5、einterpret_cast<const volatile char&>(v) 4 5 #define _crt_va_start_a(ap, v) (void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) 6 #define _crt_va_arg(ap, t) (*(t*)(ap += _INTSIZEOF(t) - _INTSIZEOF(t) 7 #define _crt_va_end(ap) (void)(ap = (va_list)0) 8 9 #define _crt_va_start(ap, x) (void)(_

6、vcrt_va_start_verify_argument_type<decltype(x)>(), _crt_va_start_a(ap, x)10 11 #define va_start _crt_va_start12 #define va_arg _crt_va_arg13 #define va_end _crt_va_end复制代码上述宏定义中，_INTSIZEOF(n) 将地址的低2位指令，做内存的4字节对齐。每次取参数时，调用_crt_va_arg(ap,t) ，返回t类型参数地址的值，同时将ap偏移到t之后。最后，调用_crt_va_end(ap)将ap置0.变长参数

7、的函数的使用及其原理看了宏定义是很好理解的。从上文可知，要使用变长参数函数的参数，我们必须知道传入的每个参数的类型。printf中，有format字符串中的特殊字符组合来解析后面的参数类型。但是当传入类的构造函数的参数时，我们并不知道每个参数都是什么类型，虽然参数能够依次传入函数，但无法解析并获取每个参数的数值。因此传统的变长参数函数并不足以解决传入任意构造函数参数的问题。2.变长参数模板我们需要用到C+11的新特性，变长参数模板。这里举一个使用自定义内存池的例子。定义一个内存池类MemPool.h，以count个类型T为单元分配内存，默认分配一个对象。每当内存内空闲内存不够，则一次申请MEM

8、POOL_NEW_SIZE个内存对象。内存池本身只负责内存分配，不做初始化工作，因此不需要传入任何参数，只需实例化模板分配相应类型的内存即可。复制代码 1 #ifndef UTIL_MEMPOOL_H 2 #define UTIL_MEMPOOL_H 3 4 #include <stdlib.h> 5 6 #define MEMPOOL_NEW_SIZE 8 7 8 template<typename T, size_t count = 1> 9 class MemPool10 11 private:12 union MemObj 13 char _obj1;14 Me

9、mObj* _freelink;15 ;16 17 public:18 static void* Allocate()19 20 if (!_freelist) 21 refill();22 23 MemObj* alloc_mem = _freelist;24 _freelist = _freelist->_freelink;25 +_size;26 return (void*)alloc_mem;27 28 29 static void DeAllocate(void* p)30 31 MemObj* q = (MemObj*)p;32 q->_freelink = _free

10、list;33 _freelist = q;34 -_size;35 36 37 static size_t TotalSize() 38 return _totalsize;39 40 41 static size_t Size() 42 return _size;43 44 private:45 static void refill()46 47 size_t size = sizeof(T) * count;48 char* new_mem = (char*)malloc(size * MEMPOOL_NEW_SIZE);49 for (int i = 0; i < MEMPOOL

11、_NEW_SIZE; +i) 50 MemObj* free_mem = (MemObj*)(new_mem + i * size);51 free_mem->_freelink = _freelist;52 _freelist = free_mem;53 54 _totalsize += MEMPOOL_NEW_SIZE;55 56 57 static MemObj* _freelist;58 static size_t _totalsize;59 static size_t _size;60 ;61 62 template<typename T, size_t count>

12、;63 typename MemPool<T, count>:MemObj* MemPool<T, count>:_freelist = NULL;64 65 template<typename T, size_t count>66 size_t MemPool<T, count>:_totalsize = 0;67 68 template<typename T, size_t count>69 size_t MPool<T, count>:_size = 0;70 #endif复制代码 接下来在没有变长参数的情况下，实现

13、通用MemNew和MemDelete函数模板。这里不对函数模板作详细解释，用函数模板我们可以对不同的类型实现同样的内存池分配操作。如下：复制代码 1 template<class T> 2 T *MemNew(size_t count) 3 4 T *p = (T*)MemPool<T, count>:Allocate(); 5 if (p != NULL) 6 7 if (!std:is_pod<T>:value) 8 9 for (size_t i = 0; i < count; +i)10 11 new (&pi) T();12 13 1

14、4 15 return p;16 17 18 template<class T>19 T *MemDelete(T *p, size_t count)20 21 if (p != NULL)22 23 if (!std:is_pod<T>:value)24 25 for (size_t i = 0; i < count; +i)26 27 pi.T();28 29 30 MemPool<T, count>:DeAllocate(p);31 32 复制代码上述实现中，使用placement new对申请的内存进行构造，使用了默认构造函数，当申请内存的类型

15、不具备默认构造函数时，placement new将报错。对于pod类型，可以省去调用构造函数的过程。引入C+11变长模板参数后MemNew修改为如下复制代码 1 template<class T, class. Args> 2 T *MemNew(size_t count, Args&&. args) 3 4 T *p = (T*)MemPool<T, count>:Allocate(); 5 if (p != NULL) 6 7 if (!std:is_pod<T>:value) 8 9 for (size_t i = 0; i <

16、count; +i)10 11 new (&pi) T(std:forward<Args>(args).);12 13 14 15 return p;16 复制代码以上函数定义包含了多个特性，后面我将一一解释，其中class. Args 表示变长参数模板，函数参数中Args&& 为右值引用。std:forward<Args> 实现参数的完美转发。这样，无论传入的类型具有什么样的构造函数，都能够完美执行placement new。C+11中引入了变长参数模板的概念，来解决参数个数不确定的模板。复制代码 1 template<class. T&

17、gt; class Test ; 2 Test<> test0; 3 Test<int> test1; 4 Test<int,int> test2; 5 Test<int,int,long> test3; 6 7 template<class. T> void test(T. args); 8 test(); 9 test<int>(0);10 test<int,int,long>(0,0,0L);复制代码以上分别是使用变长参数类模板和变长参数函数模板的例子。2.1变长参数函数模板T. args 为形参包，其中

18、args是模式，形参包中可以有0到任意多个参数。调用函数时，可以传任意多个实参。对于函数定义来说，该如何使用参数包呢？在上文的MemNew中，我们使用std:forward依次将参数包传入构造函数，并不关注每个参数具体是什么。如果需要，我们可以用sizeof.(args)操作获取参数个数，也可以把参数包展开，对每个参数做更多的事。展开的方法有两种，递归函数，逗号表达式。递归函数方式展开，模板推导的时候，一层层递归展开，最后到没有参数时用定义的一般函数终止。复制代码 1 void test() 2 3 4 5 template<class T, class. Args> 6 void

19、 test(T first, Args. args) 7 8 std:cout << typeid(T).name() << " " << first << std:endl; 9 test(args.);10 11 12 test<int, int, long>(0, 0, 0L);13 14 output:15 int 016 int 017 long 0复制代码逗号表达式方式展开，利用数组的参数初始化列表和逗号表达式，逐一执行print每个参数。复制代码 1 template<class T> 2

20、 void print(T arg) 3 4 std:cout << typeid(T).name() << " " << arg << std:endl; 5 6 7 template<class. Args> 8 void test(Args. args) 9 10 int arr = (print(args), 0). ;11 12 13 test(0, 0, 0L);14 15 output:16 int 017 int 018 long 0复制代码 2.2变长参数类模板 变长参数类模板，一般情况下可以方便

21、我们做一些编译期计算。可以通过偏特化和递归推导的方式依次展开模板参数。复制代码 1 template<class T, class. Types> 2 class Test 3 4 public: 5 enum 6 value = Test<T>:value + Test<Types.>:value, 7 ; 8 ; 9 10 template<class T>11 class Test<T>12 13 public:14 enum 15 value = sizeof(T),16 ;17 ;18 19 Test<int, int

22、, long> test;20 std:cout << test.value;21 22 output: 12复制代码 2.3右值引用和完美转发 对于变长参数函数模板，需要将形参包展开逐个处理的需求不多，更多的还是像本文的MemNew这样的需求，最终整个传入某个现有的函数。我们把重点放在参数的传递上。要理解右值引用，需要先说清楚左值和右值。左值是内存中有确定存储地址的对象的表达式的值；右值则是非左值的表达式的值。const左值不可被赋值，临时对象的右值可以被赋值。左值与右值的根本区别在于是否能用&运算符获得内存地址。复制代码int i =0;/i 左值int *p =

23、 &i;/ i 左值int& foo();foo() = 42;/ foo() 左值int* p1 = &foo();/ foo() 左值int foo1();int j = 0;j = foo1();/ foo 右值int k = j + 1;/ j + 1 右值int *p2 = &foo1(); / 错误，无法取右值的地址j = 1;/ 1 右值复制代码理解左值和右值之后，再来看引用，对左值的引用就是左值引用，对右值（纯右值和临终值）的引用就是右值引用。如下函数foo，传入int类型，返回int类型，这里传入函数的参数0和返回值0都是右值(不能用&

24、取得地址)。于是，未做优化的情况下，传入参数0的时候，我们需要把右值0拷贝给param，函数返回的时候需要将0拷贝给临时对象，临时对象再拷贝给res。当然现在的编译器都做了返回值优化，返回对象是直接创建在返回后的左值上的，这里只用来举个例子复制代码int foo(int param) printf("%d", param); return 0;int res = foo(0);复制代码显然，这里的拷贝都是多余的。可能我们会想要优化，首先将参数int改为int&，传入左值引用，于是0无法传入了，当然我们可以改成const int&，这样终于省去了传参的拷贝。i

25、nt foo(const int& param) printf("%d", param); return 0;由于const int& 既可以是左值也可以是右值，传入0或者int变量都能够满足。(但是似乎既然有左值引用的int&类型，就应该有对应的传入右值引用的类型int&&)。另外，这里返回的右值0，似乎不通过拷贝就无法赋值给左值res。于是有了移动语义，把临时对象的内容直接移动给被赋值的左值对象(std:move)。和右值引用，X&&是到数据类型X的右值引用。复制代码int result = 0;int&&

26、amp; foo(int&& param) printf("%d", param); return std:move(result);int&& res = foo(0);int *pres = &res;复制代码将foo改为右值引用参数和返回值，返回右值引用，免去拷贝。这里res是具名引用，运算符右侧的右值引用作为左值，可以取地址。右值引用既有左值性质，也有右值性质。 上述例子还只存在于拷贝的性能问题。回到MemNew这样的函数模板。复制代码 1 template<class T> 2 T* Test(T arg) 3

27、4 return new T(arg); 5 6 7 template<class T> 8 T* Test(T& arg) 9 10 return new T(arg);11 12 13 template<class T>14 T* Test(const T& arg)15 16 return new T(arg);17 18 19 template<class T>20 T* Test(T&& arg)21 22 return new T(std:forward<T>(arg);23 复制代码上述的前三种方式传

28、参，第一种首先有拷贝消耗，其次有的参数就是需要修改的左值。第二种方式则无法传常数等右值。第三种方式虽然左值右值都能传，却无法对传入的参数进行修改。第四种方式使用右值引用，可以解决参数完美转发的问题。std:forward能够根据实参的数据类型，返回相应类型的左值和右值引用，将参数完整不动的传递下去。解释这个原理涉及到引用塌缩规则T& & ->T&T& &&->T& T&& &->T&T&& &&->T&&复制代码 1 template&

29、lt; class T > struct remove_reference typedef T type; 2 template< class T > struct remove_reference<T&> typedef T type; 3 template< class T > struct remove_reference<T&&> typedef T type; 4 5 template< class T > T&& forward( typename std:remove_ref

30、erence<T>:type& t ) 6 7 return static_cast<T&&>(t); 8 9 10 template<class T>11 typename std:remove_reference<T>:type&& move(T&& a) noexcept12 13 return static_cast<typename std:remove_reference<T>:type&&>(a);14 复制代码对于函数模板template<class T>T*