C++中的变长参数深入理解
前言 在吸进的一个项目中为了使用共享内存和自定义内存池,我们自己定义了 一、变长参数函数 首先回顾一下较多使用的变长参数函数,最经典的便是 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 = 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; } 变长参数函数的解析,使用到三个宏 这几个宏如何解析传入的参数呢? 函数的调用,是一个压栈,保存,跳转的过程。 简单的流程描述如下: 1、把参数从右到左依次压入栈; 2、调用 3、当前的ebp(基址指针)入栈保存,然后把当前esp(栈顶指针)赋给ebp作为新函数栈帧的基址; 4、执行被调用函数,局部变量等入栈; 5、返回值放入eax,leave,ebp赋给esp,esp所存的地址赋给ebp;(这里可能需要拷贝临时返回对象) 由于开始的时候从右至左把参数压栈, #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 上述宏定义中, 变长参数的函数的使用及其原理看了宏定义是很好理解的。从上文可知,要使用变长参数函数的参数,我们必须知道传入的每个参数的类型。 二、变长参数模板 我们需要用到C++11的新特性,变长参数模板。 这里举一个使用自定义内存池的例子。定义一个内存池类 #ifndef UTIL_MEMPOOL_H #define UTIL_MEMPOOL_H #include <stdlib.h> #define MEMPOOL_NEW_SIZE 8 template<typename T,size_t count = 1> class MemPool { private: union MemObj { char _obj[1]; 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 = 0; 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 = 0; template<typename T,count>::_size = 0; #endif 接下来在没有变长参数的情况下,实现通用 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 = 0; 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 = 0; i < count; ++i) { p[i].~T(); } } MemPool<T,count>::DeAllocate(p); } } 上述实现中,使用 引入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 = 0; i < count; ++i) { new (&p[i]) T(std::forward<Args>(args)...); } } } return p; } 以上函数定义包含了多个特性,后面我将一一解释,其中 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>(0); test<int,long>(0,0L); 以上分别是使用变长参数类模板和变长参数函数模板的例子。 2.1变长参数函数模板
递归函数方式展开,模板推导的时候,一层层递归展开,最后到没有参数时用定义的一般函数终止。 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,0L); output: int 0 int 0 long 0 逗号表达式方式展开,利用数组的参数初始化列表和逗号表达式,逐一执行 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),0)... }; } test(0,0L); output: int 0 int 0 long 0 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,long> test; std::cout << test.value; output: 12 2.3右值引用和完美转发 对于变长参数函数模板,需要将形参包展开逐个处理的需求不多,更多的还是像本文的 要理解右值引用,需要先说清楚左值和右值。左值是内存中有确定存储地址的对象的表达式的值;右值则是非左值的表达式的值。 int i =0;//i 左值 int *p = &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 右值 理解左值和右值之后,再来看引用,对左值的引用就是左值引用,对右值(纯右值和临终值)的引用就是右值引用。 如下函数 int foo(int param) { printf("%d",param); return 0; } int res = foo(0); 显然,这里的拷贝都是多余的。可能我们会想要优化,首先将参数 int foo(const int& param) { printf("%d",param); return 0; } 由于 于是有了移动语义,把临时对象的内容直接移动给被赋值的左值对象( int result = 0; int&& foo(int&& param) { printf("%d",param); return std::move(result); } int&& res = foo(0); int *pres = &res; 将 上述例子还只存在于拷贝的性能问题。回到 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)); } 可以看到最终实参总是被推导为和传入时相同的类型引用。 至此,我们讨论了变长参数模板,讨论了右值引用和函数模板的完美转发,完整的解释了 总结 以上就是这篇文章的全部内容了,希望本文的内容对大家学习或者使用C++能有所帮助,如果有疑问大家可以留言交流,谢谢大家对编程小技巧的支持。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |