va_start、va_end、va_list、va_arg的使用整理

<code>

#include <cstdarg>

type va_arg( va_list argptr, type );

void va_end( va_list argptr );

void va_start( va_list argptr, last_parm );

</code>

在VC++6.0的include有一个stdarg.h头文件,有如下几个宏定义:

#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 ) // 将指针置为无效

va_arg() 系列宏用来将变化数目的变量传递给一个函数。

- 首先，必须调用 va_start() 并传递给它一个有效的va_list和函数位于'...'参数之前的那个强制参数。如果只有一个强制参数，那就是它了。你必须拥有至少一个强制参数。这个参数可以代表任何事；一种用法是使得此参数为整数用来描述传递过来参数的个数。

- 然后，调用 va_arg() 并传递给它那个 va_list 和返回参数的类型。va_arg()的返回值是当前的参数。

- 根据仍然有多少参数重复调用va_arg()。

- 最后，将va_list传递给 va_end() 并因为需要适当的清理工作而调用它。

参数在堆栈中分布,位置

在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,执行自己的代码来达到执行自己插入的代码段的目的.

总之,函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.

堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:

最后一个参数

倒数第二个参数

...

第一个参数

函数返回地址

函数代码段

1:当无法列出传递函数的所有实参的类型和数目时,可用省略号指定参数表

void foo(...);

void

foo(parm_list,...);

2:函数参数的传递原理

函数参数是以数据结构:栈的形式存取,从右至左入栈.eg:

#include <iostream>

void fun(int a, ...)

{

int *temp = &a;

temp++;

for (int i = 0; i < a; ++i)

{

cout << *temp << endl;

temp++;

}

}

int main()

{

int a = 1;

int b = 2;

int c = 3;

int d = 4;

fun(4, a, b, c, d);

system("pause");

return

0;

}

Output::

1

2

3

4

3:获取省略号指定的参数

在函数体中声明一个va_list，然后用va_start函数来获取参数列表中的参数，使用完毕后调用va_end()结束。像这段代码：

void

TestFun(char* pszDest, int DestLen, const char* pszFormat, ...)

{

va_list args;

va_start(args,pszFormat);

_vsnprintf(pszDest, DestLen, pszFormat, args);

va_end(args);

}

4.va_start使argp指向第一个可选参数。va_arg返回参数列表中的当前参数并使argp指向参数列表中的下一个参数。va_end把argp指针清为NULL。函数体内可以多次遍历这些参数，但是都必须以va_start开始，并以va_end结尾。

　　1).演示如何使用参数个数可变的函数，采用ANSI标准形式

　　#include 〈stdio.h〉

　　#include 〈string.h〉

　　#include 〈stdarg.h〉

　　

　　int demo( char, ... );

　　void main( void )

　　{

　　 demo("DEMO", "This", "is", "a", "demo!", "");

　　}

　　

　　int demo( char msg, ... )

　　{

　　 va_list argp;

　　 int argno = 0;

　　 char para;　　

　　 va_start( argp, msg);

　　 while (1)

{

　　 para = va_arg( argp, char);

　　 if ( strcmp( para, "") == 0 )

break;

　　 printf("Parameter #%d is: %s\n", argno, para);

　　 argno++;

　　

}

　　 va_end( argp );

　　

　　　return 0;

　　}

2)//示例代码1：可变参数函数的使用

#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;

}

3)//示例代码2:扩展——自己实现简单的可变参数的函数。

下面是一个简单的printf函数的实现，参考了<The C Programming Language>中的例子

#include "stdio.h"

#include "stdlib.h"

void myprintf(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;

}

int main(int argc, char* argv[])

{

int i = 1234;

int j = 5678;

myprintf("the first test:i=%d\n",i,j);

myprintf("the secend test:i=%d; %x;j=%d;\n",i,0xabcd,j);

system("pause");

return 0;

}

bool CCFile::WriteToFile(const char *pFmt,...)

{

const char *p = pFmt;

string strFmt;

char buf[1024] = {0};

va_list ap;

int d = 0;

char c,*s = NULL;

double f = 0;

long l = 0;

va_start(ap,pFmt);

char *s=va_arg(ap,char *);

for (;*p != '\0';++p)

{

if (*p != '%')

{

sprintf(buf,"%c",*p);

strFmt += buf;

continue;

}

switch (*++p)

{

case 's':

s = va_arg(ap,char *);

sprintf(buf,"%s",s);

break;

case 'f': /* float and double */

f = va_arg(ap, double);

sprintf(buf,"%f",f);

break;

case 'l': /* long */

d = va_arg(ap, long);

sprintf(buf,"%d",l);

break;

case 'd': /* int */

d = va_arg(ap, int);

sprintf(buf,"%d",d);

break;

case 'c': /* char */

c = va_arg(ap, char);

sprintf(buf,"%c",c);

break;

default:

sprintf(buf,"输出类型不支持/% %c",*(p-1));

}

strFmt += buf;

}

return true;

}