可变参数函数的原理与实例
2017-02-05 09:55
148 查看
在C/C++中，我们经常会用到可变参数的函数（比如printf/snprintf等），本篇笔记旨在讲解编译器借助va_start/va_arg/va_end这簇宏来实现可变参数函数的原理，并在文末给出简单的实例。
备注：本文的分析适用于Linux/Windows，其它操作系统平台的可变参数函数的实现原理大体相似。
1. 基础知识
如果想要真正理解可变参数函数背后的运行机制，建议先理解两部分基础内容：
1）函数调用栈
2）函数调用约定
关于这两个基础知识点，我之前的笔记有详细介绍，感兴趣的童鞋可以移步这里：栈与函数调用惯例—上篇 和栈与函数调用惯例—下篇
2. 三个宏：va_start/va_arg/va_end
由man va_start可知，这簇宏定义在stdarg.h中，在我的测试机器上，该头文件路径为：/usr/lib/gcc/x86_64-redhat-Linux/3.4.5/include/stdarg.h，在gcc源码中，其路径为：gcc/include/stdarg.h。
在stdarg.h中，宏定义的相关代码如下：
[cpp] view
plain copy
#define va_start(v,l) __builtin_va_start(v,l)
#define va_end(v) __builtin_va_end(v)
#define va_arg(v,l) __builtin_va_arg(v,l)
#if !defined(__STRICT_ANSI__) || __STDC_VERSION__ + 0 >= 199900L
#define va_copy(d,s) __builtin_va_copy(d,s)
#endif
#define __va_copy(d,s) __builtin_va_copy(d,s)
其中，前3行就是我们所关心的va_start & var_arg & var_end的定义（至于va_copy，man中有所提及，但通常不会用到，想了解的同学可man查看之）。可见，gcc将它们定义为一组builtin函数。
关于这组builtin函数的实现代码，我曾试图在gcc源码中沿着调用路径往下探索，无奈gcc为实现这组builtin函数引入了很多自定义的数据结构和宏，对非编译器研究者的我来说，实在有点晦涩，最终探索过程无疾而终。在这里，我列出目前跟踪到的调用路径，以便有兴趣的童鞋能继续探索下去或指出我的不足，先在此谢过。
__builtin_va_start()函数的调用路径：
[cpp] view
plain copy
// file: gcc/builtins.c
/* The "standard" implementation of va_start: just assign `nextarg' to the variable. */
void std_expand_builtin_va_start (tree valist, rtx nextarg)
{
rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
convert_move (va_r, nextarg, 0); // definition is in gcc/expr.c
}
// 上述代码中调用了expand_expr()来展开表达式，我猜测该函数调用完后，va_list指向了可变参数list前的最后一个已知类型参数
// file: gcc/expr.h
/* Generate code for computing expression EXP.
An rtx for the computed value is returned. The value is never null.
In the case of a void EXP, const0_rtx is returned.
*/
static inline rtx expand_expr (tree exp, rtx target, enum machine_mode mode,enum expand_modifier modifier)
{
return expand_expr_real (exp, target, mode, modifier, NULL);
}
3. Windows系统VS内置编译器对va_start/va_arg/va_end的实现
如前所述，我没能在gcc源码中找出va_startva_arg/va_end这3个宏的实现代码（⊙﹏⊙b汗），所幸的是，Windows平台VS2008集成的编译器中，对这三个函数有很明确的实现代码，摘出如下。
[cpp] view
plain copy
/* file path: Microsoft Visual Studio 9.0\VC\include\stdarg.h */
#include <vadefs.h>
#define va_start _crt_va_start
#define va_arg _crt_va_arg
#define va_end _crt_va_end
可见，Windows系统下，仍然将va_start/va_arg/va_end定义为一组宏。他们对应的实现在vadefs.h中：
[cpp] view
plain copy
/* file path: Microsoft Visual Studio 9.0\VC\include\vadefs.h */
#ifdef __cplusplus
#define _ADDRESSOF(v) ( &reinterpret_cast<const char &>(v) )
#else
#define _ADDRESSOF(v) ( &(v) )
#endif
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
#define _crt_va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
#define _crt_va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define _crt_va_end(ap) ( ap = (va_list)0 )
备注：在VS2008提供的vadefs.h文件中，定义了若干组宏以支持不同的操作系统平台，上面摘出的代码片段是针对IA x86_32的实现。
下面对上面的代码做个解释：
a. 宏_ADDRESSOF(v)作用：取参数v的地址。
b. 宏_INTSIZEOF(n)作用：返回参数n的size并保证4字节对齐（32-bits平台）。这个宏应用了一个小技巧来实现字节对齐：~(sizeof(int)
- 1)的值对应的2进制值的低k位一定是0，其中sizeof(int) = 2^k，因此，在IA x86_32下，k=2。理解了这一点，那么(sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1)的作用就很直观了，它保证了sizeof(n)的值按sizeof(int)的值做对齐，例如在32-bits平台下，就是按4字节对齐；在64-bits平台下，按8字节对齐。至于为什么要保证对齐，与编译器的底层实现有关，这里不再展开。
c. _crt_va_start(ap,v)作用：通过v的内存地址来计算ap的起始地址，其中，v是可变参数函数的参数中，最后一个类型已知的参数，执行的结果是ap指向可变参数列表的第1个参数。以int
snprintf(char *str, size_t size, const char *format, ...)为例，其函数参数列表中最后一个已知类型的参数是const char *format，因此，参数format对应的就是_crt_va_start(ap, v)中的v, 而ap则指向传入的第1个可变参数。
特别需要理解的是：为什么ap
= address(v) + sizeof(v)，这与函数栈从高地址向低地址的增长方向 及函数调用时参数从右向左的压栈顺序有关，这里默认大家已经搞清楚了这些基础知识，不再展开详述。
d. _crt_va_arg(ap,t)作用：更新指针ap后，取类型为t的变量的值并返回该值。
e. _crt_va_end(ap)作用：指针ap置0，防止野指针。
概括来说，可变参数函数的实现原理是：
1）根据函数参数列表中最后一个已知类型的参数地址，得到可变参数列表的第一个可变参数
2）根据程序员指定的每个可变参数的类型，通过地址及参数类型的size获取该参数值
3）遍历，直到访问完所有的可变参数
从上面的实现过程可以注意到，可变参数的函数实现严重依赖于函数栈及函数调用约定（主要是参数压栈顺序），同时，依赖于程序员指定的可变参数类型。因此，若指定的参数类型与实际提供的参数类型不符时，程序出core简直就是一定的。
4. 程序实例
经过上面对可变参数函数实现机制的分析，很容易实现一个带可变参数的函数。程序实例如下：
[cpp] view
plain copy
#include <stdio.h>
#include <stdarg.h>
void foo(char *fmt, ...)
{
va_list ap;
int d;
char c, *p, *s;
va_start(ap, fmt);
while (*fmt)
{
if('%' == *fmt) {
switch(*(++fmt)) {
case 's': /* string */
s = va_arg(ap, char *);
printf("%s", s);
break;
case 'd': /* int */
d = va_arg(ap, int);
printf("%d", d);
break;
case 'c': /* char */
/* need a cast here since va_arg only takes fully promoted types */
c = (char) va_arg(ap, int);
printf("%c", c);
break;
default:
c = *fmt;
printf("%c", c);
} // end of switch
}
else {
c = *fmt;
printf("%c", c);
}
++fmt;
}
va_end(ap);
}
int main(int argc, char * argv[])
{
foo("sdccds%%, string=%s, int=%d, char=%c\n", "hello world", 211, 'k');
return 0;
}
上面的代码很简单，旨在抛砖引玉，只要真正搞清楚了可变参数函数的原理，相信各位会写出更加复杂精细的可变参函数。
^_^
【参考资料】
1. linux man : va_start
2. wikipedia - x86 calling conventions
3. VS2008头文件：stdarg.h和vadefs.h的源码
================== EOF =================
备注：本文的分析适用于Linux/Windows，其它操作系统平台的可变参数函数的实现原理大体相似。
1. 基础知识
如果想要真正理解可变参数函数背后的运行机制，建议先理解两部分基础内容：
1）函数调用栈
2）函数调用约定
关于这两个基础知识点，我之前的笔记有详细介绍，感兴趣的童鞋可以移步这里：栈与函数调用惯例—上篇 和栈与函数调用惯例—下篇
2. 三个宏：va_start/va_arg/va_end
由man va_start可知，这簇宏定义在stdarg.h中，在我的测试机器上，该头文件路径为：/usr/lib/gcc/x86_64-redhat-Linux/3.4.5/include/stdarg.h，在gcc源码中，其路径为：gcc/include/stdarg.h。
在stdarg.h中，宏定义的相关代码如下：
[cpp] view
plain copy
#define va_start(v,l) __builtin_va_start(v,l)
#define va_end(v) __builtin_va_end(v)
#define va_arg(v,l) __builtin_va_arg(v,l)
#if !defined(__STRICT_ANSI__) || __STDC_VERSION__ + 0 >= 199900L
#define va_copy(d,s) __builtin_va_copy(d,s)
#endif
#define __va_copy(d,s) __builtin_va_copy(d,s)
其中，前3行就是我们所关心的va_start & var_arg & var_end的定义（至于va_copy，man中有所提及，但通常不会用到，想了解的同学可man查看之）。可见，gcc将它们定义为一组builtin函数。
关于这组builtin函数的实现代码，我曾试图在gcc源码中沿着调用路径往下探索，无奈gcc为实现这组builtin函数引入了很多自定义的数据结构和宏，对非编译器研究者的我来说，实在有点晦涩，最终探索过程无疾而终。在这里，我列出目前跟踪到的调用路径，以便有兴趣的童鞋能继续探索下去或指出我的不足，先在此谢过。
__builtin_va_start()函数的调用路径：
[cpp] view
plain copy
// file: gcc/builtins.c
/* The "standard" implementation of va_start: just assign `nextarg' to the variable. */
void std_expand_builtin_va_start (tree valist, rtx nextarg)
{
rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
convert_move (va_r, nextarg, 0); // definition is in gcc/expr.c
}
// 上述代码中调用了expand_expr()来展开表达式，我猜测该函数调用完后，va_list指向了可变参数list前的最后一个已知类型参数
// file: gcc/expr.h
/* Generate code for computing expression EXP.
An rtx for the computed value is returned. The value is never null.
In the case of a void EXP, const0_rtx is returned.
*/
static inline rtx expand_expr (tree exp, rtx target, enum machine_mode mode,enum expand_modifier modifier)
{
return expand_expr_real (exp, target, mode, modifier, NULL);
}
3. Windows系统VS内置编译器对va_start/va_arg/va_end的实现
如前所述，我没能在gcc源码中找出va_startva_arg/va_end这3个宏的实现代码（⊙﹏⊙b汗），所幸的是，Windows平台VS2008集成的编译器中，对这三个函数有很明确的实现代码，摘出如下。
[cpp] view
plain copy
/* file path: Microsoft Visual Studio 9.0\VC\include\stdarg.h */
#include <vadefs.h>
#define va_start _crt_va_start
#define va_arg _crt_va_arg
#define va_end _crt_va_end
可见，Windows系统下，仍然将va_start/va_arg/va_end定义为一组宏。他们对应的实现在vadefs.h中：
[cpp] view
plain copy
/* file path: Microsoft Visual Studio 9.0\VC\include\vadefs.h */
#ifdef __cplusplus
#define _ADDRESSOF(v) ( &reinterpret_cast<const char &>(v) )
#else
#define _ADDRESSOF(v) ( &(v) )
#endif
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
#define _crt_va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
#define _crt_va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define _crt_va_end(ap) ( ap = (va_list)0 )
备注：在VS2008提供的vadefs.h文件中，定义了若干组宏以支持不同的操作系统平台，上面摘出的代码片段是针对IA x86_32的实现。
下面对上面的代码做个解释：
a. 宏_ADDRESSOF(v)作用：取参数v的地址。
b. 宏_INTSIZEOF(n)作用：返回参数n的size并保证4字节对齐（32-bits平台）。这个宏应用了一个小技巧来实现字节对齐：~(sizeof(int)
- 1)的值对应的2进制值的低k位一定是0，其中sizeof(int) = 2^k，因此，在IA x86_32下，k=2。理解了这一点，那么(sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1)的作用就很直观了，它保证了sizeof(n)的值按sizeof(int)的值做对齐，例如在32-bits平台下，就是按4字节对齐；在64-bits平台下，按8字节对齐。至于为什么要保证对齐，与编译器的底层实现有关，这里不再展开。
c. _crt_va_start(ap,v)作用：通过v的内存地址来计算ap的起始地址，其中，v是可变参数函数的参数中，最后一个类型已知的参数，执行的结果是ap指向可变参数列表的第1个参数。以int
snprintf(char *str, size_t size, const char *format, ...)为例，其函数参数列表中最后一个已知类型的参数是const char *format，因此，参数format对应的就是_crt_va_start(ap, v)中的v, 而ap则指向传入的第1个可变参数。
特别需要理解的是：为什么ap
= address(v) + sizeof(v)，这与函数栈从高地址向低地址的增长方向 及函数调用时参数从右向左的压栈顺序有关，这里默认大家已经搞清楚了这些基础知识，不再展开详述。
d. _crt_va_arg(ap,t)作用：更新指针ap后，取类型为t的变量的值并返回该值。
e. _crt_va_end(ap)作用：指针ap置0，防止野指针。
概括来说，可变参数函数的实现原理是：
1）根据函数参数列表中最后一个已知类型的参数地址，得到可变参数列表的第一个可变参数
2）根据程序员指定的每个可变参数的类型，通过地址及参数类型的size获取该参数值
3）遍历，直到访问完所有的可变参数
从上面的实现过程可以注意到，可变参数的函数实现严重依赖于函数栈及函数调用约定（主要是参数压栈顺序），同时，依赖于程序员指定的可变参数类型。因此，若指定的参数类型与实际提供的参数类型不符时，程序出core简直就是一定的。
4. 程序实例
经过上面对可变参数函数实现机制的分析，很容易实现一个带可变参数的函数。程序实例如下：
[cpp] view
plain copy
#include <stdio.h>
#include <stdarg.h>
void foo(char *fmt, ...)
{
va_list ap;
int d;
char c, *p, *s;
va_start(ap, fmt);
while (*fmt)
{
if('%' == *fmt) {
switch(*(++fmt)) {
case 's': /* string */
s = va_arg(ap, char *);
printf("%s", s);
break;
case 'd': /* int */
d = va_arg(ap, int);
printf("%d", d);
break;
case 'c': /* char */
/* need a cast here since va_arg only takes fully promoted types */
c = (char) va_arg(ap, int);
printf("%c", c);
break;
default:
c = *fmt;
printf("%c", c);
} // end of switch
}
else {
c = *fmt;
printf("%c", c);
}
++fmt;
}
va_end(ap);
}
int main(int argc, char * argv[])
{
foo("sdccds%%, string=%s, int=%d, char=%c\n", "hello world", 211, 'k');
return 0;
}
上面的代码很简单，旨在抛砖引玉，只要真正搞清楚了可变参数函数的原理，相信各位会写出更加复杂精细的可变参函数。
^_^
【参考资料】
1. linux man : va_start
2. wikipedia - x86 calling conventions
3. VS2008头文件：stdarg.h和vadefs.h的源码
================== EOF =================
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- C/C++中用va_start/va_arg/va_end实现可变参数函数的原理与实例详解
- c语言中可变参数的原理---printf()函数
- 可变参数的函数 start va_arg va_end 的使用和原理
- 函数中的可变参数传递原理
- C语言可变参数函数实现原理
- Lua中的函数（function）、可变参数、局部函数、尾递归优化等实例讲解
- C/C++中可变参数的原理 与函数调用约定
- C语言中可变参数函数实现原理浅析
- C语言中可变参数函数实现原理
- C语言中可变参数函数实现原理
- C 语言可变参数函数原理及用法
- 可变参数的函数的原理及其简单模仿
- 解析可变参数函数的实现原理（printf,scanf)
- C语言中可变参数函数实现原理浅析
- 函数可变参数va_list、va_start、va_arg、va_end原理及使用方法
- JS与PHP向函数传递可变参数的区别实例代码
- 解析可变参数函数的实现原理（printf,scanf)
- C语言可变参数函数执行原理以应用
- C 语言的可变参数表函数的设计及原理 - printf(const char* format, ...)
- C语言可变参数函数实现原理