可变参数宏

参考各可变参数的博客，才写出现在的博客，有不准确之处，还望指出。

1.先看些标准C中printf函数原型：

标准C就支持可变参数宏，也就意味着函数的参数是不固定的，例如printf()函数的原型为：
 int printf(const char *format, ...);
在GNU C中，宏也可以接受可变数目的参数，例如：
#define pr_debug (fmt,arg...)  printk(fmt,##arg)
这里arg表示其余的参数，可以是零个或多个，这些参数以及参数之间的逗号构成arg的值，在宏扩展时替换arg，例如列代码：
pr_debug ("%s:%d",filename,line)
会被扩展为：
printk ("%s:%d", filename,line)
使用“##” 的原因是处理arg不代表任何参数的情况，这时候，前面的逗号就变得多余了。使用“##” 之后，GNU C预处理器会丢弃前面的逗号，这样，代码：
pr_debug ("success!\n“);
会被正确地替换为：
printk ("success!\n“);
而不是：
printk ("success!\n“,);


2.C语言中解决变参问题的一组宏 VA_LIST 

他有这么几个成员：
1） va_list型变量：
#ifdef  _M_ALPHA
typedef struct {
        char *a0;       /* pointer to first homed integer argument */
        int offset;     /* byte offset of next parameter */
} va_list;
#else
typedef char *  va_list;
#endif


2）_INTSIZEOF 宏，获取类型占用的空间长度，最小占用长度为int的整数倍：
#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

3）VA_START宏，获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，v是可变参数最左边的参数）：
#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )

4）VA_ARG宏，获取可变参数的当前参数，返回指定类型并将指针指向下一参数（t参数描述了当前参数的类型）：
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

5）VA_END宏，清空va_list可变参数列表：
#define va_end(ap)      ( ap = (va_list)0 )

VA_LIST的用法：      
       （1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针；
       （2）然后用VA_START宏初始化变量刚定义的VA_LIST变量；
       （3）然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用VA_ARG获取各个参数）；
       （4）最后用VA_END宏结束可变参数的获取。
使用VA_LIST应该注意的问题：
   （1）可变参数的类型和个数完全由程序代码控制,它并不能智能地识别不同参数的个数和类型；
   （2）如果我们不需要一一详解每个参数，只需要将可变列表拷贝至某个缓冲，可用vsprintf函数；
   （3）因为编译器对可变参数的函数的原型检查不够严格,对编程查错不利.不利于我们写出高质量的代码；



3. 可变参数的函数

写可变参数的C函数要在程序中用到以下这些宏:
void va_start( va_list arg_ptr, prev_param )
type va_arg( va_list arg_ptr, type )
void va_end( va_list arg_ptr )

va在这里是variable-argument(可变参数)的意思,这些宏定义在stdarg.h中.下面我们写一个简单的可变参数的函数,

该函数至少有一个整数参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值.
void simple_va_fun(int i, ...)
{
   va_list arg_ptr;
   int j=0; 
   
   va_start(arg_ptr, i);
   j=va_arg(arg_ptr, int);
   va_end(arg_ptr);
   printf("%d %d/n", i, j);
   return;
}

在程序中可以这样调用:
simple_va_fun(100);
simple_va_fun(100,200);

从这个函数的实现可以看到,使用可变参数应该有以下步骤:
1)首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变量是指向参数的指针.
2)然后用va_start宏初始化变量arg_ptr,这个宏的第二个参数是第一个可变参数的前一个参数,是一个固定的参数.
3)然后用va_arg返回可变的参数,并赋值给整数j. va_arg的第二个参数是你要返回的参数的类型,这里是int型.
4)最后用va_end宏结束可变参数的获取.然后你就可以在函数里使用第二个参数了.如果函数有多个可变参数的,依次调用va_arg获取各个参数.


如果我们用下面三种方法调用的话,都是合法的,但结果却不一样:
1)simple_va_fun(100);
结果是:100 -123456789(会变的值)
2)simple_va_fun(100,200);
结果是:100 200
3)simple_va_fun(100,200,300);
结果是:100 200


我们看到第一种调用有错误,第二种调用正确,第三种调用尽管结果正确,但和我们函数最初的设计有冲突.

现在我们探讨出现这些结果的原因和可变参数在编译器中是如何处理的. 

4.. 可变参数函数原理

va_start,va_arg,va_end是在stdarg.h中被定义成宏的,由于硬件平台的不同,编译器的不同,所以定义的宏也有所不同,下面以VC++中stdarg.h里x86平台的宏定义摘录如下:

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 ) 


定义_INTSIZEOF(n)主要是为了内存对齐,C语言的函数是从右向左压入堆栈的(设数据进栈方向为从高地址向低地址发展,即首先压入的数据在高地址). 

下图是函数的参数在堆栈中的分布位置:

低地址       |-----------------------------|<-- &v
                          |第n-1个参数(最后一个固定参数)|
                          |-----------------------------|<--va_start后ap指向
                          |第n个参数(第一个可变参数) |
                          |-----------------------------|
                          |....... |
                          |-----------------------------|
                          |函数返回地址 |
高地址      |-----------------------------|


1. va_list 被定义为char *
2. va_start 将地址ap定义为 &v+_INTSIZEOF(v),而&v是固定参数在堆栈的地址,所以va_start(ap, v)以后,ap指向第一个可变参数在堆栈的地址
3. va_arg 取得类型t的可变参数值,以int型为例,va_arg取int型的返回值:
   j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );
4. va_end 使ap不再指向堆栈,而是跟NULL一样.这样编译器不会为va_end产生代码. 

在不同的操作系统和硬件平台的定义有些不同,但原理却是相似的. 


5. 小结：

对于可变参数的函数,因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,可变参数的类型和个数需要在该函数中由程序代码控制;另外,编译器对可变参数的函数的原型检查不够严格,对编程查错不利.

所以我们写一个可变函数的C函数时,有利也有弊,所以在不必要的场合,无需用到可变参数.如果在C++里,我们应该利用C++的多态性来实现可变参数的功能,尽量避免用C语言的方式来实现.


6. 附一些代码

#define debug(format, ...) fprintf(stderr, fmt, __VA_ARGS__)
#define debug(format, args...) fprintf (stderr, format, args)
#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)

// 使用va... 实现
void debug(const char *fmt, ...)
{
    int nBuf;
    char szBuffer[1024];
    va_list args;

    va_start(args, fmt);
    nBuf = vsprintf(szBuffer, fmt, args) ;
    assert(nBuf >= 0);

    printf("QDOGC ERROR:%s/n",szBuffer);
    va_end(args);
}

本文参考：http://www.cppblog.com/xmoss/archive/2009/07/20/90680.html