再次理解C语言的变参

实在是令我很郁闷的事啊。

去年用了两天的时间恶补了一下变参，今天看到变参。发现头脑一篇空白，啥都不知道了。

古人有云：温故而知新。今日我就在看一遍，做个笔记了。

在 C 语言中，函数参数的 传递方式有值传和址传 . 值传是把实参的一个专用的、临时的复制值给被调函数中相应的形参 被调用函数使用、修改这个传来的复制值，不会影响实参的值 . 址传则 是把变量 ( 实参 ) 的地址传给被调函数 . 被调函数通过这个地址找到该变量的存放位置，直接对该地址中存放 的变量的内容进行存取操作 . 无论是值传还是址传，都要求实参的数目及类型与形参 要完全一致。

但是在C语言中，在形参表中可以不明确指定传递参数的个数和类型。printf就是一个最好的例子了。这也就是今天要讨论的主要话题-- 变参函数 。

下面我们通过对可变长参数函数的理解和设计， 加深 C 语言函数设计的思想方法。

在标准文件 stdarg.h 中包含带参数的宏定义：

C代码  

1. typedef __builtin_va_list __gnuc_va_list;  
2. typedef __gnuc_va_list va_list   
3. #define va_start(v,l)   __builtin_va_start(v,l)  
4. #define va_end(v)       __builtin_va_end(v)  
5. #define va_arg(v,l)     __builtin_va_arg(v,l)  

 __builtin_va_list等带有__builtin都是编译器所能识别的函数，类似于关键字，这里就不深究了。

下面举例一下可变参数的使用注意事项：

1，可变长参数函数规定格式 {类型函数名 (firstfix,…,lastfix,…)} 。 firstfix,…,lastfix表示函数参数列表中的第一个和最后一个固定参数，该参数列表至少要有一个固定参数，其作用是为了给变参函数确定列表中参数的个数和参数的类型。

2，指针类型va_list用来说明一个变量ap(argument pointer -- 可变参数指针），此变量将依次引用可变参数列表中用省略号“...”代替的每一个参数。即指向将要操作的变参。

3，宏va_start(ap,lastfix)是为了初始化变参指针ap，以指向可变参数列表中未命名的第一个参数，即指向lastfix后的第一个变参。它必须在指针使用之前调用一次该宏，参数列表中至少有一个未命名的可变参数。从宏定义可知其正确性。

4，宏va_arg(ap, type)调用，将ap指向下一个可变参数，而ap的类型由type确定，type数据类型不使用float类型。调用后将新的变参指向一个工作变参，如iap=va_start(ap,int)调用。

5，宏va_end(ap)功能是完成清除变量ap的作用，表明程序以后不再使用，若该指针变量需再使用，必须重新调用宏va_start以启动该变量。

下面举两个列子，一个使用可变参数实现，一个使用常规方式实现：

C代码  

1. #include <stdio.h>  
2. #include <stdarg.h>  
3.   
4. int add_va(int num, int first, ...) {  
5.         int ret = 0, arg, i;  
6.         va_list ap;  //定义一个可变参数变量  
7.   
8.         ret = first;  
9.         va_start(ap,first); //初始化可变参数  
10.         for(i = 1; i < num;i++) {  
11.                 arg = va_arg(ap,int);//获取下一个类型为int的参数  
12.                 ret += arg;  
13.         }  
14.   
15.         va_end(ap);//清除变量ap  
16.         return ret;  
17. }  
18.   
19. int add_normal(int num, ...) {  
20.         int *p, i;  
21.         int ret;  
22.         p = &num + 1; //p指向参数列表下一个位置  
23.         ret = *p;  
24.   
25.         for(i = 1; i < num; i++)  
26.                 ret +=p[i];  
27.   
28.         return ret;  
29. }  
30.   
31. int main(int argc, char **argv) {  
32.         printf("%d\n", add_va(5,1,2,3,4,5));  
33.         printf("%d\n", add_normal(5,1,2,3,4,5));  
34.         return 0;  
35. }  

得出结论：

15

15

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

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

C代码  

1. typedef char * va_list;   
2. #define _INTSIZEOF(n) \   
3. ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )   
4. #define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )   
5. #define va_arg(ap,t) \   
6. ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )   
7. #define va_end(ap) ( ap = (va_list)0 )   

_INTSIZEOF(n) 中注意 (( sizeof (n) + sizeof ( int ) - 1 ) &~ ( sizeof ( int )  -   1 ) )， 其实这段表达式主要是为了字节对齐作用，这里是使用int值来确定对齐的方式。很好很强大。

图 (1) 是函数的参数在堆栈中的分布位置 。运行 va_start(ap, v) 以后 ,ap 指向第一 个可变参数在堆栈的地址

Java代码  

1. 高地址|-----------------------------|   
2. |函数返回地址 |   
3. |-----------------------------|   
4. |. |   
5. |-----------------------------|   
6. |第n个参数(第一个可变参数) |   
7. |-----------------------------|<--va_start后ap指向   
8. |第n-1个参数(最后一个固定参数)|   
9. 低地址|-----------------------------|<-- &v   
10. 图( 1 )   

然后，使用va_arg() 取得类型 t 的可变参数值 。举例 va_arg 取 int 型的返回值 : j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) )。

1，ap+=sizeof(int),ap指向了下一个参数的地址

2，减去sizeof(int)，相当于又返回到了前一个参数，不过这一步没有赋值给ap。

3,  将表达式的值强转成int类型。

4，返回第n(第一个可变参数)的值，并且赋值给变量j。

C代码  

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

 最后要说的是 va_end 宏的意思 ,x86 平 台定义为 ap=(char*)0; 使 ap 不再指向堆栈 , 而是跟 NULL 一样 . 有些直接定义为 ((void*)0), 这样编译器不会为 va_end 产生代码 , 例如 gcc 在 linux 的 x86 平台就是这样定义的 .

NOTE:

由于参数的地址用于 va_start 宏 , 所以参数不能声明为寄存器变量或作为函数或数组类型 。 不同的操作系统和硬件平台的定义有些不同 , 但原理却是相似的。

接下来自己写了一个printf:

C代码  

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <stdarg.h>  
4.   
5. void printf_diy(char *fmt,...) {  
6.         va_list arg;  
7.         char c;  
8.   
9.         va_start(arg, fmt);  
10.   
11.         do {  
12.                 c = *fmt;  
13.                 if(c != '%'){  
14.                         putchar(c); //输出  
15.                 }  
16.                 else {  
17.                         fmt++;  
18.                         switch(*fmt) {  
19.                         case 'd':  
20.                                 printf("%d", *((int*)arg));  
21.                                 break;  
22.                         case 'x':  
23.                                 printf("%#x", *((int*)arg));  
24.                                 break;  
25.                         case 'f':  
26.                                 printf("%f", *((float*)arg));  
27.                         default:  
28.                                 break;  
29.                         }  
30.   
31.                         va_arg(arg,int);  
32.                 }  
33.   
34.                 ++fmt;  
35.   
36.         } while (*fmt != '\0');  
37.   
38.         va_end(arg);  
39.         return;  
40. }  
41.   
42. int main(int argc, char **argv) {  
43.         int i = 1234;  
44.         int j = 5678;  
45.         float f = 13.9;  
46.   
47.         printf_diy("i = %d\n", i);  
48.         printf_diy("j = %d\n", j);  
49.         printf_diy("f = %f\n", f);  
50.         return 0;  
51. }  
52.                                                                                    

输出的结果是：

i = 1234
j = 5678
f = -2.000000

这里不明白f会输出的是怎么会是“ -2.000000” 。今天就写到这里了，该问题以后解决。哈哈！