参考：
http://www.360doc.com/content/12/0309/10/4025635_192940551.shtml
http://www.cnblogs.com/AnnieKim/archive/2011/11/25/ellipsis.html
http://intijk.com/others/va_list-%E7%9A%84%E7%94%A8%E6%B3%95.html
如何获取函数的变长参数（va_list, va_start, va_arg, va_end）
最近在花时间研读C++。
函数这章讲到了函数的变长参数（ellipsis...），但是primer中讲得比较浅，提到了怎么声明怎么调用，但是没有写明在函数内部是如何获取变长的参数的。
1）省略号（ellipsis）
在无法给出所有传递给函数的参数的类型和数目时，可以使用省略号（...）指定函数参数表。有如下几种形式：
1 void fun1(int a, double b, ...); //给出确定的几个参数，其他用省略号
2 void fun2(int a ...); //省略号前有或者没有逗号都是可以的
3 void fun3(...); //也可以不确定任何参数，但和没有参数是不一样的
最典型的应用就是printf函数，printf的声明和调用方法如下：
1 int printf( const char *format [,argument]... ); //官方声明
2 printf("My name is %s, age %d.", "AnnieKim", 24); //调用
2）通用的工作原理
大多数带有变长参数的函数都利用显式声明的参数中的一些信息，来获取调用中提供的其他可选实参的类型和数目。
比如printf函数，就是根据第一个参数推导可选实参：如果第一个'%'后有一个's'，说明后面要有第二个参数，类型是字符串；如果还有第二个'%'，后面跟一个'd'，说明还需要第三个参数，是一个整型等等。
所以说，通常情况下，第一个参数是必不可少的。
3）如何获取变长参数
现在，我们要关注的是函数内部的实现细节。当我看到primer这部分的时候还真是好奇实现细节呢，只怪我孤陋寡闻，以前没见过⊙﹏⊙b。
为了解决变长参数问题，需要用到以下几个宏（以下定义来自MSDN），并且使用这几个宏时必须至少提供一个显式的参数：
#include <stdarg.h>
type va_arg(
va_list arg_ptr,
type
);
void va_end(
va_list arg_ptr
);
void va_start(
va_list arg_ptr,
prev_param
);
其中，type是指要获取的参数的类型，比如int，char *等，arg_ptr是指向参数列表的指针（va_list类型），prev_param是指最后一个显式声明的参数，以用来获取第一个变长参数的位置。
使用步骤：
a）定义一个va_list类型的变量，变量是指向参数的指针。
b）va_start初始化刚定义的变量，第二个参数是最后一个显式声明的参数。
c）va_arg返回变长参数的值，第二个参数是该变长参数的类型。
d）va_end将a)定义的变量重置为NULL。
注意事项：
a）变长参数的类型和数目不能通过宏来获取，只能通过自己写程序控制。
b）编译器对变长参数函数的原型检查不够严格，会影响代码质量。
4）举个例子
最后举个例子，是自己写的printf函数，只能用于处理'%s'和'%d'。为简单起见，没有做任何异常处理，理解这些宏的使用方法即可。
1 #include <iostream>
2 #include <stdarg.h>
3 using namespace std;
4
5 void myprintf(const char *format...)
6 {
7 va_list argptr;
8 va_start(argptr, format); //va_start
9
10 char ch;
11 while (ch = *(format++)) //逐个遍历format字符串
12 {
13 if (ch == '%')
14 {
15 ch = *(format++);
16 if (ch == 's')
17 {
18 char *name = va_arg(argptr, char *); //va_arg
19 cout<<name;
20 }
21 else if (ch == 'd')
22 {
23 int age = va_arg(argptr, int); //va_arg
24 cout<<age;
25 }
26 }
27 else
28 {
29 cout<<ch;
30 }
31 }
32 cout<<endl;
33 va_end(argptr); //va_end
34 }
35
36 int main()
37 {
38 myprintf("My name is %s, age %d.", "AnnieKim", 24);
39 return 0;
40 }
代码写得较粗糙，表介意。变长参数问题也就先到这里。
va_list 的用法
相信每个程序员都会用C语言的 printf, scanf 函数, 当时在我学会函数之后, 对这两个函数感到惊讶, 为什么呢? 他们太不同于我们自己写的那种接受固定个参数的函数, 而是可以接受任意多个参数.
c 语言允许定义这样的接受变参的函数, 它的机制就是 va_list , 使用它 , 我们也可以定义自己的变参个数的函数.
首先, 看下 printf 函数的声明:
int printf(char * format, ... ); |
第一个 char * format 就是我们常写的带 %d, %f 这样转换单元的格式字符串, 第二个参数是 … ? 这是什么? 对, 这就是变参函数定义时的奥秘了, 记住如下两点:
- 1. 变参处的定义或声明, 用 … 代替参数类型.
- 2. 变参 … 只能放在参数列表最末尾.
这里我们写一个小程序, 来演示 va_list 的用法, 定义一个barycentre 函数, 计算 n 个点的重心并返回, 声明如下:
point barycentre(int n , ... ); |
其中point为描述二维点坐标的结构体:
struct { double x,y;}point; |
函数体是这样的:
struct point barycentre(int n, ... ){ int i; struct point t; struct point sum={0}; va_list listPointer; va_start(listPointer, n); for(i=0;i<n;i++){ t=va_arg(listPointer,struct point); sum.x+=t.x; sum.y+=t.y; } sum.x/=n; sum.y/=n; va_end(listPointer); return sum;} |
在以上函数中, 用到了以下几个宏:
- va_list
- va_start
- va_arg
- va_end
va_list 用来定义一个变量列表的指针类型.
va_start(listPointer, n) 的意思是将 listPointer 这个指针绑定到有 n 个变量的传入参数列表上.
va_arg(listPointer, type) 从参数列表中逐个取出数据, 取出数据的类型由 type 决定, 它返回这个 type 类型的值, 你可以马上把它赋值给另一个变量.
当函数调用结束的时候, 要记得使用 va_end 来清除 listPointer 指向的空间, 否则会发生内存泄漏问题.
可能你有两个问题要问:
- 1. 必须知道传入参数的个数吗?
- 答: 是的, 若没有参数个数, va_start 的时候就无法绑定.
- 2. 必须向上面的例子中那样所有的可变参数都是同一个类型吗?
- 答: 不是这样, 想想 printf 函数, 它通过一个 char * format 格式字符串, 不仅确定了参数个数, 还确定了每个参数的类型(通过 %d 这样的转换单元), 这样只要在 va_arg 的时候采用适当的 type 类型就可读出各种类型的参数.
以下是程序的完全版, 随机生成了3个二维点的坐标, 并传递给 barycentre 得到它的重心.
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
struct point{
double x,y;
};
struct point barycentre(int n, ... )
{
int i;
struct point t;
struct point sum={0};
va_list listPointer;
va_start(listPointer, n);
for(i=0;i<n;i++){
t=va_arg(listPointer,struct point);
sum.x+=t.x;
sum.y+=t.y;
}
sum.x/=n;
sum.y/=n;
va_end(listPointer);
return sum;
}
int main()
{
struct point a,b,c,bc;
a.x=rand()%1000/100.0;
a.y=rand()%1000/100.0;
b.x=rand()%1000/100.0;
b.y=rand()%1000/100.0;
c.x=rand()%1000/100.0;
c.y=rand()%1000/100.0;
bc=barycentre(3,a,b,c);
printf("The barycentre of the 3 points is (%f,%f).
",bc.x,bc.y);
return 0;
}
va_list、va_start、va_arg、va_end宏的使用
当你的函数的参数个数不确定时，就可以使用上述宏进行动态处理，这无疑为你的程序增加了灵活性。
Example:
◎用法1:
func( Type para1, Type para2, Type para3, ... )
{
/****** Step 1 ******/
va_list ap;
va_start( ap, para3 ); //一定要“...”之前的那个参数
/****** Step 2 ******/
//此时ap指向第一个可变参数
//调用va_arg取得里面的值
Type xx = va_arg( ap, Type );
//Type一定要相同，如:
//char *p = va_arg( ap, char *);
//int i = va_arg( ap, int );
//如果有多个参数继续调用va_arg
/****** Step 3 ******/
va_end(ap); //For robust!
}
◎用法2:
CString AppendString(CString str1,...)//一个连接字符串的函数，参数个数可以动态变化
{
LPCTSTR str=str1;//str需为指针类型，因为va_arg宏返回的是你的参数的指针，但是如果你的参数为int等简 //单类型，则不必为指针，因为变量名实际上即是指针。
CString res;
va_list marker; //你的类型链表
va_start(marker,str1);//初始化你的marker链表
while(str!="ListEnd")//ListEnd:参数的结束标志，十分重要，在实际中需自行指定
{
res+=str;
str=va_arg(marker,CString);//取得下一个指针
}
va_end(marker);//结束，与va_start合用
return res;
}
int main()
{
CString str=AppendString("xu","zhi","hong","ListEnd");
cout<<str.GetBuffer(str.GetLength())<<endl;
return 0;
}
输出xuzhihong
CString
AppendString(CString
str1,...)，因为连接字符串的参数可以动态变化，你不知用户要进行连接的字符串个数是多少，所以你可以用…来代替。但是要注意的是你的函数要有一
个参数作为标志来表示结束，否则会出错。在上例中用ListEnd作为结束符。还有va_arg返回的是你参数内容的指针。上例在支持MFC程序的
console下运行通过。
可变参数函数的原型声明格式为：
type VAFunction(type arg1, type arg2, … );
参数可以分为两部分：个数确定的固定参数和个数可变的可选参数。函数至少需要一个固定参数，固定参数的声明和普通函数一样；可选参数由于个数不确定，声明时用"…"表示。固定参数和可选参数公同构成一个函数的参数列表。
借助上面这个简单的例2，来看看各个va_xxx的作用。
va_list arg_ptr：定义一个指向个数可变的参数列表指针；
va_start(arg_ptr,
argN)：使参数列表指针arg_ptr指向函数参数列表中的第一个可选参数，说明：argN是位于第一个可选参数之前的固定参数，（或者说，最后一个
固定参数；…之前的一个参数），函数参数列表中参数在内存中的顺序与函数声明时的顺序是一致的。如果有一va函数的声明是void
va_test(char a, char b, char c,
…)，则它的固定参数依次是a,b,c，最后一个固定参数argN为c，因此就是va_start(arg_ptr, c)。
va_arg(arg_ptr, type)：返回参数列表中指针arg_ptr所指的参数，返回类型为type，并使指针arg_ptr指向参数列表中下一个参数。
va_copy(dest, src)：dest，src的类型都是va_list，va_copy()用于复制参数列表指针，将dest初始化为src。
va_end(arg_ptr)：
清空参数列表，并置参数指针arg_ptr无效。说明：指针arg_ptr被置无效后，可以通过调用va_start
()、va_copy()恢复arg_ptr。每次调用va_start() /
va_copy()后，必须得有相应的va_end()与之匹配。参数指针可以在参数列表中随意地来回移动，但必须在va_start()
…va_end()之内。
va函数的实现就是对参数指针的使用和控制。
typedef char * va_list; // x86平台下va_list的定义
函数的固定参数部分，可以直接从函数定义时的参数名获得；对于可选参数部分，先将指针指向第一个可选参数，然后依次后移指针，根据与结束标志的比较来判断是否已经获得全部参数。因此，va函数中结束标志必须事先约定好，否则，指针会指向无效的内存地址，导致出错。
这
里，移动指针使其指向下一个参数，那么移动指针时的偏移量是多少呢，没有具体答案，因为这里涉及到内存对齐（alignment）问题，内存对齐跟具体
使用的硬件平台有密切关系，比如大家熟知的32位x86平台规定所有的变量地址必须是4的倍数(sizeof(int) =
4)。va机制中用宏_INTSIZEOF(n)来解决这个问题，没有这些宏，va的可移植性无从谈起。
首先介绍宏_INTSIZEOF(n)，它求出变量占用内存空间的大小，是va的实现的基础。
#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 ) // 将指针置为无效
下表是针对函数int TestFunc(int n1, int n2, int n3, …)
参数传递时的内存堆栈情况。（C编译器默认的参数传递方式是__cdecl。）
对该函数的调用为int result = TestFunc(a, b, c, d. e); 其中e为结束标志。
从上图中可以很清楚地看出va_xxx宏如此编写的原因。
1．va_start。为了得到第一个可选参数的地址，我们有三种办法可以做到：
A) = &n3 + _INTSIZEOF(n3)
// 最后一个固定参数的地址+ 该参数占用内存的大小
B) = &n2 + _INTSIZEOF(n3) + _INTSIZEOF(n2)
// 中间某个固定参数的地址+ 该参数之后所有固定参数占用的内存大小之和
C) = &n1 + _INTSIZEOF(n3) + _INTSIZEOF(n2) + _INTSIZEOF(n1)
// 第一个固定参数的地址+ 所有固定参数占用的内存大小之和
从
编译器实现角度来看，方法B)，方法C)为了求出地址，编译器还需知道有多少个固定参数，以及它们的大小，没有把问题分解到最简单，所以不是很聪明的途
径，不予采纳；相对来说，方法A)中运算的两个值则完全可以确定。va_start()正是采用A)方法，接受最后一个固定参数。调用va_start
()的结果总是使指针指向下一个参数的地址，并把它作为第一个可选参数。在含多个固定参数的函数中，调用va_start()时，如果不是用最后一个固定
参数，对于编译器来说，可选参数的个数已经增加，将给程序带来一些意想不到的错误。(当然如果你认为自己对指针已经知根知底，游刃有余，那么，怎么用就随
你，你甚至可以用它完成一些很优秀（高效）的代码，但是，这样会大大降低代码的可读性。)
注意：宏va_start是对参数的地址进行操作的，要求参数地址必须是有效的。一些地址无效的类型不能当作固定参数类型。比如：寄存器类型，它的地址不是有效的内存地址值；数组和函数也不允许，他们的长度是个问题。因此，这些类型时不能作为va函数的参数的。
2．va_arg身兼二职：返回当前参数，并使参数指针指向下一个参数。
初看va_arg宏定义很别扭，如果把它拆成两个语句，可以很清楚地看出它完成的两个职责。
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址
// 将( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )拆成：
/* 指针ap指向下一个参数的地址*/
1．ap += _INTSIZEOF(t)； // 当前，ap已经指向下一个参数了
/* ap减去当前参数的大小得到当前参数的地址，再强制类型转换后返回它的值*/
2．return *(t *)( ap - _INTSIZEOF(t))
回想到printf/scanf系列函数的%d %s之类的格式化指令，我们不难理解这些它们的用途了- 明示参数强制转换的类型。
(注：printf/scanf没有使用va_xxx来实现，但原理是一致的。)
3．va_end很简单，仅仅是把指针作废而已。
#define va_end(ap) (ap = (va_list)0) // x86平台
四、 简洁、灵活，也有危险
从va的实现可以看出，指针的合理运用，把C语言简洁、灵活的特性表现得淋漓尽致，叫人不得不佩服C的强大和高效。不可否认的是，给编程人员太多自由空间必然使程序的安全性降低。va中，为了得到所有传递给函数的参数，需要用va_arg依次遍历。其中存在两个隐患：
1）如何确定参数的类型。
va_arg在类型检查方面与其说非常灵活，不如说是很不负责，因为是强制类型转换，va_arg都把当前指针所指向的内容强制转换到指定类型；
2）
结束标志。如果没有结束标志的判断，va将按默认类型依次返回内存中的内容，直到访问到非法内存而出错退出。例2中SqSum()求的是自然数的平方
和，所以我把负数和0作为它的结束标志。例如scanf把接收到的回车符作为结束标志，大家熟知的printf()对字符串的处理用' '作为结束标
志，无法想象C中的字符串如果没有' '， 代码将会是怎样一番情景，估计那时最流行的可能是字符数组，或者是malloc/free。
允许对内存的随意访问，会留给不怀好意者留下攻击的可能。当处理cracker精心设计好的一串字符串后，程序将跳转到一些恶意代码区域执行，以使cracker达到其攻击目的。(常见的exploit攻击)所以，必需禁止对内存的随意访问和严格控制内存访问边界。
有关va_list和vsnprintf输出函数的问题
来源: ChinaUnix博客 日期：2006.11.16 12:36 (共有0条评论) 我要评论
va_list ap; //声明一个变量来转换参数列表
va_start(ap,fmt); //初始化变量
va_end(ap); //结束变量列表,和va_start成对使用
可以根据va_arg(ap,type)取出参数
已经经过调试成功的输出程序
#include
#include
#define bufsize 80
char buffer[bufsize];
int vspf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(buffer,bufsize ,fmt, argptr);
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
", buffer);
return 0;
}
#include <stdio.h>
#include <stdarg.h>
void myprintf(const char *ptr, ...);
int main(int argc, const char *argv[])
{
myprintf("%s, %d
","pengdonglin", 9);
return 0;
}
void myprintf(const char *ptr, ...)
{
char ch;
va_list argptr;
va_start(argptr, ptr);
while((ch = *ptr++))
{
if(ch == '%')
{
ch = *ptr++;
if(ch == 's')
{
char *p = va_arg(argptr, char *);
while(*p)
{
putchar (*p++);
}
}
else if(ch == 'd')
{
int p = va_arg(argptr, int);
putchar(p +'0');
}
}
else
{
putchar(ch);
}
}
va_end(argptr);
}