C++中的变长参数

　　新参与的项目中，为了使用共享内存和自定义内存池，我们自己定义了MemNew函数，且在函数内部对于非pod类型自动执行构造函数。在需要的地方调用自定义的MemNew函数。这样就带来一个问题，使用stl的类都有默认构造函数，以及复制构造函数等。但使用共享内存和内存池的类可能没有默认构造函数，而是定义了多个参数的构造函数，于是如何将参数传入MemNew函数便成了问题。

1.变长参数函数

　　首先回顾一下较多使用的变长参数函数，最经典的便是printf。

extern int printf(const char *format, ...);

　　以上是一个变长参数的函数声明。我们自己定义一个测试函数：

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

int testparams(int count, ...)
{
    va_list args;
    va_start(args, count);
    for (int i = ; i < count; ++i)
    {
        int arg = va_arg(args, int);
        printf("arg %d = %d", i, arg);
    }
    va_end(args);
    return ;
}

int main()
{
    testparams(, , , );
    return ;
}

　　变长参数函数的解析，使用到三个宏va_start,va_arg 和va_end，再看va_list的定义 typedef char* va_list; 只是一个char指针。

　　这几个宏如何解析传入的参数呢？

　　函数的调用，是一个压栈，保存，跳转的过程。简单的流程描述如下：

1. 把参数从右到左依次压入栈；
2. 调用call指令，把下一条要执行的指令的地址作为返回地址入栈；（被调用函数执行完后会回到该地址继续执行）
3. 当前的ebp（基址指针）入栈保存，然后把当前esp（栈顶指针）赋给ebp作为新函数栈帧的基址；
4. 执行被调用函数，局部变量等入栈；
5. 返回值放入eax，leave，ebp赋给esp，esp所存的地址赋给ebp；（这里可能需要拷贝临时返回对象）
6. 从返回地址开始继续执行；（把返回地址所存的地址给eip）

　　由于开始的时候从右至左把参数压栈，va_start 传入最左侧的参数，往右的参数依次更早被压入栈，因此地址依次递增（栈顶地址最小）。va_arg传入当前需要获得的参数的类型，便可以利用 sizeof 计算偏移量，依次获取后面的参数值。

 #define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))

 #define _ADDRESSOF(v) (&const_cast<char&>(reinterpret_cast<const volatile char&>(v)))

 #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))
 #define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
 #define __crt_va_end(ap)        ((void)(ap = (va_list)0))

 #define __crt_va_start(ap, x) ((void)(__vcrt_va_start_verify_argument_type<decltype(x)>(), __crt_va_start_a(ap, x)))

 #define va_start __crt_va_start
 #define va_arg   __crt_va_arg
 #define va_end   __crt_va_end

　　上述宏定义中，_INTSIZEOF(n) 将地址的低2位指令，做内存的4字节对齐。每次取参数时，调用__crt_va_arg(ap,t) ，返回t类型参数地址的值，同时将ap偏移到t之后。最后，调用_crt_va_end(ap)将ap置0.

　　变长参数的函数的使用及其原理看了宏定义是很好理解的。从上文可知，要使用变长参数函数的参数，我们必须知道传入的每个参数的类型。printf中，有format字符串中的特殊字符组合来解析后面的参数类型。但是当传入类的构造函数的参数时，我们并不知道每个参数都是什么类型，虽然参数能够依次传入函数，但无法解析并获取每个参数的数值。因此传统的变长参数函数并不足以解决传入任意构造函数参数的问题。

2.变长参数模板

　　我们需要用到C++11的新特性，变长参数模板。

　　这里举一个使用自定义内存池的例子。定义一个内存池类MemPool.h，以count个类型T为单元分配内存，默认分配一个对象。每当内存内空闲内存不够，则一次申请MEMPOOL_NEW_SIZE个内存对象。内存池本身只负责内存分配，不做初始化工作，因此不需要传入任何参数，只需实例化模板分配相应类型的内存即可。

 #ifndef UTIL_MEMPOOL_H
 #define UTIL_MEMPOOL_H

 #include <stdlib.h>

 #define MEMPOOL_NEW_SIZE 8

 template<typename T, size_t count = >
 class MemPool
 {
 private:
     union MemObj {
         char _obj[];
         MemObj* _freelink;
     };

 public:
     static void* Allocate()
     {
         if (!_freelist) {
             refill();
         }
         MemObj* alloc_mem = _freelist;
         _freelist = _freelist->_freelink;
         ++_size;
         return (void*)alloc_mem;
     }

     static void DeAllocate(void* p)
     {
         MemObj* q = (MemObj*)p;
         q->_freelink = _freelist;
         _freelist = q;
         --_size;
     }

     static size_t TotalSize() {
         return _totalsize;
     }

     static size_t Size() {
         return _size;
     }
 private:
     static void refill()
     {
         size_t size = sizeof(T) * count;
         char* new_mem = (char*)malloc(size * MEMPOOL_NEW_SIZE);
         for (int i = ; i < MEMPOOL_NEW_SIZE; ++i) {
             MemObj* free_mem = (MemObj*)(new_mem + i * size);
             free_mem->_freelink = _freelist;
             _freelist = free_mem;
         }
         _totalsize += MEMPOOL_NEW_SIZE;
     }

     static MemObj* _freelist;
     static size_t _totalsize;
     static size_t _size;
 };

 template<typename T, size_t count>
 typename MemPool<T, count>::MemObj* MemPool<T, count>::_freelist = NULL;

 template<typename T, size_t count>
 size_t MemPool<T, count>::_totalsize = ;

 template<typename T, size_t count>
 size_t MemPool<T, count>::_size = ;
 #endif

　　接下来在没有变长参数的情况下，实现通用MemNew和MemDelete函数模板。这里不对函数模板作详细解释，用函数模板我们可以对不同的类型实现同样的内存池分配操作。如下：

 template<class T>
 T *MemNew(size_t count)
 {
     T *p = (T*)MemPool<T, count>::Allocate();
     if (p != NULL)
     {
         if (!std::is_pod<T>::value)
         {
             for (size_t i = ; i < count; ++i)
             {
                 new (&p[i]) T();
             }
         }
     }
     return p;
 }

 template<class T>
 T *MemDelete(T *p, size_t count)
 {
     if (p != NULL)
     {
         if (!std::is_pod<T>::value)
         {
             for (size_t i = ; i < count; ++i)
             {
                 p[i].~T();
             }
         }
         MemPool<T, count>::DeAllocate(p);
     }
 }

　　上述实现中，使用placement new对申请的内存进行构造，使用了默认构造函数，当申请内存的类型不具备默认构造函数时，placement new将报错。对于pod类型，可以省去调用构造函数的过程。

　　引入C++11变长模板参数后MemNew修改为如下

 template<class T, class... Args>
 T *MemNew(size_t count, Args&&... args)
 {
     T *p = (T*)MemPool<T, count>::Allocate();
     if (p != NULL)
     {
         if (!std::is_pod<T>::value)
         {
             for (size_t i = ; i < count; ++i)
             {
                 new (&p[i]) T(std::forward<Args>(args)...);
             }
         }
     }
     return p;
 }

　　以上函数定义包含了多个特性，后面我将一一解释，其中class... Args 表示变长参数模板，函数参数中Args&& 为右值引用。std::forward<Args> 实现参数的完美转发。这样，无论传入的类型具有什么样的构造函数，都能够完美执行placement new。

　　C++11中引入了变长参数模板的概念，来解决参数个数不确定的模板。

 template<class... T> class Test {};
 Test<> test0;
 Test<int> test1;
 Test<int,int> test2;
 Test<int,int,long> test3;

 template<class... T> void test(T... args);
 test();
 test<int>();
 test<int,int,long>(,,0L);

　　以上分别是使用变长参数类模板和变长参数函数模板的例子。

2.1变长参数函数模板

　　T... args 为形参包，其中args是模式，形参包中可以有0到任意多个参数。调用函数时，可以传任意多个实参。对于函数定义来说，该如何使用参数包呢？在上文的MemNew中，我们使用std::forward依次将参数包传入构造函数，并不关注每个参数具体是什么。如果需要，我们可以用sizeof...(args)操作获取参数个数，也可以把参数包展开，对每个参数做更多的事。展开的方法有两种，递归函数，逗号表达式。

　　递归函数方式展开，模板推导的时候，一层层递归展开，最后到没有参数时用定义的一般函数终止。

 void test()
 {
 }

 template<class T, class... Args>
 void test(T first, Args... args)
 {
     std::cout << typeid(T).name() << " " << first << std::endl;
     test(args...);
 }

 test<int, int, long>(, , 0L);

 output:
 int
 int
 long 

　　逗号表达式方式展开，利用数组的参数初始化列表和逗号表达式，逐一执行print每个参数。

 template<class T>
 void print(T arg)
 {
     std::cout << typeid(T).name() << " " << arg << std::endl;
 }

 template<class... Args>
 void test(Args... args)
 {
     int arr[] = { (print(args), )... };
 }

 test(, , 0L);

 output:
 int
 int
 long 

2.2变长参数类模板

　　变长参数类模板，一般情况下可以方便我们做一些编译期计算。可以通过偏特化和递归推导的方式依次展开模板参数。

 template<class T, class... Types>
 class Test
 {
 public:
     enum {
         value = Test<T>::value + Test<Types...>::value,
     };
 };

 template<class T>
 class Test<T>
 {
 public:
     enum {
         value = sizeof(T),
     };
 };

 Test<int, int, long> test;
 std::cout << test.value;

 output: 

2.3右值引用和完美转发

　　对于变长参数函数模板，需要将形参包展开逐个处理的需求不多，更多的还是像本文的MemNew这样的需求，最终整个传入某个现有的函数。我们把重点放在参数的传递上。

　　要理解右值引用，需要先说清楚左值和右值。左值是内存中有确定存储地址的对象的表达式的值；右值则是非左值的表达式的值。const左值不可被赋值，临时对象的右值可以被赋值。左值与右值的根本区别在于是否能用&运算符获得内存地址。

int i =;//i 左值
int *p = &i;// i 左值
int& foo();
foo() = ;// foo() 左值
int* p1 = &foo();// foo() 左值

int foo1();
int j = ;
j = foo1();// foo 右值
int k = j + ;// j + 1 右值
int *p2 = &foo1(); // 错误，无法取右值的地址
j = ;// 1 右值

　　理解左值和右值之后，再来看引用，对左值的引用就是左值引用，对右值（纯右值和临终值）的引用就是右值引用。

　　如下函数foo，传入int类型，返回int类型，这里传入函数的参数0和返回值0都是右值(不能用&取得地址)。于是，未做优化的情况下，传入参数0的时候，我们需要把右值0拷贝给param，函数返回的时候需要将0拷贝给临时对象，临时对象再拷贝给res。当然现在的编译器都做了返回值优化，返回对象是直接创建在返回后的左值上的，这里只用来举个例子

int foo(int param)
{
    printf("%d", param);
    return ;
}

int res = foo();

　　显然，这里的拷贝都是多余的。可能我们会想要优化，首先将参数int改为int&，传入左值引用，于是0无法传入了，当然我们可以改成const int&，这样终于省去了传参的拷贝。

int foo(const int& param)
{
    printf("%d", param);
    return ;
}

　　由于const int& 既可以是左值也可以是右值，传入0或者int变量都能够满足。(但是似乎既然有左值引用的int&类型，就应该有对应的传入右值引用的类型int&&)。另外，这里返回的右值0，似乎不通过拷贝就无法赋值给左值res。

于是有了移动语义，把临时对象的内容直接移动给被赋值的左值对象(std::move)。和右值引用，X&&是到数据类型X的右值引用。

int result = ;
int&& foo(int&& param)
{
    printf("%d", param);
    return std::move(result);
}

int&& res = foo();
int *pres = &res;

　　将foo改为右值引用参数和返回值，返回右值引用，免去拷贝。这里res是具名引用，运算符右侧的右值引用作为左值，可以取地址。右值引用既有左值性质，也有右值性质。

　　上述例子还只存在于拷贝的性能问题。回到MemNew这样的函数模板。

 template<class T>
 T* Test(T arg)
 {
     return new T(arg);
 }

 template<class T>
 T* Test(T& arg)
 {
     return new T(arg);
 }

 template<class T>
 T* Test(const T& arg)
 {
     return new T(arg);
 }

 template<class T>
 T* Test(T&& arg)
 {
     return new T(std::forward<T>(arg));
 }

　　上述的前三种方式传参，第一种首先有拷贝消耗，其次有的参数就是需要修改的左值。第二种方式则无法传常数等右值。第三种方式虽然左值右值都能传，却无法对传入的参数进行修改。第四种方式使用右值引用，可以解决参数完美转发的问题。

　　std::forward能够根据实参的数据类型，返回相应类型的左值和右值引用，将参数完整不动的传递下去。

　　解释这个原理涉及到引用塌缩规则

　　T& & ->T&

　　T& &&->T&

T&& &->T&

　　T&& &&->T&&

 template< class T > struct remove_reference      {typedef T type;};
 template< class T > struct remove_reference<T&>  {typedef T type;};
 template< class T > struct remove_reference<T&&> {typedef T type;};

 template< class T > T&& forward( typename std::remove_reference<T>::type& t )
 {
   return static_cast<T&&>(t);
 }

 template<class T>
 typename std::remove_reference<T>::type&& move(T&& a) noexcept
 {
   return static_cast<typename std::remove_reference<T>::type&&>(a);
 }

　　对于函数模板

template<class T>
T* Test(T&& arg)
{
    return new T(std::forward<T>(arg));
}

　　当传入实参为X类型左值时，T为X&，最后的类型为X&。当实参为X类型右值时，T为X，最后的类型为X&&。

　　x为左值时：

X x;
Test(x);

　　T为X&，实例化后

X& && std::forward(remove_reference<X&>::type& a) noexcept
{
    return static_cast<X& &&>(a);
}

X* Test(X& && arg)
{
    return new X(std::forward<X&>(arg));
}

// 塌陷后

X& std::forward(X& a)
{
    return static_cast<X&>(a);
}

X* Test(X& arg)
{
    return new X(std::forward<X&>(arg));
}

　　x为右值时：

X foo();
Test(foo());

　　T为X，实例化后

X&& std::forward(remove_reference<X>::type& a) noexcept
{
    return static_cast<X&&>(a);
}

X* Test(X&& arg)
{
    return new X(std::forward<X>(arg));
}

// 塌陷后

X&& std::forward(X& a)
{
    return static_cast<X&&>(a);
}

X* Test(X&& arg)
{
    return new X(std::forward<X>(arg));
}

　　可以看到最终实参总是被推导为和传入时相同的类型引用。

　　至此，我们讨论了变长参数模板，讨论了右值引用和函数模板的完美转发，完整的解释了MemNew对任意多个参数的构造函数的参数传递过程。利用变长参数函数模板，右值引用和std::forward，可以完成参数的完美转发。