C语言之可变参数

可变参数总结：可变参数的函数原理其实很简单，是以宏定义来实现的，其实现跟堆栈相关。我们写一个可变函数的C函数时,有利也有弊,所以在不必要的场合，我们无需用到可变参数。如果在C++里,我们应该利用C++的多态性来实现可变参数的功能，尽量避免用C语言的方式来实现。

零、C函数调用的栈结构
   可变参数函数的实现与函数调用的栈结构密切相关，正常情况下C的函数参数入栈规则为__stdcall, 它是从右到左的，即函数中的最右边的参数最先入栈。例如，对于函数：

void fun(int a, int b, int c)
{
int d;
...
}

其栈结构为

    0x1ffc-->d

    0x2000-->a

    0x2004-->b

    0x2008-->c

对于在32位系统的多数编译器，每个栈单元的大小都是sizeof(int), 而函数的每个参数都至少要占一个栈单元大小，如函数 void fun1(char a, int b, double c, short d) 对一个32的系统其栈的结构就是

    0x1ffc-->a  (4字节)（为了字对齐）

    0x2000-->b  (4字节)

    0x2004-->c  (8字节)

    0x200c-->d  (4字节)

参数是从右到左，逐一压入栈中的(栈的延伸方向是从高地址到低地址，栈底的占领着最高内存地址，先入栈的参数，其地理位置也就最高了)。


因此，函数的所有参数是存储在线性连续的栈空间中的，基于这种存储结构，这样就可以从可变参数函数中必须有的第一个普通参数来寻址后续的所有可变参数的类型及其值。
  
 在linux下，输入man 3 printf，可以看到prinf函数原型如下：

<pre name="code" class="cpp">   int printf( const char* format, ...);

　它除了有一个参数format固定以外，后面的三个点...表示printf参数个数和类型是不定的。例如我们可以有以下不同的调用方法：

　　printf("%d",i);
　　printf("%s",s);
　　printf("the number is %d ,string is:%s", i, s);

　 可变参数的问题在C++中是不存在，因为C++具有多态性。但C++是C的一个超集，所以可变参数也可用于C++程序中。 

一、编写可变参数的C函数 
　　写可变参数的C函数，我们通常需要用到<stdarg.h>头文件下定义的以下这些宏：

void va_start(va_list ap, last);
type va_arg(va_list ap, type);
void va_end(va_list ap);
void va_copy(va_list dest, va_list src);

　 　va在这里是variable-argument(可变参数)的意思.这些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个头文件.

va_list:存放参数列表的数据结构，向宏va_start、va_arg和va_end提供参数信息。为了访问变长参数列表中的参数，必须声明va_list类型的一个对象。
定义： typedef char *  va_list；

va_start:访问变长参数列表中的参数之前使用该宏，它初始化用va_list声明的对象，初始化的结构体变量供宏va_arg和va_end使用；
va_arg: 用于从参数列表中取出一个参数，参数类型由type指定。每次调用va_arg都会修改用va_list声明的对象，从而使该对象指向参数列表中的下一个参数；
va_end:该宏使程序能够从变长参数列表用宏va_start引用的函数中正常返回，执行清理参数列表的工作。

va_copy：用于复制参数列表。

例程，该函数至少有一个整数参数，第二个参数也是整数,是可选的

　　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;
　　}

　　我们可以在我们的头文件中这样声明我们的函数: 

　　extern void simple_va_fun(int i, ...);

　　我们在程序中可以这样调用: 

　　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获取各个参数.

　　如果我们用下面三种方法调用的话,都是合法的,但结果却不一样: 

　　simple_va_fun(100);

       结果是:100 -123456789(会变的值) 

simple_va_fun(100,200);

   　 结果是:100 200 

simple_va_fun(100,200,300);

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

二、可变参数在编译器中的处理 

　　我们知道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语言的函数是从右向左压入堆栈的,图(1)是函数的参数在堆栈中的分布位置.我 们看到va_list被定义成char*,有一些平台或操作系统定义为void*.再看va_start的定义,定义为&v+ _INTSIZEOF(v),而&v是固定参数在堆栈的地址,所以我们运行va_start(ap,
v)以后,ap指向第一个可变参数在堆栈的地址,如图: 

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

　　然后,我们用va_arg()取得类型t的可变参数值,以上例为int型为例,我们看一下va_arg取int型的返回值: 

　　j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );

　　首先ap+=sizeof(int),已经指向下一个参数的地址了.然后返回ap-sizeof(int)的int*指针,这正是第一个可变参数在堆栈里的地址(图2).然后用*取得这个地址的内容(参数值)赋给j. 

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

　 　最后要说的是va_end宏的意思,x86平台定义为ap=(char*)0;使ap不再指向堆栈,而是跟NULL一样.有些直接定义为 ((void*)0),这样编译器不会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的.在这里大家要注意一个问题:由于参数 的地址用于va_start宏,所以参数不能声明为寄存器变量或作为函数或数组类型.关于va_start,
va_arg, va_end的描述就是这些了,我们要注意的是不同的操作系统和硬件平台的定义有些不同,但原理却是相似的. 

三、可变参数在编程中要注意的问题 
　 　因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能地识别不同参数的个数和类型.有人会问:那 么printf中不是实现了智能识别参数吗?那是因为函数printf是从固定参数format字符串来分析出参数的类型,再调用va_arg的来获取可
变参数的.也就是说,你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的.另外有一个问题,因为编译器对可变参数的函数的原型检查不够严 格,对编程查错不利.如果simple_va_fun()改为: 

　void simple_va_fun(int i, ...)
　　{
　　va_list arg_ptr;
　　char *s=NULL;

　　va_start(arg_ptr, i);
　　s=va_arg(arg_ptr, char*);
　　va_end(arg_ptr);
　　printf("%d %s/n", i, s);
　　return;
　　}

　　可变参数为char*型,当我们忘记用两个参数来调用该函数时,就会出现core dump(Unix) 或者页面非法的错误(window平台).但也有可能不出错,但错误却是难以发现,不利于我们写出高质量的程序. 
以下提一下va系列宏的兼容性.System V Unix把va_start定义为只有一个参数的宏: 

　　va_start(va_list arg_ptr);

　　而ANSI C则定义为: 

　　va_start(va_list arg_ptr, prev_param);

　　如果我们要用system V的定义,应该用vararg.h头文件中所定义的宏,ANSI C的宏跟system V的宏是不兼容的,我们一般都用ANSI C,所以用ANSI C的定义就够了,也便于程序的移植. 

四、我们的简易printf函数如下：

#include <stdio.h>
#include <stdarg.h>
void
myprintf(char *fmt, ...)
{
va_list ap;
int d;
double f;
char c;
char *s;
char flag;
va_start(ap,fmt);
while (*fmt){
　flag=*fmt++;
　if(flag!='%'){
putchar(flag);
continue;
　　}
　　flag=*fmt++;//记得后移一位
switch (flag)
　　{
　　　case 's':
s=va_arg(ap,char*);
printf("%s",s);
break;
　　　case 'd': /* int */
d = va_arg(ap, int);
printf("%d", d);
break;
　　　case 'f': /* double*/
d = va_arg(ap,double);
printf("%d", d);
break;
　　　case 'c': /* char*/
c = (char)va_arg(ap,int);
printf("%c", c);
break;
　　　default:
putchar(flag);
break;
　　}
}
va_end(ap);
}
int main(){
　　char str[10]="linuxcode";
　　int i=1024;
　　double f=3.1415926;
　　char c='V';
　　myprintf("string is:%s,int is:%d,double is:%f,char is :%c",str,i,f,c);
}

说明：
va_start(ap, fmt);用于根据fmt初始化可变参数列表。
va_arg(ap, char *);用于从参数列表中取出一个参数，其中的char *用于指定所取的参数的类型为字符串。每次调用va_arg后，参数列表ａｐ都会被更改，以使得下次调用时能得到下一个参数。
va_end(ap);用于对参数列表进行一些清理工作。调用完va_end后，ap便不再有效。
以上程序给了我们一个实现printf函数的是思路，即：通过调用va_start函数，来得到参数列表，然后我们一个个取出参数来进行输出即可。
3.实例
例如：对于printf(“a=%d,b=%ｓ,c=%c”,a,b,c)语句;fmt的值为a=%d,b=%ｓ,c=%c，调用va_start函数将参数a,b,c存入了ap中。注意到：fmt中的%为特殊字符，紧跟%后的参数指明了参数类型．