可变参数的理解与使用之整理篇

当一个函数中的同类型的参数有很多个的时候，在定义这个函数的时候该怎么办？

（va_list、va_start、va_arg、va_end宏）

于是它这样定义：
fun（Type para1 para2 para3 ...）
即:前面写几个参数后后面的参数用省略号...代替.
前面写出的参数就是固定参数,后面没有写出的参数就是可选参数.va_start() va_arg() va_end()这些函数就是用来处理这些情况的.
几个重要的概念:
可变参数:...所隐含的或者所省略的参数
固定参数:凡是写出来的参数都是固定参数.
最后一个固定参数:固定参数是在可变参数之前的位置.紧挨着...并在其之前的那个固定参数称做最后一个固定参数.

◎用法:
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_xxx的作用。

va_list ap：定义一个指向个数可变的参数列表指针；

va_start(ap, argN)：使参数列表指针ap指向函数参数列表中的第一个可选参数，说明：argN是位于第一个可选参数之前的固定参数，（或者说，最后一个 固定参数；…之前的一个参数），函数参数列表中参数在内存中的顺序与函数声明时的顺序是一致的。如果有一va函数的声明是void va_test(char a, char b, char c, …)，则它的固定参数依次是a,b,c，最后一个固定参数argN为c，因此就是va_start(ap, c)。
va_arg(ap, type)：返回参数列表中指针ap所指的参数，返回类型为type，并使指针ap指向参数列表中下一个参数。
va_copy(dest, src)：dest，src的类型都是va_list，va_copy()用于复制参数列表指针，将dest初始化为src。
va_end(ap)：清空参数列表，并置参数指针arg_ptr无效。说明：指针ap被置无效后，可以通过调用va_start ()、va_copy()恢复ap。每次调用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()对字符串的处理用'/0'作为结束标 志，无法想象C中的字符串如果没有'/0'， 代码将会是怎样一番情景，估计那时最流行的可能是字符数组，或者是malloc/free。

允许对内存的随意访问，会留给不怀好意者留下攻击的可能。当处理cracker精心设计好的一串字符串后，程序将跳转到一些恶意代码区域执行，以使cracker达到其攻击目的。(常见的exploit攻击)所以，必需禁止对内存的随意访问和严格控制内存访问边界。

 

1.对于一般的函数来说，函数压栈的顺序是从右向左，所谓屁股后面开始压栈。

2.因此可变参数列表来说，具体俄有几个宏

   va_list 定义指向参数列表信息，一般来说定义为系统最小的内存单位的指针，有些机器上定义为void *，x86一般情况下定义为char *。typedef char * valist

   va_start 初始化参数列表指针，通过参数中最后一个确定名称的参数来确定可变参数列表的开始，换句话，一个可变参数函数至少也需要一个固定的参数。#define va_start(va_pointer,last) ....(需要进行位对齐)

   var_arg 获取需要的参数，需要提供参数列表以及具体的类型。#define var_arg(va_pointer,<type> ...其实可变参数的个数是随便取的，所以需要某个方式去确定参数的个数。例如，main里面通过argc，printf通过格式化串。

   var_end 施放可变参数列表，对于通过var_copy 拷贝的列表也需要使施放 #define var_end(va_pointer)

   var_copy #define var_copy(dest,src)

   以上宏定义在<stdarg.h >中

   一般来说，在不同的机器上有不同的实现和定义，举x86系统来说

typedef   char   *va_list; 
/*把va_list被定义成char*，这是因为在我们目前所用的PC机上，字符指针类型可以用来存储内存单元地址。而在有的机器上va_list是被定义成void*的*/

#define   _INTSIZEOF(n)   (   (sizeof(n)   +   sizeof(int)   -   1)   &   ~(sizeof(int)   -   1)   )
/*_INTSIZEOF (n)宏是为了考虑那些内存地址需要对齐的系统，从宏的名字来应该是跟sizeof(int)对齐。一般的 sizeof(int)=4，也就是参数在内存中的地址都为4的倍数。比如，如果sizeof(n)在1－4之间，那么_INTSIZEOF(n)＝4； 如果sizeof(n)在5－8之间，那么_INTSIZEOF(n)=8。*/

#define   va_start(ap,v)(   ap   =   (va_list)&v   +   _INTSIZEOF(v)   )
/*va_start 的定义为   &v+_INTSIZEOF(v)   ,这里&v是最后一个固定参数的起始地址，再加上其实际占用大小后，就得到了第一个可变参数的起始内存地址。所以我们运行 va_start(ap,   v)以后,ap指向第一个可变参数在的内存地址*/

#define   va_arg(ap,t)   (   *(t   *)((ap   +=   _INTSIZEOF(t))   -   _INTSIZEOF(t))   )
/*这个宏做了两个事情，
①用用户输入的类型名对参数地址进行强制类型转换，得到用户所需要的值
②计算出本参数的实际大小，将指针调到本参数的结尾，也就是下一个参数的首地址，以便后续处理。*/

#define   va_end(ap)   (   ap   =   (va_list)0   ) 
/*x86 平台定义为ap=(char*)0;使ap不再   指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不会为va_end产生代码,例如gcc在linux的x86平台就是这 样定义的.   在这里大家要注意一个问题:由于参数的地址用于va_start宏,所以参数不能声明为寄存器变量或作为函数或数组类型.   */