C,C++可变长参数实现

系统管理员 2022-09-18 14:54 239阅读 0赞

转帖地址1：[http://www.cnblogs.com/CUCmehp/archive/2008/12/18/1357438.html][http_www.cnblogs.com_CUCmehp_archive_2008_12_18_1357438.html]

转帖地址2：[http://blog.csdn.net/cnsword/article/details/8022729][http_blog.csdn.net_cnsword_article_details_8022729]

地址3：[http://blog.sina.com.cn/s/blog\_7b62c61c0100swnx.html][http_blog.sina.com.cn_s_blog_7b62c61c0100swnx.html]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/\*  
 函数名: vsprintf  
 功 能: 送格式化输出到串中  
 返回值: 正常情况下返回生成字串的长度(除去\\0),错误情况返回负值  
 用 法: int vsprintf(char \*string, char \*format, va\_list param);  
 // 将param 按格式format写入字符串string中  
 注: 该函数会出现内存溢出情况,建议使用vsnprintf  
\*/

\#include <stdarg.h>  
\#include <stdio.h>  
char buffer\[80\];  
int vspf(char \*fmt, ...)  
\{  
  va\_list argptr;  
  int cnt;  
  va\_start(argptr, fmt);  
  cnt = vsprintf(buffer, fmt, argptr);//vsprintf使用时可以不调用va\_end  
  va\_end(argptr);  
  return(cnt);  
\}  
 int main(void)  
 \{  
  int inumber = 30;  
  float fnumber = 90.0;  
  char string\[4\] = "abc";  
  vspf("%d %f %s", inumber, fnumber, string);  
  printf("%s\\n", buffer);  
 getchar();  
 return 0;  
\}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[转：C/C++变长参数的实现][http_www.cnblogs.com_CUCmehp_archive_2008_12_18_1357438.html]

很多技术人员都有在"技术细节"上"钻牛角尖"的"癖好"，对此很多人褒贬不一；无论怎样，我也是属于这类人。C语言的变长参数在平时做开发时很少会在自己设计的接口中用到，但我们最常用的接口printf就是使用的变长参数接口，在感受到printf强大的魅力的同时，是否想挖据一下到底printf是如何实现的呢？这里我们一起来挖掘一下C语言变长参数的奥秘。  
  
先考虑这样一个问题：如果我们不使用C标准库(libc)中提供的Facilities，我们自己是否可以实现拥有变长参数的函数呢？我们不妨试试。  
  
一步一步进入正题，我们先看看固定参数列表函数，  
void fixed\_args\_func(int a, double b, char \*c) \{  
printf("a = 0x%p\\n", &a);  
printf("b = 0x%p\\n", &b);  
printf("c = 0x%p\\n", &c);  
\}  
对于固定参数列表的函数，每个参数的名称、类型都是直接可见的，他们的地址也都是可以直接得到的，比如：通过&a我们可以得到a的地址，并通过函数原型声明了解到a是int类型的; 通过&b我们可以得到b的地址，并通过函数原型声明了解到b是double类型的; 通过&c我们可以得到c的地址，并通过函数原型声明了解到c是char\*类型的。  
  
但是对于变长参数的函数，我们就没有这么顺利了。还好，按照C标准的说明，支持变长参数的函数在原型声明中，必须有至少一个最左固定参数(这一点与传统C有区别，传统C允许不带任何固定参数的纯变长参数函数)，这样我们可以得到其中固定参数的地址，但是依然无法从声明中得到其他变长参数的地址，比如：  
void var\_args\_func(const char \* fmt, ... ) \{  
  ... ...  
\}  
这里我们只能得到fmt这固定参数的地址，仅从函数原型我们是无法确定"..."中有几个参数、参数都是什么类型的，自然也就无法确定其位置了。那么如何可以做到呢？在大脑中回想一下函数传参的过程，无论"..."中有多少个参数、每个参数是什么类型的，它们都和固定参数的传参过程是一样的，简单来讲都是[栈操作][Link 1]，而栈这个东西对我们是开放的。这样一来，一旦我们知道某函数帧的栈上的一个固定参数的位置，我们完全有可能推导出其他变长参数的位置，顺着这个思路，我们继续往下走，通过一个例子来诠释一下：(这里要说明的是：函数参数进栈以及参数空间地址分配都是"实现相关"的，不同平台、不同编译器都可能不同，所以下面的例子仅在IA-32，Windows XP， MinGW gcc v3.4.2下成立)  
  
我们先用上面的那个fixed\_args\_func函数确定一下这个平台下的入栈顺序。  
  
int main() \{  
  fixed\_args\_func(17, 5.40, "hello world");  
  return 0;  
\}  
a = 0x0022FF50  
b = 0x0022FF54  
c = 0x0022FF5C  
  
从这个结果来看，显然参数是从右到左，逐一压入栈中的([栈的延伸方向是从高地址到低地址][http_blog.sina.com.cn_s_blog_7b62c61c0100swnx.html]，栈底的占领着最高内存地址，先入栈的参数，其地理位置也就最高了)。我们基本可以得出这样一个结论：  
c.addr = b.addr + x\_sizeof(b);  
b.addr = a.addr + x\_sizeof(a);  
  
有 了以上的"等式"，我们似乎可以推导出 void var\_args\_func(const char \* fmt, ... ) 函数中，可变参数的位置了。起码第一个可变参数的位置应该是：first\_vararg.addr = fmt.addr + x\_sizeof(fmt);根据这一结论我们试着实现一个支持可变参数的函数：  
  
void var\_args\_func(const char \* fmt, ... ) \{  
  char   \*ap;  
  
  ap = ((char\*)&fmt) + sizeof(fmt);  
  printf("%d\\n", \*(int\*)ap);   
     
  ap = ap + sizeof(int);  
  printf("%d\\n", \*(int\*)ap);  
  
  ap = ap + sizeof(int);  
  printf("%s\\n", \*((char\*\*)ap));  
\}  
  
int main()\{  
  var\_args\_func("%d %d %s\\n", 4, 5, "hello world");  
\}  
  
输出结果:  
4  
5  
hello world  
  
var\_args\_func 只是为了演示，并未根据fmt消息中的格式字符串来判断变参的个数和类型，而是直接在实现中写死了，如果你把这个程序拿到solaris 9下，运行后，一定得不到正确的结果，为什么呢，后续再说。先来解释一下这个程序。我们用ap获取第一个变参的地址，我们知道第一个变参是4，一个int 型，所以我们用(int\*)ap以告诉编译器，以ap为首地址的那块内存我们要将之视为一个整型来使用，\*(int\*)ap获得该参数的值；接下来的变参是5，又一个int型，其地址是ap + sizeof(第一个变参)，也就是ap + sizeof(int)，同样我们使用\*(int\*)ap获得该参数的值；最后的一个参数是一个字符串，也就是char\*，与前两个int型参数不同的是，经过ap + sizeof(int)后，ap指向栈上一个char\*类型的内存块(我们暂且称之tmp\_ptr, char \*tmp\_ptr)的首地址，即ap -> &tmp\_ptr，而我们要输出的不是printf("%s\\n", ap)，而是printf("%s\\n", tmp\_ptr); printf("%s\\n", ap)是意图将ap所指的内存块作为字符串输出了，但是ap -> &tmp\_ptr，tmp\_ptr所占据的4个字节显然不是字符串，而是一个地址。如何让&tmp\_ptr是char \*\*类型的，我们将ap进行强制转换(char\*\*)ap <=> &tmp\_ptr，这样我们访问tmp\_ptr只需要在(char\*\*)ap前面加上一个\*即可，即printf("%s\\n",\*(char\*\*)ap);  
  
前面说过，如果将var\_args\_func放到solaris上，一定是得不到正确结果的？为什么呢？由于[内存对齐][Link 2]。编译器在栈上压入参数时，不是一个紧挨着另一个的，编译器会根据变参的类型将其放到满足类型对齐的地址上的，这样栈上参数之间实际上可能会是有空隙的。上述例子中，我是根据反编译后的汇编码得到的参数间隔，还好都是4，然后在代码中写死了。  
  
为了满足代码的可移植性，[C标准库][C]在stdarg.h中提供了诸多Facilities以供实现变长长度参数时使用。这里也列出一个简单的例子，看看利用标准库是如何支持变长参数的：  
\#include <stdarg.h>  
  
void std\_vararg\_func(const char \*fmt, ... ) \{  
va\_list ap;  
va\_start(ap, fmt);  
  
printf("%d\\n", va\_arg(ap, int));  
printf("%f\\n", va\_arg(ap, double));  
printf("%s\\n", va\_arg(ap, char\*));  
  
va\_end(ap);  
\}  
  
int main() \{  
std\_vararg\_func("%d %f %s\\n", 4, 5.4, "hello world");  
\}  
输出:  
4  
5.400000  
hello world  
  
对 比一下 std\_vararg\_func和var\_args\_func的实现，va\_list似乎就是char\*， va\_start似乎就是 ((char\*)&fmt) + sizeof(fmt)，va\_arg似乎就是得到下一个参数的首地址。没错，多数平台下stdarg.h中va\_list, va\_start和var\_arg的实现就是类似这样的。一般stdarg.h会包含很多宏，看起来比较复杂。在有的系统中stdarg.h的实现依赖 some special functions built into the the compilation system to handle variable argument lists and stack allocations，多数其他系统的实现与下面很相似：(Visual C++ 6.0的实现较为清晰，因为windows上的应用程序只需要在windows平台间做移植即可，没有必要考虑太多的平台情况)。  
  
Microsoft Visual Studio\\VC98\\Include\\stdarg.h中，  
typedef char \* va\_list;  
  
\#define \_INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )  
\#define va\_start(ap,v) ( ap = (va\_list)&v + \_INTSIZEOF(v) )  
\#define va\_arg(ap,t) ( \*(t \*)((ap += \_INTSIZEOF(t)) - \_INTSIZEOF(t)) )  
\#define va\_end(ap) ( ap = (va\_list)0 )  
  
这里有两个地方需要深入挖掘一下：  
1、\#define \_INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )  
我们这里简化一下这个宏：  
\#define \_INTSIZEOF(n) ((sizeof(n) + x) & ~(x))  
x = sizeof(int) - 1 = 3 = 0000 0000 0000 0011(b)  
~x = 1111 1111 1111 1100(b)  
  
当一个数 & (-x)时，得到的值始终是sizeof(int)的倍数，也就是说\_INTSIZEOF(n)的功能是将n[圆整][Link 3]到sizeof(int)的倍数上去。sizeof(n) >= 1, sizeof(n)+sizeof(int)-1经过圆整后，一定会是>=4的整数；在其他系统平台上，圆整的目标值有的是4，有的则是8，视具体系统而定。  
  
2、\#define va\_arg(ap,t) ( \*(t \*)((ap += \_INTSIZEOF(t)) - \_INTSIZEOF(t)) )  
其实有了var\_args\_func的实现，这里也就不难理解了。不过这里有一个trick，很多人一开始肯定对先加上\_INTSIZEOF(t)，又减去 \_INTSIZEOF(t)很不理解，其实这里是一点就透的：整个表达式((ap += \_INTSIZEOF(t)) - \_INTSIZEOF(t)) 返回的值其实和最初的ap所指向的地址是一致的，关键就是在整个表达式被evaluated后，ap确指向了下一个参数的地址了，就这么简单。  
  
在[P.J.Plauger][]的"The standard C library"一书的第10章节中也有对stdarg实现的分析，那个版本虽然比较老，但我想应该是现有版本的一个雏形。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

### [        C++11变参模板       ][http_blog.csdn.net_cnsword_article_details_8022729] ###

分类：            [ C++][C 1] 2012-09-26 23:06 809人阅读 [评论][Link 4](0) 收藏 [举报][Link 5]

[c++][c] [C++][C 2]

变参模板是C++11中新的特性，它主要解决了原有模板参数数量不可变的问题。现在标准库的tuple实现就是基于变参模板来实现的。

还是从C的变参函数来说吧，经典的就是printf了, 它基于可变参数

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  void print(constchar \*fmt, ...) 
2.  \{ 
3.      va\_list ls; 
4.      va\_start(fmt, ls); 
5.      va\_arg(ls, int); 
6.      va\_end(ls); 
7.  \}

void print(const char *fmt, ...)
    {
        va_list ls;
        va_start(fmt, ls);
        va_arg(ls, int);
        va_end(ls);
    }

我们需要知道变参的类型才能够从列表中取出参数，为此之后就有变参宏

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define PRINT(ch, args...) printf(ch, \#\#args) 
2.  或者（C99） 
3.  \#define PRINT(ch, ...) printf(ch, \#\#\_\_VA\_ARGS\_\_ )

#define PRINT(ch, args...) printf(ch, ##args)
    或者（C99）
    #define PRINT(ch, ...) printf(ch, ##__VA_ARGS__ )

后来有了模板，可以接受任意类型，如果想接收多个不同的类型参数就要需要包装器来传递，于是有了pair有了tuple。

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  template<typename T> 
2.  void print(T t) 
3.  \{ 
4.  \} 
5.  template<> 
6.  void print(std::tuple t) 
7.  \{ 
8.  \}

template<typename T>
    void print(T t)
    {
    }
    template<>
    void print(std::tuple t)
    {
    }

这不是理想状态，我们需要接受不定参数的模板的支持，于是乎等的望眼欲穿他终于来了。使用变参模板时，会需要递归来支持，并且需要一个结束函数来处理最后的结果。

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  template<typename T,typename... L> 
2.  void print(T t, L... l) 
3.  \{ 
4.      /\*可以添加检查
5.        if ( sizeof...(t) < 1) \{ 
6.             std::cout << "end" << std::endl;
7.        \}
8.         \*/ 
9.       print(t, l); //这里是递归调用 
10. \} 
11. template<typename T> 
12. void print(T t) 
13. \{ 
14.     std::cout <<  "end" << std::endl; 
15. \}

template<typename T, typename... L>
    void print(T t, L... l)
    {
        /*可以添加检查
          if ( sizeof...(t) < 1) {
               std::cout << "end" << std::endl;
          }
           */
         print(t, l); //这里是递归调用
    }
    template<typename T>
    void print(T t)
    {
        std::cout <<  "end" << std::endl;
    }

...其实也是一个包装器，不过他通过编译器来展开，而不是在运行时来操作，性能自然会好很多。

[http_www.cnblogs.com_CUCmehp_archive_2008_12_18_1357438.html]: http://www.cnblogs.com/CUCmehp/archive/2008/12/18/1357438.html
[http_blog.csdn.net_cnsword_article_details_8022729]: http://blog.csdn.net/cnsword/article/details/8022729
[http_blog.sina.com.cn_s_blog_7b62c61c0100swnx.html]: http://blog.sina.com.cn/s/blog_7b62c61c0100swnx.html
[Link 1]: http://bigwhite.blogbus.com/logs/1592114.html
[Link 2]: http://bigwhite.blogbus.com/logs/1347304.html
[C]: http://bigwhite.blogbus.com/logs/2793927.html
[Link 3]: http://bigwhite.blogbus.com/logs/5503006.html
[P.J.Plauger]: http://bigwhite.blogbus.com/logs/2853205.html
[C 1]: http://blog.csdn.net/cnsword/article/category/836844
[Link 4]: http://blog.csdn.net/cnsword/article/details/8022729#comments
[Link 5]: http://blog.csdn.net/cnsword/article/details/8022729#report
[c]: http://www.csdn.net/tag/c%2b%2b
[C 2]: http://www.csdn.net/tag/C%2b%2b
[view plain]: http://blog.csdn.net/cnsword/article/details/8022729#