va_arg介绍

news/2024/12/3 2:31:22/

va_arg

1. 概述
由于在C语言中没有函数重载,解决不定数目函数参数问题变得比较麻烦;即使采用C++,如果参数个数不能确定,也很难采用函数重载.对这种情况,有些人采用指针参数来解决问题.下面就c语言中处理不定参数数目的问题进行讨论.
2. 定义
大家先看几宏.
在VC++6.0的include有一个stdarg.h头文件,有如下几个宏定义:
[cpp] view plain copy
  1. #define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )  
  2. #define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //第一个可选参数地址  
  3. #define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址  
  4. #define va_end(ap) ( ap = (va_list)0 ) // 将指针置为无效  
如果对以上几个宏定义不理解,可以略过,接这看后面的内容.
3. 参数在堆栈中分布,位置
在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,执行自己的代码来达到执行自己插入的代码段的目的.
总之,函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.
堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
最后一个参数
倒数第二个参数
...
第一个参数
函数返回地址
函数代码段
4. 示例代码
[cpp] view plain copy
  1. void arg_test(int i, ...);  
  2. int main(int argc,char *argv[])  
  3. {  
  4.     int int_size = _INTSIZEOF(int);  
  5.     printf("int_size=%d\n", int_size);  
  6.     arg_test(0, 4);  
  7.   
  8.   
  9.     arg_cnt(4,1,2,3,4);  
  10.     return 0;  
  11. }  
  12. void arg_test(int i, ...)  
  13. {  
  14.     int j=0;  
  15.     va_list arg_ptr;   
  16.   
  17.   
  18.     va_start(arg_ptr, i);   
  19.     printf("&i = %p\n", &i);//打印参数i在堆栈中的地址  
  20.     printf("arg_ptr = %p\n", arg_ptr);  
  21.     //打印va_start之后arg_ptr地址,  
  22.     //应该比参数i的地址高sizeof(int)个字节  
  23.     //这时arg_ptr指向下一个参数的地址  
  24.   
  25.   
  26.     j=*((int *)arg_ptr);  
  27.     printf("%d %d\n", i, j);   
  28.     j=va_arg(arg_ptr, int);  
  29.     printf("arg_ptr = %p\n", arg_ptr);  
  30.     //打印va_arg后arg_ptr的地址  
  31.     //应该比调用va_arg前高sizeof(int)个字节  
  32.     //这时arg_ptr指向下一个参数的地址  
  33.     va_end(arg_ptr);  
  34.     printf("%d %d\n", i, j);  
  35. }  
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.定义一个结束标记,在调用函数的时候,在最后一个参数中传递这个标记,这样在遍历可变参数的时候,可以根据这个标记结束可变参数的遍历;
下面是一段示例代码:
//第一个参数定义可选参数个数,用于循环取初参数内容
[cpp] view plain copy
  1. void arg_cnt(int cnt, ...);  
  2. int main(int argc,char *argv[])  
  3. {  
  4.     int int_size = _INTSIZEOF(int);  
  5.     printf("int_size=%d\n", int_size);  
  6.     arg_cnt(4,1,2,3,4);  
  7.     return 0;  
  8. }  
  9. void arg_cnt(int cnt, ...)  
  10. {  
  11.     int value=0;  
  12.     int i=0;  
  13.     int arg_cnt=cnt;  
  14.     va_list arg_ptr;   
  15.     va_start(arg_ptr, cnt);   
  16.     for(i = 0; i < cnt; i++)  
  17.     {  
  18.         value = va_arg(arg_ptr,int);  
  19.         printf("value%d=%d\n", i+1, value);  
  20.     }  
  21. }  
虽然可以根据上面两个办法解决读取参数个数的问题,但是如果参数类型都是不定的,该怎么办,如果不知道参数的类型,即使读到了参数也没有办法进行处理.解决办法:可以自定义一些可能出现的参数类型,这样在可变参数列表中,可以可变参数列表中的那类型,然后根据类型,读取可变参数值,并进行准确地转换.传递参数的时候可以这样传递:参数数目,可变参数类型1,可变参数值1,可变参数类型2,可变参数值2,....
这里给出一个完整的例子:
[cpp] view plain copy
  1. #include   
  2. #include   
  3. const int INT_TYPE = 100000;  
  4. const int STR_TYPE = 100001;  
  5. const int CHAR_TYPE = 100002;  
  6. const int LONG_TYPE = 100003;  
  7. const int FLOAT_TYPE = 100004;  
  8. const int DOUBLE_TYPE = 100005;  
  9. //第一个参数定义可选参数个数,用于循环取初参数内容  
  10. //可变参数采用arg_type,arg_value...的形式传递,以处理不同的可变参数类型  
  11. void arg_type(int cnt, ...);  
  12. //第一个参数定义可选参数个数,用于循环取初参数内容  
  13. void arg_cnt(int cnt, ...);  
  14. //测试va_start,va_arg的使用方法,函数参数在堆栈中的地址分布情况  
  15. void arg_test(int i, ...);  
  16. int main(int argc,char *argv[])  
  17. {  
  18.     int int_size = _INTSIZEOF(int);  
  19.     printf("int_size=%d\n", int_size);  
  20.     arg_test(0, 4);  
  21.   
  22.   
  23.     arg_cnt(4,1,2,3,4);  
  24.     arg_type(2, INT_TYPE, 222, STR_TYPE, "ok,hello world!");  
  25.     return 0;  
  26. }  
  27.   
  28.   
  29. void arg_test(int i, ...)  
  30. {  
  31.     int j=0;  
  32.     va_list arg_ptr;   
  33.   
  34.   
  35.     va_start(arg_ptr, i);   
  36.     printf("&i = %p\n", &i);//打印参数i在堆栈中的地址  
  37.     printf("arg_ptr = %p\n", arg_ptr);  
  38.     //打印va_start之后arg_ptr地址,  
  39.     //应该比参数i的地址高sizeof(int)个字节  
  40.     //这时arg_ptr指向下一个参数的地址  
  41.   
  42.   
  43.     j=*((int *)arg_ptr);  
  44.     printf("%d %d\n", i, j);   
  45.     j=va_arg(arg_ptr, int);  
  46.     printf("arg_ptr = %p\n", arg_ptr);  
  47.     //打印va_arg后arg_ptr的地址  
  48.     //应该比调用va_arg前高sizeof(int)个字节  
  49.     //这时arg_ptr指向下一个参数的地址  
  50.     va_end(arg_ptr);  
  51.     printf("%d %d\n", i, j);  
  52. }  
  53. void arg_cnt(int cnt, ...)  
  54. {  
  55.     int value=0;  
  56.     int i=0;  
  57.     int arg_cnt=cnt;  
  58.     va_list arg_ptr;   
  59.     va_start(arg_ptr, cnt);   
  60.     for(i = 0; i < cnt; i++)  
  61.     {  
  62.         value = va_arg(arg_ptr,int);  
  63.         printf("value%d=%d\n", i+1, value);  
  64.     }  
  65. }  
  66. void arg_type(int cnt, ...)  
  67. {  
  68.     int arg_type = 0;  
  69.     int int_value=0;  
  70.     int i=0;  
  71.     int arg_cnt=cnt;   
  72.     char *str_value = NULL;  
  73.     va_list arg_ptr;   
  74.     va_start(arg_ptr, cnt);  
  75.     for(i = 0; i < cnt; i++)  
  76.     {  
  77.         arg_type = va_arg(arg_ptr,int);  
  78.         switch(arg_type)  
  79.         {  
  80.             case INT_TYPE:  
  81.                 int_value = va_arg(arg_ptr,int);  
  82.                 printf("value%d=%d\n", i+1, int_value);  
  83.                 break;  
  84.             case STR_TYPE:  
  85.                 str_value = va_arg(arg_ptr,char*);  
  86.                 printf("value%d=%d\n", i+1, str_value);  
  87.                 break;  
  88.             default:  
  89.                 break;  
  90.         }  
  91.     }  
  92. }  


http://www.ppmy.cn/news/165131.html

相关文章

从va_list、va_start、va_arg、va_end想到了vsprintf的源码

从va_list、va_start、va_arg、va_end想到了vsprintf的源码

在前面的博文中&#xff0c; 我彻谈了从va_list、va_start、va_arg、va_end的用法&#xff0c; 但是&#xff0c; 当我看到某个程序后&#xff0c; 非常纳闷&#xff0c; 于是迫不及待得想知道vsprintf的实现。 在我的第一印象中&#xff0c; vsprintf貌似和vs有关&#xff0c;…
阅读更多...
可变参数va_start,va_arg,va_end的用法

可变参数va_start,va_arg,va_end的用法

一)写一个简单的可变参数的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_list:用来保存宏v…
阅读更多...
va_list函数学习（va_start，va_end, vasprintf）

va_list函数学习（va_start，va_end, vasprintf）

使用场景描述&#xff1a; 当函数的入参个数不确定时&#xff0c;使用va_list函数进行动态处理&#xff0c;增加编程的灵活性。 1.va_list 使用方法以及注意事项&#xff1a; 1.1使用方法&#xff1a; 1) 首先在函数中定义一个具有va_list型的变量&#xff0c;这个变量是指…
阅读更多...
va_start va_arg va_end 的原理与实例

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指向第一个可变参数 …
阅读更多...
AWVS

AWVS

一&#xff0c;什么是AWVS 全称是Acunetix Web Vulnerability Scanner 是一款知名的网络漏洞扫描工具&#xff0c;它通过网络爬虫测试你的网站安全&#xff0c;检测流行安全漏洞&#xff0c;是一款自动化的Web应用程序安全测试工具。 tip:可以看中是一款信息收集的工具&…
阅读更多...
va_list、 va_start、 vsprintf、va_end 用法

va_list、 va_start、 vsprintf、va_end 用法

小知识点总结&#xff1a;&#xff08;知识点2、3是为了更好理解知识点1&#xff09; 知识点1&#xff1a;va_list、 va_start、 vsprintf、va_end 用法&#xff1a; 看同事LCD工程里面有这样的应用-- va_list arg_ptr; va_start(arg_ptr, format); slen vsprintf(b…
阅读更多...
va rva rawaddress

va rva rawaddress

VA&#xff0c;虚拟地址&#xff0c;也就是程序被加载到内存中的地址 RVA&#xff0c;以虚拟地址前边加上个“相对的”&#xff0c;也就是说它还是按虚拟地址来换算&#xff0c;只不过不是从0开始&#xff0c;而是把一个模块的基址作为参考点。 RAW ADRRESS&#xff0c;或者FIL…
阅读更多...
va_start 与 va_end用法

va_start 与 va_end用法

1. 包含头文件: #include <stdarg.h> 2.使用方法 参考:http://www.cnblogs.com/hanyonglu/archive/2011/05/07/2039916.html #include <stdio.h> #include <stdarg.h> #include <string.h> //WIN7 64BIT #define PLAT_ADDRESS_SIZE 8 /*ANSI标准形…
阅读更多...
最新文章

Copyright @ 2022~2023