VA_LIST 是 C 语言中解决变长参数问题的一组宏
VA_LIST 的用法：
（ 1 ）首先在函数里定义一个 VA_LIST 类型的变量，这个变量是指向参数的指针；
（ 2 ）然后用 VA_START 宏初始化刚定义的 VA_LIST 变量，这个宏的第二个参数是第一个可变参数的前一个参数，是一个固定的参数；
（ 3 ）然后用 VA_ARG 返回可变的参数， VA_ARG 的第二个参数是你要返回的参数的类型，如果函数有多个可变参数的，依次调用 VA_ARG 获取各个参数；
（ 4 ）最后用 VA_END 宏结束可变参数的获取。
VA_LIST 在编译器中的处理：
（ 1 ）在运行 VA_START(ap,v) 以后， ap 指向第一个可变参数在堆栈的地址；
（ 2 ） VA_ARG() 取得类型 t 的可变参数值，在这步操作中首先 apt = sizeof(t 类型 ) ，让 ap 指向下一个参数的地址。然后返回 ap-sizeof(t 类型 ) 的 t 类型 * 指针，这正是第一个可变参数在堆栈里的地址。然后用 * 取得这个地址的内容；
（ 3 ） VA_END(),X86 平台定义为 ap = ((char*)0) ，使 ap 不再指向堆栈，而是跟 NULL 一样，有些直接定义为 ((void*)0) ，这样编译器不会为 VA_END 产生代码，例如 gcc 在 Linux 的 X86 平台就是这样定义的。
要注意的是：由于参数的地址用于 VA_START 宏，所以参数不能声明为寄存器变量、函数或数组类型。
使用 VA_LIST 应该注意的问题：
（ 1 ）因为 va_start, va_arg, va_end 等定义成宏 , 所以它显得很愚蠢 , 可变参数的类型和个数完全在该函数中由程序代码控制 , 它并不能智能地识别不同参数的个数和类型 . 也就是说 , 你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的；
（ 2 ）另外有一个问题 , 因为编译器对可变参数的函数的原型检查不够严格 , 对编程查错不利 . 不利于我们写出高质量的代码。
小结：可变参数的函数原理其实很简单，而 VA 系列是以宏定义来定义的，实现跟堆栈相关。我们写一个可变函数的 C 函数时，有利也有弊 , 所以在不必要的场合，我们无需用到可变参数，如果在 C++ 里，我们应该利用 C++ 多态性来实现可变参数的功能，尽量避免用 C 语言的方式来实现。
func( Type para1, Type para2, Type para3, ... )
{
/****** Step 1 ******/
va_list ap;
va_start( ap, para3 ); // 一定要“ ... ”之前的那个参数 **ap 指向 para 后的第一个可变参数
/****** 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!
}
请问 :va_list(), va_start() 是何意 ?
( 一 ) 写一个简单的可变参数的 C 函数
下面我们来探讨如何写一个简单的可变参数的 C 函数 . 写可变参数的
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;
}
我们可以在我们的头文件中这样声明我们的函数 :
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 获取各个参数。
如果我们用下面三种方法调用的话，都是合法的，但结果却不一样：
1)simple_va_fun(100);
结果是 :100 -123456789( 会变的值 )
2)simple_va_fun(100,200);
结果是 :100 200
3)simple_va_fun(100,200,300);
结果是 :100 200
我们看到第一种调用有错误 , 第二种调用正确 , 第三种调用尽管结果
正确 , 但和我们函数最初的设计有冲突 . 下面一节我们探讨出现这些结果
的原因和可变参数在编译器中是如何处理的 .
( 二 ) 可变参数在编译器中的处理
我们知道 va_start,va_arg,va_end 是在 stdarg.h 中被定义成宏的 ,
由于 1) 硬件平台的不同 2) 编译器的不同 , 所以定义的宏也有所不同 , 下
面以 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 的定义就够了 , 也便于程序的移植 .
扫一扫
1294
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
