关于可变参数-转

浪迹天涯

唯有努力...
努力....再努力...

va_list、va_start、va_arg、va_end的原理与使用

1. 概述
   由于在C语言中没有函数重载,解决不定数目函数参数问题变得比较麻烦;即使采用C++,如果参数个数不能确定,也很难采用函数重载.对这种情况,有些人采用指针参数来解决问题.下面就c语言中处理不定参数数目的问题进行讨论.
2. 定义
   大家先看几宏.
   在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 )                            // 将指针置为无效
   如果对以上几个宏定义不理解,可以略过,接这看后面的内容.
3. 参数在堆栈中分布,位置
   在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,执行自己的代码来达到执行自己插入的代码段的目的.
   总之,函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.
   堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
   最后一个参数
   倒数第二个参数
   ...
   第一个参数
   函数返回地址
   函数代码段
4. 示例代码
   void arg_test(int i, ...);
   int main(int argc,char *argv[])
   {
    int int_size = _INTSIZEOF(int);
    printf("int_size=%d/n", int_size);
    arg_test(0, 4);
    
    arg_cnt(4,1,2,3,4);
    return 0;
   }
   void arg_test(int i, ...)
   {
    int j=0;
    va_list arg_ptr; 
    
    va_start(arg_ptr, i); 
    printf("&i = %p/n", &i);//打印参数i在堆栈中的地址
    printf("arg_ptr = %p/n", arg_ptr);
    //打印va_start之后arg_ptr地址,
    //应该比参数i的地址高sizeof(int)个字节
    //这时arg_ptr指向下一个参数的地址
    
    j=*((int *)arg_ptr);
    printf("%d %d/n", i, j); 
    j=va_arg(arg_ptr, int);
    printf("arg_ptr = %p/n", arg_ptr);
    //打印va_arg后arg_ptr的地址
    //应该比调用va_arg前高sizeof(int)个字节
    //这时arg_ptr指向下一个参数的地址
    va_end(arg_ptr);
    printf("%d %d/n", i, j);
   }
   
5. 代码说明:
   int int_size = _INTSIZEOF(int);得到int类型所占字节数
    va_start(arg_ptr, i); 得到第一个可变参数地址,

   根据定义(va_list)&v得到起始参数的地址, 再加上_INTSIZEOF(v) ,就是其实参数下一个参数的地址,即第一个可变参数地址.
   j=va_arg(arg_ptr, int); 得到第一个参参数的值,并且arg_ptr指针上移一个_INTSIZEOF(int),即指向下一个可变参数的地址.
   va_end(arg_ptr);置空arg_ptr,即arg_ptr=0;
   总结:读取可变参数的过程其实就是堆栈中,使用指针,遍历堆栈段中的参数列表,从低地址到高地址一个一个地把参数内容读出来的过程.

6. 在编程中应该注意的问题和解决办法
   虽然可以通过在堆栈中遍历参数列表来读出所有的可变参数,但是由于不知道可变参数有多少个,什么时候应该结束遍历,如果在堆栈中遍历太多,那么很可能读取一些无效的数据.
   解决办法:a.可以在第一个起始参数中指定参数个数,那么就可以在循环还中读取所有的可变参数;b.定义一个结束标记,在调用函数的时候,在最后一个参数中传递这个标记,这样在遍历可变参数的时候,可以根据这个标记结束可变参数的遍历;
   下面是一段示例代码:
   //第一个参数定义可选参数个数,用于循环取初参数内容
   void arg_cnt(int cnt, ...);
   int main(int argc,char *argv[])
   {
    int int_size = _INTSIZEOF(int);
    printf("int_size=%d/n", int_size);
    arg_cnt(4,1,2,3,4);
    return 0;
   }
   void arg_cnt(int cnt, ...)
   {
    int value=0;
    int i=0;
    int arg_cnt=cnt;
    va_list arg_ptr; 
    va_start(arg_ptr, cnt); 
    for(i = 0; i < cnt; i++)
    {
     value = va_arg(arg_ptr,int);
     printf("value%d=%d/n", i+1, value);
    }
   }
   
   虽然可以根据上面两个办法解决读取参数个数的问题,但是如果参数类型都是不定的,该怎么办,如果不知道参数的类型,即使读到了参数也没有办法进行处理.解决办法:可以自定义一些可能出现的参数类型,这样在可变参数列表中,可以可变参数列表中的那类型,然后根据类型,读取可变参数值,并进行准确地转换.传递参数的时候可以这样传递:参数数目,可变参数类型1,可变参数值1,可变参数类型2,可变参数值2,....
   这里给出一个完整的例子:
   #include
   #include
   const int INT_TYPE  = 100000;
   const int STR_TYPE  = 100001;
   const int CHAR_TYPE  = 100002;
   const int LONG_TYPE  = 100003;
   const int FLOAT_TYPE = 100004;
   const int DOUBLE_TYPE = 100005;
   //第一个参数定义可选参数个数,用于循环取初参数内容
   //可变参数采用arg_type,arg_value...的形式传递,以处理不同的可变参数类型
   void arg_type(int cnt, ...);
   //第一个参数定义可选参数个数,用于循环取初参数内容
   void arg_cnt(int cnt, ...);
   //测试va_start,va_arg的使用方法,函数参数在堆栈中的地址分布情况
   void arg_test(int i, ...);
   int main(int argc,char *argv[])
   {
    int int_size = _INTSIZEOF(int);
    printf("int_size=%d/n", int_size);
    arg_test(0, 4);
    
    arg_cnt(4,1,2,3,4);
    arg_type(2, INT_TYPE, 222, STR_TYPE, "ok,hello world!");
    return 0;
   }

void arg_test(int i, ...)
{
 int j=0;
 va_list arg_ptr; 
 
 va_start(arg_ptr, i); 
 printf("&i = %p/n", &i);//打印参数i在堆栈中的地址
 printf("arg_ptr = %p/n", arg_ptr);
 //打印va_start之后arg_ptr地址,
 //应该比参数i的地址高sizeof(int)个字节
 //这时arg_ptr指向下一个参数的地址
 
 j=*((int *)arg_ptr);
 printf("%d %d/n", i, j); 
 j=va_arg(arg_ptr, int);
 printf("arg_ptr = %p/n", arg_ptr);
 //打印va_arg后arg_ptr的地址
 //应该比调用va_arg前高sizeof(int)个字节
 //这时arg_ptr指向下一个参数的地址
 va_end(arg_ptr);
 printf("%d %d/n", i, j);
}
void arg_cnt(int cnt, ...)
{
 int value=0;
 int i=0;
 int arg_cnt=cnt;
 va_list arg_ptr; 
 va_start(arg_ptr, cnt); 
 for(i = 0; i < cnt; i++)
 {
  value = va_arg(arg_ptr,int);
  printf("value%d=%d/n", i+1, value);
 }
}
void arg_type(int cnt, ...)
{
 int arg_type = 0;
 int int_value=0;
 int i=0;
 int arg_cnt=cnt; 
 char *str_value = NULL;
 va_list arg_ptr; 
 va_start(arg_ptr, cnt);
 for(i = 0; i < cnt; i++)
 {
  arg_type = va_arg(arg_ptr,int);
  switch(arg_type)
  {
  case INT_TYPE:
   int_value = va_arg(arg_ptr,int);
   printf("value%d=%d/n", i+1, int_value);
   break;
  case STR_TYPE:
   str_value = va_arg(arg_ptr,char*);
   printf("value%d=%d/n", i+1, str_value);
   break;
  default:
   break;
  }
 }
}
以上是我个人的见解,不对的地方希望大家指正,发表看法,我不胜感谢!!!

posted on 2008-01-21 15:30 浪迹天涯 阅读(11405) 评论(5)  编辑 收藏 引用 所属分类: C++

评论

va_start() va_end()函数应用

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

2:函数参数的传递原理
函数参数是以数据结构:栈的形式存取,从右至左入栈.eg:
#include
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!", "");
　　}
　　/*ANSI标准形式的声明方式，括号内的省略号表示可选参数*/
　　int demo( char msg, ... )
　　{
/*定义保存函数参数的结构*/
　　 va_list argp;
　　 int argno = 0;
　　 char para;

　　 /*argp指向传入的第一个可选参数，msg是最后一个确定的参数*/
　　 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 );
　　 /*将argp置为NULL*/
　　　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函数的实现，参考了中的例子
#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;
}
       

 re: va_list、va_start、va_arg、va_end的原理与使用 2009-05-14 08:05

多谢!
描述上有点问题
-----------------------
堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
最后一个参数
倒数第二个参数
...
第一个参数
函数返回地址
函数代码段
---------------------
stdcall才是这种情况...
       

 re: va_list、va_start、va_arg、va_end的原理与使用 2009-06-09 13:53

经典！！！       

 re: va_list、va_start、va_arg、va_end的原理与使用 2009-06-09 14:07

int demo( char msg, ... )
这个函数有个小问题（应该是char *，而不是char ），应改为：
/*ANSI标准形式的声明方式，括号内的省略号表示可选参数*/
int demo(char* msg, ...)
{
/*定义保存函数参数的结构*/
va_list argp;
int argno = 0;
char* para;

/*argp指向传入的第一个可选参数，msg是最后一个确定的参数*/
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);
/*将argp置为NULL*/
return 0;
}
       

 re: va_list、va_start、va_arg、va_end的原理与使用 2010-02-08 21:05

好！       

IT新闻：
·
·
·
·
·

专题：
招聘：

                标题 请输入标题 姓名 请输入你的姓名 主页 请输入验证码 验证码 * 内容(提交失败后,可以通过“恢复上次提交”恢复刚刚提交的内容) 请输入评论内容
Remember Me?                  [使用Ctrl+Enter键可以直接提交]

博客园首页随笔：
·
·
·
·
·

知识库：
·
·
·
·
·

相关文章:

  网站导航:

                       

#  re: va_list、va_start、va_arg、va_end的原理与使用 2008-01-21 15:30 浪迹天涯

< 2008年1月 >
日	一	二	三	四	五	六
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31	1	2
3	4	5	6	7	8	9

导航

• C++博客
• 首页
• 新随笔
• 联系
• 聚合
• 管理

统计

• 随笔 - 32
• 文章 - 0
• 评论 - 158
• 引用 - 0

公告

宠辱不惊 看庭前花开花落;
去留无意 望天上云卷云舒.
希望在服务器端开发上能有所成!
MSN:qj-qiujian#sohu.com(#->@)


稍微了解:
gsoap
xsl/xslt
[2.25]每日一句: He wiped off a debt. 他把债还清了。

常用链接

• 我的随笔
• 我的评论
• 我参与的随笔

留言簿(11)

• 给我留言
• 查看公开留言
• 查看私人留言

随笔分类(32)

• Boost (rss)
• C++(16) (rss)
• Java (rss)
• Lib(4) (rss)
• NetWork(1) (rss)
• Other(7) (rss)
• Perl (rss)
• ProjectManage (rss)
• STL(1) (rss)
• Thinking(2) (rss)
• Unix(1) (rss)

随笔档案(32)

• 2010年1月 (1)
• 2009年12月 (2)
• 2009年3月 (2)
• 2008年12月 (1)
• 2008年11月 (1)
• 2008年10月 (1)
• 2008年9月 (3)
• 2008年7月 (1)
• 2008年6月 (2)
• 2008年3月 (1)
• 2008年2月 (1)
• 2008年1月 (14)
• 2007年12月 (2)

文章分类

• 技术 (rss)
• 生活 (rss)
• 文学 (rss)

搜索

•  

积分与排名

• 积分 - 88280
• 排名 - 44

最新评论

• 1. re: VC一步一步编译OpenVPN
• 搜索如：symbol _GetAdaptersInfo@8中的GetAdaptersInfo函数，看看这个函数在哪个库中。
• --浪迹天涯
• 2. re: 有一些google wave邀请，谁要的留言!
• [email protected],邀请已发。
• --浪迹天涯
• 3. re: VC一步一步编译OpenVPN
• 请问怎样知道lnk错误是缺少哪个库文件？
• --vc6
• 4. re: 有一些google wave邀请，谁要的留言!
• [email protected]路人 来个谢谢
• --bluewater
• 5. re: va_list、va_start、va_arg、va_end的原理与使用
• 好！
• --chhaya
• 6. re: gsoap使用心得!
• 评论内容较长,点击标题查看
• --xiaohei
• 7. re: gsoap使用心得!
• http_get里面应该怎么写，返回值是什么？第一个例子,怎么才能让C#或者java或者C++的ISoapSerializerPtr 写的客户端去调用呢？
  请楼主赐教....
• --xiaohei
• 8. re: gsoap使用心得!
• 这个url过来的请求时http_get，你必须自己实现http_get方法，返回wsdl的真正内容即可。
• --浪迹天涯
• 9. re: gsoap使用心得!
• 我是依照你上面的方法建立的服务。。。。
• --xiaohei
• 10. re: gsoap使用心得!
• 评论内容较长,点击标题查看
• --xiaohei

阅读排行榜

• 1. va_list、va_start、va_arg、va_end的原理与使用(11405)
• 2. libcurl使用心得(7206)
• 3. vs2005奇怪的断点无效问题(6966)
• 4. gsoap使用心得!(6797)
• 5. 关闭笔记本触摸板(4756)

评论排行榜

• 1. gsoap使用心得!(32)
• 2. 再谈sizeof()的问题(17)
• 3. 这样的辞职报告感人吗？(15)
• 4. vs2005奇怪的断点无效问题(13)
• 5. 看看这只鸭子上藏了些什么？(11)

Powered by:
C++博客
Copyright © 浪迹天涯