转自http://www.cnblogs.com/wangyonghui/archive/2010/07/12/1776068.html，稍有改动
一、是什么
我们学习C语言时最经常使用printf()函数，但我们很少了解其原型。其实printf()的参数就是可变参数，想想看，我们可以利用它打印出各种类型的数据。下面我们来看看它的原型：
int printf( const char* format, ...);
它的第一个参数是format，属于固定参数,后面跟的参数的个数和类型都是可变的（用三个点“…”做参数占位符）,实际调用时可以有以下的形式:
printf("%d",i);
printf("%s",s);
printf("the number is %d ,string is:%s", i, s);
那么它的原型是怎样实现的呢？我今天在看内核代码时碰到了vsprintf，花了大半天时间，终于把它搞的有点明白了。
二、先看两个例子
不必弄懂，先大致了解其用法，继续往下看。
①一个简单的可变参数的C函数
在函数simple_va_fun参数列表中至少有一个整数参数,其后是占位符…表示后面参数的个数不定.。在这个例子里，所有输入参数必须都是整数，函数的功能只是打印所有参数的值。
#include <stdio.h>
#include <stdarg.h>
void simple_va_fun(int start, ...)
{
va_list arg_ptr;
int nArgValue =start;
int nArgCout=0; //可变参数的数目
va_start(arg_ptr,start); //以固定参数的地址为起点确定变参的内存起始地址。
do
{
++nArgCout;
printf("the %d th arg: %d\n",nArgCout,nArgValue); //输出各参数的值
nArgValue = va_arg(arg_ptr,int); //得到下一个可变参数的值
} while(nArgValue != -1);
return;
}
int main(int argc, char* argv[])
{
simple_va_fun(100,-1);
simple_va_fun(100,200,-1);
return 0;
}
②格式化到一个文件流，可用于日志文件
FILE *logfile;
int WriteLog(const char * format, ...)
{
va_list arg_ptr;
va_start(arg_ptr, format);
int nWrittenBytes = vfprintf(logfile, format, arg_ptr);
va_end(arg_ptr);
return nWrittenBytes;
}
稍作解释上面两个例子。
【这部分的引用地址http://www.cppblog.com/lmlf001/archive/2006/04/19/5874.html】
从这个函数的实现可以看到,我们使用可变参数应该有以下步骤:
⑴在程序中用到了以下这些宏:
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中,所以用到可变参数的程序应该包含这个头文件.
⑵函数里首先定义一个va_list型的变量,这里是arg_ptr,这个变量是存储参数地址的指针.因为得到参数的地址之后，再结合参数的类型，才能得到参数的值。
⑶然后用va_start宏初始化⑵中定义的变量arg_ptr,这个宏的第二个参数是可变参数列表的前一个参数,即最后一个固定参数.
⑷然后依次用va_arg宏使arg_ptr返回可变参数的地址,得到这个地址之后，结合参数的类型，就可以得到参数的值。
⑸设定结束条件，①是判断参数值是否为-1。注意被调的函数在调用时是不知道可变参数的正确数目的，程序员必须自己在代码中指明结束条件。②是调用宏va_end。
三、剖析可变参数真相
1.va_*宏定义
我们已经知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,由于1)硬件平台的
不同 2)编译器的不同,所以定义的宏也有所不同。下面看一下VC++6.0中stdarg.h里的代码
（文件的路径为VC安装目录下的\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 )
再来看看linux中的定义
typedef char *va_list; #define __va_rounded_size(TYPE) (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) #define va_start(AP, LASTARG) (AP=((char*)&(LASTARG) + __va_rounded_size (LASTARG)) void va_end (va_list); #define va_end(AP) （AP= (char *)0） #define va_arg(AP,TYPE) (AP+=__va_rounded_size(TYPE),\ *((TYPE *)(AP - __va_rounded_size (TYPE))))
要理解上面这些宏定义的意思，需要首先了解：
①栈的方向②参数的入栈顺序③CPU的对齐方式④内存地址的表达方式。
2.栈——以Intel32位的CPU为分析基础
在IntelCPU中，栈的生长方向是向下的，即栈底在高地址，而栈顶在低地址；从栈底向栈顶看过去，地址是从高地址走向低地址的，因为称它为向下生长，如图。
【图1引用自http://www.yuanma.org/data/2008/0504/article_3027_1.htm，这部分内容，我认为作者讲的很详细，所以引来共享】
从上面压栈前后的两个图可明显看到栈的生长方向，在Intel32位的CPU中，windown或linux都使用了它的保护模式，ss指定栈所有在的段，ebp指向栈基址，esp指向栈顶。显然执行push指令后，esp的值会减4，而pop后，esp值增加4。栈中每个元素存放空间的大小决定push或pop指令后esp值增减和幅度。Intel32位CPU中的栈元素大小为16位或32位，由定义堆栈段时定义。在Window和Linux系统中，内核代码已定义好栈元素的大小为32位，即一个字长(sizeof(int))。因此用户空间程栈元素的大小肯定为32位，这样每个栈元素的地址向4字节对齐。
C语言的函数调用约定对编写可变参数函数是非常重要的，只有清楚了，才更欲心所欲地控制程序。在高级程序设计语言中，函数调用约定有如下几种，stdcall，cdecl，fastcall,thiscal,nakedcall。cdel是C语言中的标准调用约定，如果在定义函数中不指明调用约定(在函数名前加上约定名称即可），那编译器认为是cdel约定，从上面的几种约定来看，只有cdel约定才可以定义可变参数函数。下面是cdel约定的重要特征：如果函数A调用函数B，那么称函数A为调用者(caller)，函数B称为被调用者(callee)。caller把向callee传递的参数存放在栈中，并且压栈顺序按参数列表中从右向左的顺序；callee不负责清理栈，而是由caller清理。我们用一个简单的例子来说明问题，并采用Nasm的汇编格式写相应的汇编代码，程序段如下：
void callee(int a, int b)
{
int c = 0;
c = a +b;
}
void caller()
{
callee(1,2);
}
来分析一下在调用过程发生了什么事情。程序执行点来到caller时，那将要执行调用callee函数，在跳到callee函数前，它先要把传递的参数压到栈上，并按右到左的顺序，即翻译成汇编指令就是push2；push1；
图2
函数栈如图中（a）所示。接着跳到callee函数，即指令callcalle。CPU在执行call时，先把当前的EIP寄存器的值压到栈中，然后把EIP值设为callee(地址),这样，栈的图变为如图2(b)。程序执行点跳到了callee函数的第一条指令。C语言在函数调用时，每个函数占用的栈段称为stackframe。用ebp来记住函数stackframe的起始地址。故在执行callee时，最前的两条指令为：
push ebp mov ebp, esp
经过这两条语句后，callee函数的stackframe就建好了，栈的最新情况如图2(c)所示。函数callee定义了一个局部变量intc，该变量的储存空间分配在callee函数占用的栈中，大小为4字节(insizeofint)。那么callee会在如下指令：
sub esp, 4 mov [ebp-4], 0
这样栈的情况又发生了变化，最新情况如图2(d)所示。注意esp总是指向栈顶，而ebp作为函数的stackframe基址起到很大的作用。ebp地址向下的空间用于存放局部变量，而它向上的空间存放的是caller传递过来的参数，当然编译器会记住变量c相对ebp的地址偏移量，在这里为-4。跟着执行c=
a + b语句，那么指令代码应该类似于：
mov eax , [ebp + 8] ；这里用eax存放第一个传递进来的参数，记住第一个参数与ebp的偏移量肯定为8 add eax, [ebp + 12] ;第二个参数与ebp的偏移量为12，故计算eax = a+b mov [ebp -4], eax ;执行 c = eax, 即c = a+b
栈又有了新了变化，如图2(e)。至此，函数callee的计算指令执行完毕，但还要做一些事情：释放局部变量占用的栈空间，销除函数的stack-frame过程会生成如下指令：
movesp, ebp;把局部变量占用的空间全部略过，即不再使用，ebp以下的空间全部用于局部变量
popebp；弹出caller函数的stack-frame基址
在IntelCPU里上面两条指令可以用指令leave来代替，功能是一样。这样栈的内容如图2(f)所示。最后，要返回到caller函数，因此callee的最后一条指令是
ret
ret指令用于把栈上的保存的断点弹出到EIP寄存器，新的栈内容如图2(g)所示。函数callee的调用与返回全部结束，跟着下来是执行callcallee的下一条语句。
从caller函数调用callee前，把传递的参数压到栈中，并且按从右到左的顺序；函数返回时，callee并不清理栈，而是由caller清楚传递参数所占用的栈（如上图，函数返回时，1和2还放在栈中，让caller清理）。栈元素的大小为4个字节，每个参数占用栈空间大小为4字节的倍数，并且任何两个参数都不能共用同一个栈元素。
下面是使用gcc -S 生成的AT&T格式汇编代码
.file "test.c" .text .globl callee .type callee, @function callee: .LFB0: .cfi_startproc pushl %ebp .cfi_def_cfa_offset 8 .cfi_offset 5, -8 movl %esp, %ebp .cfi_def_cfa_register 5 subl $16, %esp movl $0, -4(%ebp) movl 12(%ebp), %eax movl 8(%ebp), %edx addl %edx, %eax movl %eax, -4(%ebp) leave .cfi_restore 5 .cfi_def_cfa 4, 4 ret .cfi_endproc .LFE0: .size callee, .-callee .globl caller .type caller, @function caller: .LFB1: .cfi_startproc pushl %ebp .cfi_def_cfa_offset 8 .cfi_offset 5, -8 movl %esp, %ebp .cfi_def_cfa_register 5 subl $8, %esp movl $2, 4(%esp) movl $1, (%esp) call callee leave .cfi_restore 5 .cfi_def_cfa 4, 4 ret .cfi_endproc .LFE1: .size caller, .-caller .ident "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3" .section .note.GNU-stack,"",@progbits
其中callee中
subl $16, %esp
可见AT&T是预留一段空间栈
从C语言的函数调用约定可知，参数列表从右向左依次压栈，故可变参数压在栈的地址比最后一个命名参数还大，如下图3所示：
由图3可知，最后一个命名参数a上面都放着可变参数，每个参数占用栈的大小必为4的倍数。因此：可变参数1的地址=参数a的地址+a占用栈的大小，可变参数2的地址=可变参数1的地址+可变参数1占用栈的大小，可变参数3的地址=可变参数2的地址+可变参数2占用栈的大小，依此类推。如何计算每个参数占用栈的大小呢？
3.数据对齐问题
对于两个正整数 x,n总存在整数
q,r使得
x= nq + r, 其中 0<=r <n //最小非负剩余
q,r是唯一确定的。q= [x/n], r = x - n[x/n].这个是带余除法的一个简单形式。在c语言中，q,r容易计算出来：
q= x/n, r = x % n.
所谓把 x按n对齐指的是：若r=0,取qn,若r>0,取(q+1)n.这也相当于把x表示为：
x= nq + r',其中
-n< r' <=0 //最大非正剩余
nq是我们所求。关键是如何用c语言计算它。由于我们能处理标准的带余除法，所以可以把这个式子转换成一个标准的带余除法，然后加以处理：
x+n= qn + (n+r')，其中0<n+r'<=n //最大正剩余
x+n-1= qn + (n+r'-1),其中
0<=n+r'-1 <n //最小非负剩余
所以 qn= [(x+n-1)/n]n.用
c语言计算就是：
((x+n-1)/n)*n
若 n是2的方幂,比如2^m，则除为右移m位，乘为左移m位。所以把x+n-1的最低m个二进制位清0就可以了。得到：
(x+n-1)& (~(n-1))
【来自CSDN博客：http://blog.csdn.net/swell624/archive/2008/11/03/3210779.aspx】
根据这些推导，相信已经了解#define__va_rounded_size(TYPE) (((sizeof (TYPE) + sizeof (int) - 1) /sizeof (int)) * sizeof (int))的涵义。
4.再看va_*宏定义
va_start(va_listap, last)
last为最后一个命名参数，va_start宏使ap记录下第一个可变参数的地址，原理与“可变参数1的地址=参数a的地址+a占用栈的大小”相同。从ap记录的内存地址开始，认为参数的数据类型为type并把它的值读出来；把ap记录的地址指向下一个参数，即ap记录的地址+=occupy_stack(type)
va_arg(va_litap, type)
这里是获得可变参数的值，具体工作是：从ap所指向的栈内存中读取类型为type的参数，并让ap根据type的大小记录它的下一个可变参数地址，便于再次使用va_arg宏。从ap记录的内存地址开始，认为存的数据类型为type并把它的值读出来；把ap记录的地址指向下一个参数，即ap记录的地址+=occupy_stack(type)
va_end(va_listap)
用于“释放”ap变量，它与va_start对称使用。在同一个函数内有va_start必须有va_end。
5.可变参数函数问题
考虑了参数大小和数据对齐问题，使得可变参数的类型不但可以是基本类型，同样适用于用户定义类型。值的注意的是，如果是用户定义类型，最好用typedef定义的名字作为类型名，这样就会减少在va_arg进行宏展开时出错的机率。
在可变参数函数中，由va_list变量来记录（或获得）可变参数部分，但是va_list中并没有记录下它们的名字，事实上也是不可能的。要想把可变参数部分传递给下一个函数，唯有通过va_list变量去传递，而原来定义的函数用"..."来表示可变参数部分，而不是用va_list来表示。为了方便程序的标准化，ANSIC在标准库代码中就作出了很好的榜样：在任何形如:type
fun( type arg1, type arg2,...)的函数，都同时定义一个与它功能完全一样的函数，但用va_list类型来替换"..."，即
typefun(type arg1, type arg2, va_list ap)。以printf函数为例： intprintf(const char *format, ...); intvprintf(const char *format, va_list ap);
第一个函数用"..."表示可变参数，第二个用va_list类型表示可变参数，目的是用于被其它可变参数调用，两者在功能功能上是完全上一样。只是在函数名字相差一个'"v"字母。
四、可变参数函数的应用
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
/* minprintf: minimal printf with variable argument list */
void minprintf(char *fmt, ...)
{
va_list ap; /* points to each unnamed arg in turn */
char *p, *sval;
int ival;
double dval;
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
for (p = fmt; *p; p++) {
if (*p != '%') {
putchar(*p);
continue;
}
switch (*++p) {
case 'd':
ival = va_arg(ap, int);
printf("%d", ival);
break;
case 'x':
ival=va_arg(ap,int);
printf("%#x",ival);
break;
case 'f':
dval = va_arg(ap, double);
printf("%f", dval);
break;
case 's':
for (sval = va_arg(ap, char *); *sval; sval++)
putchar(*sval);
break;
default:
putchar(*p);
break;
}
}
va_end(ap); /* clean up when done */
}
int main(int argc, char* argv[])
{
int i = 1234;
int j = 5678;
char *s="nihao";
double f=;
minprintf("the first test:i=%d\n",i,j);
minprintf("the secend test:i=%d; %x;j=%d;",i,0xabcd,j);
minprintf("the 3rd test:s=%s\n",s);
minprintf("the 4th test:f=%f\n",f);
minprintf("the 5th test:s=%s,f=%f\n",s,f);
system("pause");
return 0;
}
//不使用va_*宏定义的实现：
void minprintf(char* fmt, ...) //一个简单的类似于printf的实现不过参数必须都是int 类型
{
char* pArg=NULL; //等价于原来的va_list
char c;
pArg = (char*) &fmt; //注意不要写成p = fmt !因为这里要对//参数取址，而不是取值
pArg += sizeof(fmt); //等价于原来的va_start
do
{
c =*fmt;
if (c != '%')
{
putchar(c); //照原样输出字符
}
else
{
//按格式字符输出数据
switch(*++fmt)
{
case 'd':
printf("%d",*((int*)pArg));
break;
case 'x':
printf("%#x",*((int*)pArg));
break;
default:
break;
}
pArg += sizeof(int); //等价于原来的va_arg
}
++fmt;
}while (*fmt != '\0');
pArg = NULL; //等价于va_end
return;
}