stdarg.h以宏的形式定义变量列表- -va_list,va_start,vava_arg,_arg,va_end

最新推荐文章于 2023-02-12 09:23:37 发布
最新推荐文章于 2023-02-12 09:23:37 发布
阅读量625 收藏
点赞数
文章标签： list 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55255438/article/details/122169359
版权

一、stdarg.h原文
va在这里是variable-argument(可变参数)的意思

#ifndef _STDARG_H 
#define _STDARG_H 
typedef char *va_list; // 定义 va_list 是一个字符指针类型
#define _va_rounded_size(TYPE)(((sizeof(TYPE) + sizeof(int) - 1)/sizeof(int)) *sizeof(int)) 
#ifndef __spare__
#define va_start(AP, LASTARG)
   (AP = ((char *) &(LASTARG) + va_rounded size(LASTARG)))
#else
#define va_start(AP, LASTARG)
(__builtin_saveregs(), 
   AP = ((char *) &(LASTARG) + _va_rounded_size(LASTARG)))
#endif  
void va_end (va_list); //void va_end (va_list);是声明，
//va_end在 gnulib 中定义,在有些代码中va_end定义为:#define   va_end(ap)  ( ap = (va_list)0 )
#define va_end(AP) //将函数va_end作成宏        
#define va_arg(AP,TYPE)  
(AP += va_rounded_size (TYPE), 
*((TYPE *)(AP -  va_rounded_size(TYPE)))) 
#endif

可以整理成宏if嵌套：

#ifndef _STDARG_H 
        #define _STDARG_H 
        typedef char *va_list; 
        #define _va_rounded_size(TYPE)(((sizeof(TYPE) + sizeof(int) - 1)/sizeof(int)) *sizeof(int)) //在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。
        
        
        #ifndef __spare__
                #define  va_start(AP, LASTARG)  (AP = ((char *) &(LASTARG) + va_rounded size(LASTARG)))
        #else
-               #define va_start(AP, LASTARG)  (__builtin_saveregs(),AP = ((char *) &(LASTARG) + _va_rounded_size(LASTARG)))
        #endif  
        
        
        void va_end (va_list); //void va_end (va_list);是声明，
        //va_end在 gnulib 中定义,在有些代码中va_end定义为:#define   va_end(ap)  ( ap = (va_list)0 )
        #define va_end(AP) //将函数va_end作成宏        
        #define  va_arg(AP,TYPE)  (AP += va_rounded_size (TYPE), *((TYPE *)(AP -  va_rounded_size(TYPE)))) 
#endif

二 在实际情景中分析其中的宏

#include<stdio.h>
#include<stdlib.h>
#include<stdarg.h>
 
int add(int number, ...)//...代表多少个参数都可以。第一个add函数参数n指定了变参数列表参数的个数
{
	va_list v;//定义一个字符指针用于保存可以变长参数的列表
	va_start(v, number);//保存n之后的所有参数
	for (int i = 0; i < number; i++)
	{
		int data = va_arg(v, int);
		printf("%d\n", data);
	}
	va_end(v);//释放列表
 
	return 0;
}
void main()
{
    int a=3;
    int one=1;
    int two=2;
    int three=3;
    add(a,one,two,three);
    add(3,1,2,3);
}

输出
在这里插入图片描述
（1）__builtin_saveregs()：
函数builtin saveregs()是在gcc的库程序libgcc2. c中定义的，用于保存寄存器。

（2）_va_rounded_size()：

#define  _va_rounded_size(TYPE)  (((sizeof(TYPE) + sizeof(int) - 1)/sizeof(int)) *sizeof(int)) //type类型round圆形的


#define M (a+b)
......
......
s=M*M;
//上例程序中首先进行带参数宏定义，定义M来替代表达式(a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)*(a+b)

此情此景：TYPE为int，所以#define _va_rounded_size(int) (((4+4-1)/4)x4),即_va_rounded_size宏展开为(((4+4-1)/4)x4)，即返回4
（3）va_start()：

#define  va_start(AP, LASTARG)  (AP = ((char *) &(LASTARG) + va_rounded size(LASTARG)))

此情此景：va_start宏展开为v=number+4，即置v为number+4，返回v（v要先定义）。此时v指向可变参数列表中第一个参数
作用：开始获取可变参数列表中的第一个参数（…里面的第一个），也就是跳过第一个add函数参数n
（4）va_arg()：

 #define  va_arg(AP,TYPE)  (AP += va_rounded_size (TYPE), *((TYPE *)(AP -  va_rounded_size(TYPE))))

此情此景：va_arg宏展开为v=v+4,即置v为v+4，返回*((TYPE *)(v-4)
作用：循环使用，可循环获取到可变参数列表中的参数，v指向下一个参数地址，返回的则是当前参数地址
（5）va_end()：

#define  va_end(AP)  ( AP=(va_list)0 )//va_end在 gnulib 中定义,在有些代码中va_end最终是宏：#define  va_end(AP)  ( AP=(va_list)0 )

此情此景：va_end宏展开为(char*)(v=0),即置v为0，返回0。
作用：用于防止出现野指针

三补充仅作为了解
具体去看：https://www.cnblogs.com/LyShark/p/12730393.html
定义并使用有参函数: 我们给函数传递些参数,然后分析其反汇编代码,观察代码的展示形式.


```c
#include <stdio.h>

int Function(int x,float y,double z)
{
	if (x = 100)
	{
		x = x + 100;
		y = y + 100;
		z = z + 100;
	}
	return (x);
}

int main(int argc, char* argv[])
{
	int ret = 0;
	ret = Function(100, 2.5, 10.245);
	printf("返回值: %d\n", ret);
	return 0;
}

下方的反汇编代码就是调用函数ret = Function()的过程,该过程中可看出压栈顺序遵循的是从后向前压入的.

0041145E | C745 F8 00000000         | mov dword ptr ss:[ebp-0x8],0x0                       | main.c:17
00411465 | 83EC 08                  | sub esp,0x8                                          | main.c:18
00411468 | F2:0F1005 70584100       | movsd xmm0,qword ptr ds:[<__real@40247d70a3d70a3d>]  | 将10.245放入XMM0寄存器
00411470 | F2:0F110424              | movsd qword ptr ss:[esp],xmm0                        | 取出XMM0中内容,并放入堆栈
00411475 | 51                       | push ecx                                             |
00411476 | F3:0F1005 68584100       | movss xmm0,dword ptr ds:[<__real@40200000>]          | 将2.5放入XMM0
0041147E | F3:0F110424              | movss dword ptr ss:[esp],xmm0                        | 同理
00411483 | 6A 64                    | push 0x64                                            | 最后一个参数100
00411485 | E8 51FDFFFF              | call 0x4111DB                                        | 调用Function函数
0041148A | 83C4 10                  | add esp,0x10                                         |
0041148D | 8945 F8                  | mov dword ptr ss:[ebp-0x8],eax                       | 将返回值压栈
00411490 | 8BF4                     | mov esi,esp                                          | main.c:19
00411492 | 8B45 F8                  | mov eax,dword ptr ss:[ebp-0x8]                       |
00411495 | 50                       | push eax                                             |
00411496 | 68 58584100              | push consoleapplication1.415858                      | 415858:"返回值: %d\n"
0041149B | FF15 14914100            | call dword ptr ds:[<&printf>]                        | 输出结果
004114A1 | 83C4 08                  | add esp,0x8                                          |

压栈完成以后我们可以继续跟进call 0x4111DB这个关键CALL,此处就是运算数据的关键函数,跟进去以后,可发现其对浮点数的运算,完全是依靠XMM寄存器实现的.

004113F1 | 8945 08                  | mov dword ptr ss:[ebp+0x8],eax                       |
004113F4 | F3:0F1045 0C             | movss xmm0,dword ptr ss:[ebp+0xC]                    | main.c:8
004113F9 | F3:0F5805 8C584100       | addss xmm0,dword ptr ds:[<__real@42c80000>]          |
00411401 | F3:0F1145 0C             | movss dword ptr ss:[ebp+0xC],xmm0                    |
00411406 | F2:0F1045 10             | movsd xmm0,qword ptr ss:[ebp+0x10]                   | main.c:9
0041140B | F2:0F5805 80584100       | addsd xmm0,qword ptr ds:[<__real@4059000000000000>]  |
00411413 | F2:0F1145 10             | movsd qword ptr ss:[ebp+0x10],xmm0                   |
00411418 | 8B45 08                  | mov eax,dword ptr ss:[ebp+0x8]                       | main.c:11
光电仪器设计学徒
关注
C/C++(6)va_list、va_start、va_arg、va_end实现可变参数列表函数
kღïξs√√
10-24 1234
经典的可变参数表printf函数的实现原理:在C/C++中，对函数参数的扫描是从后向前的。 函数参数是通过压入堆栈的方式来给函数传参数的,最先压入的参数最后出来，而栈是从内存的高地址向低地址存放的，控制存放位置的是堆栈指针，最先压入的参数是在最上面，最后压入的参数在最下面，结构上看起来是第一个，所以最后压入的参数总是能够被函数找到，因为它就在堆栈指针的上方。printf的第一个被找到的参数就是那个
va_list(),va_start(),va_arg(),va_end() 详细解析
09-05
些宏定义在stdarg.h中,所以用到可变参数的程序应该包含这个头文件.下面我们写一个简单的可变参数的函数,该函数至少有一个整数参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值
stdarg 宏
sduyyy的专栏
06-21 801
    可变参数列表是通过宏来实现的，这些宏定义于stdarg.h头文件，是标准库的一部分。这个头文件声明了一个类型va_list和三个宏va_start, va_arg和va_end。注意参数列表中的省略号。     注意：可变参数必须从头到尾按照顺序逐个访问。如果你一开始就想访问参数列表中间的参数，那是不行的。     首先声明一个类型为va_list、名叫var_arg的变量，用于访问参数列
c 函数 stdarg 宏
沈纵情
08-24 813
让我再找找资料再来写 #include "stdio.h" #include int average(int n_values,...) { va_list var_arg; int count ; float sum = 0; va_start(var_arg,n_values); for (count =0 ;count<n_values;c
8.C 不定数组 va_list stdarg.h
风一样的男人
07-18 469
菜鸟在线C编译器：1）或2）  1. http://www.compileonline.com/compile_c_online.php   2.http://www.runoob.com/try/runcode.php?filename=helloworld&amp;type=c   摘要： 注意：如果想要使用stdarg.h中的宏定义和类型对象，必须显示定义头文件#include ...
《C和指针》——stdarg宏简介
Learn From The Masters
04-01 485
可变参数列表是通过宏来实现的，这些宏定义于stdarg.h头文件，它是标准库的一部分。这个头文件声明了一个类型 va_list 和三个宏—— va_start、va_arg 和 va_end。我们可以声明一个类型为 va_list 的变量，与这几个宏配合使用，访问参数值。 函数声明了一个名叫 var_arg 的变量，它用于访问参数列表的未确定部分。这个变量通过调用 va_start 来初始纶。它的
关于C/C++中可变参数的详细介绍(va_list,va_start,va_arg,va_end)
09-04
这主要通过一组预定义的宏来实现，包括`va_list`、`va_start`、`va_arg`和`va_end`，这些宏定义在`stdarg.h`头文件中。下面我们将详细探讨这些宏的用途和工作原理。 1. `va_list`： `va_list`是一个类型定义，它...
stdarg.h中三个宏va_start ，va_arg和va_end的应用
05-15
### stdarg.h中三个宏va_start，va_arg和va_end的应用详解 在C语言中，经常需要编写能够接受可变数量参数的函数。一个典型的例子就是`printf`函数，它可以接受任意数量和类型的参数。为了支持这种功能，C语言提供了...
stdarg宏的用法
atinybirdinit的专栏
01-05 407
#include #include int sum(int n_values, ...) { va_list var_arg; int count; int sum = 0; va_start(var_arg, n_values); for (count = 0; count < n_values; ++count) { sum += va_arg(var_arg, in
C stdarg.h：可变参数va_list、va_arg等宏的使用及原理简介
kafmws的博客
12-07 1108
va_list、va_arg宏及 …的使用 va_list 可变参数宏，同标识符…相同，用于传递可变参数 当函数需要传递的参数个数不能确定时，如 printf，使用…声明接下来的多个参数， 在函数实现中使用va_list、va_arg等宏取出参数使用 具体使用方法如下 void func(type first_arg, ...){ va_list argptr;//声明参数列表指针 va_st...
可变参数列表_stdarg宏
微风
04-18 535
用于实现可变参数列表的-stdarg具有非常神奇的用途
<stdarg.h>
diyudong4681的博客
04-05 270
stdarg.h头文件定义了一个变量类型va_list和三个宏，这三个宏可用于在参数个数未知（即参数个数可变）时获取函数中的参数。 可变参数的函数通在参数列表的末尾是使用省略号(,...)定义的。 库变量 下面是头文件 stdarg.h 中定义的变量类型： 变量 描述 va_list 这是一个适用于 va_start(...
C语言（可变参数：stdarg.h）
最新发布
little_startoo的博客
02-12 974
可变参数：stdarg.h
stdarg.h
liugan528的博客
03-02 319
示例1： #include <stdio.h> #include <stdarg.h> void PrintFloats(int num, const char * verify, ...) { va_list ap, aq; va_start(ap, verify); // 指定ap开始的位置是最后一个有名字的参数verify后面一个参数 ...
【C++】关于可变参数函数、vsprintf()函数、stdarg.h的宏函数使用
Blacktone的博客
03-19 1246
可变参数函数 C++允许定义形参个数和类型不确定的函数； 在声明不确定形参可以使用省略号 ... 代替； 故在函数调用是，不检查形参类型你是否与实参类型相同，也不检查参数个数； 实例 void func(int i, ...); 需要注意的是，编译器需要检查第一个参数，故第一个参数不可省略； 对于可变参数的函数，需要进行特殊的处理。首先需要引用 <stdarg.h>头文件，然后利用va_list类型和va_start、va_arg、va_end 3个宏读取传递到函数中的参数值。 &l
stdarg c语言,stdarg的用法（可变参数的用法）
weixin_34870207的博客
05-20 249
stdarg宏：可变参数列表是通过宏来实现的，这些宏定义于stdarg.h头文件，它是标准库的一部分。这个头文件声明的一个va_list的类型，和三个宏va_start，va_arg，va_end。我们可以生明一个va_list类型的变量，配合三个宏使用。va_start(arg, last have name arg);初始化之后，arg将指向第一个无名参数。va_arg(arg， next a...
stdarg宏用法--------可变参数调用
偏执
05-02 936
stdarg宏——可变参数调用，定义于stdarg.h头文件，是标准库的一部分，这个主要在一些内核代码中经常看到，这个头文件声明了类型va_list和三个宏—–va_start,va_arg,va_end。一般声明一个va_list的变量，与这几个宏配合使用，访问参数的值。 var_arg用来访问参数列表的未确定部分，这个变量通过调用va_start来初始化。 va_start...
C语言可变参数及stdarg.h中的三个宏定义
seeappapp的专栏
03-13 2199
我们知道va_start,va_arg,va_end是在stdarg.h中被定义成宏的,由于1)硬件平台的不同 2)编译器的不同,所以定义的宏也有所不同,下面以VC++中stdarg.h里x86平台的宏定义typedef char *  va_list;#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(in
C语言中可变参数的用法
Augice's Blog
06-25 1403
我们在C语言编程中会遇到一些参数个数可变的函数,例如printf() 这个函数,它的定义是这样的:     int printf( const char* format, ...);     它除了有一个参数format固定以外,后面跟的参数的个数和类型是 可变的,例如我们可以有以下不同的调用方法:     printf("%d",i);     printf("%s",s);     print
C语言可变参数实现揭秘：从_va_list到_vsnprintf
C语言中的可变参数机制允许函数接受不同数量和类型的参数，这是通过`stdarg.h`头文件中的`va_list`、`va_start`、`va_arg`和`va_end`宏来实现的。`va_list`是一个类型定义，用于存储变长参数列表的指针；`va_start`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值