C语言变参数函数详解_c语言可变参数函数

可以参考一下之前写过的一篇博客:从main函数参数，printf多参数来了解C语言可变参数函数

在printf函数中，我们一般可以控制输入函数的参数：

printf("%d\n", i);
printf("%d %d\n", i, j);

这样看来，printf函数是有一种机制来处理这种可变参数。

我们先看看printf源码：

int printf
    (
    const char \*  fmt,	/\* format string to write \*/
    ...      		/\* optional arguments to format string \*/
    )
    {
    va_list vaList;	/\* traverses argument list \*/
    int nChars;

    va\_start (vaList, fmt);
    nChars = fioFormatV (fmt, vaList, printbuf, 1);
    va\_end (vaList);

    return (nChars);
    }
    
typedef struct {
	char \*a0;	/\* pointer to first homed integer argument \*/
	int offset;	/\* byte offset of next parameter \*/
} va_list;

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

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*
\* printbuf - printf() support routine: print characters in a buffer
\*/

LOCAL STATUS printbuf
    (
    char \*buf,
    int nbytes,
    int fd
    )
    {
    return (write (fd, buf, nbytes) == nbytes ? OK : ERROR);
    }

C++中有函数重载这种方法，以供我们调用时要可以不确定实参的个数，其实 C 语言也可以，而且更高明！

我们在stdio.h 中可以看到 printf() 函数的原型：

int printf(char * format,…)

事实上，我们如果要写这样的函数也可以类似的写，那么在定义函数时用上这个符号“ … ” ，它叫占位符，喊它 “ 三个点 ” 也可以，只要你愿意！那么我可以这样定义我的函数：

fun(int a,…) { }
要实现可变参数函数，我们需要用到下面几个比较重要的东西：

va_list
va\_arg()
va\_start()

三、C语言函数调用堆栈过程

在此之前我们需要了解一下函数调用时的传参过程，在调用函数时，程序同样会把实参传入，在函数存储区保存起来，如果有很多参数，将一起保存起来。

调用约定

函数的调用约定很多，常见的包括__stdcall，__cdecl，__fastcall，__thiscall等等。
主要的区别在于约束的三个事件，一个是***参数传递*是从左开始呢还是从右开始，还有就是堆栈清理的清理方*是调用者还是被调用者。另外来说不同的函数调用约定函数产生的符号名称不同***。

举个栗子，对于cdecl，参数是从右到左传递，堆栈平衡是由调用函数来执行的；而win32API一般使用的是stdcall，参数同样是采用了从右往左传递，而函数的堆栈平衡则是由被调用函数执行（不支持可变参数）；fastcall参数直接放入寄存器而非栈中，规定前两个参数分别放入ecx和edx中，当寄存器用完时候参数才按照从右往左的顺序压入堆栈。

调用约定	使用场景
_cdecl	c调用约定
_stdcall	windows标准调用约定
_fastcall	快速调用约定
_thiscall	C++成员函数调用约定

---

压栈过程

int add(int a, int b)
{
    return a+b;
}

int main()
{
    int a = 1;
    int b = 2;
    int res = add(a,b);
    return 0;
}

1. 首先从main函数初始，ebp和esp分别存放函数的栈底地址和栈顶地址，此时ebp-4即是a，ebp-8则是b的地址。

2. 然后调用函数add，第一先将参数从右往左依次入栈，push在调用方的函数栈当中，也就是说此时esp往里开辟了两个参数。
   

3. 执行call指令，首先将下一条指令地址进行入栈，
   

4. 随后开辟新栈，进行现场保护
   

   • 这里省略了现场保护的过程，主要做的就是push了多个寄存器（例如edi，ebx，edi）的值，在完成后还原现场进行pop，对程序没有什么其他影响这里省略。
   • 将edi置为栈顶地址，ecx置为11h，eax置为0CCCCCCCCh。
   • 从edi开始循环拷贝eax，也就是将整个栈内初始化为0CCCCCCCCh，也就是常见的“烫”。

5. 执行add函数
   开辟一个临时变量，值是***（a）*（ebp+8） + *（b）*（ebp+0Ch）**，将这个值放入eax中。

6. 执行完成后回退栈针
   

   • 首先mov esp,ebp 将add的函数栈回退。
   • 随后pop，将[ebp]的值弹出给ebp，也就是ebp弹回退到main函数的栈底。
   • 执行ret指令，将下一条指令的地址弹出给eip寄存器。
   • 随后在main函数的函数栈中回退形参变量所占用的内存 add esp+8。

---

那么再来看看其他情况

上面的返回值是一个int类型，也就是C的内置类型，通过eax寄存器带出。

如果是一个double或者long long呢？那么可以通过eax、edx两个寄存器带出。

如果是一个自定义类型呢？其实也是类似的：

• 首先在参数传参过程中不能直接去push一个寄存器了，而现在是通过开辟内存后，将自定义类型的实参b的地址放入esi中，循环赋给实参。
  例如说自定义类型的b参数
  
• 参数传递完成之后，再来看看返回值，返回值首先会在压入所有的形参之后，将main函数中返回值（临时量）的地址压入参数。
  
• 对返回值的操作也是类似的，通过esi和edi、ecx，循环拷贝到main函数的函数栈之中。
• 临时量返回值的地址是最后才会压栈的，那么它的地址一定是ebx+8

四、C语言实现可变参数详解

虽说是可变参数，但也并不是完全自由的，对于任意的可变参数函数，至少需要指定一个参数，通常这个参数包含对传入参数的描述(下面会提到原因)。
可变参数的实现依赖下列几个库函数(宏定义)的定义：

va_list           //这是一个特殊的指针类型，指代栈中参数的开始地址
va\_start(ap,T)    //ap为va\_list类型，T为函数第一个参数
va\_args(ap,A)     //ap为va\_list类型，A为需要取出的参数类型，如int，char
va\_end(ap)        //ap为va\_list类型。

这些变量类型或者宏定义的含义如下：

typedef struct {
	char \*a0;	/\* pointer to first homed integer argument \*/
	int offset;	/\* byte offset of next parameter \*/
} va_list;

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

接下来我们便动手实现一个可变参数函数add(),返回所有传入的int型参数之和：

int add(int cnt, ... )
{
    int sum=0;
    va_list args;
    va\_start(args,cnt);
    for(int i=0;i<cnt;i++)
    {
        sum += va\_arg(args,int);
    }
    va\_end(args);
    return sum;
}
int main()
{
    
    printf("%d\r\n",add(4,1,2,3,4));
    return 0;
}

程序输出结果：

10

老规矩，看完示例我们来探究一下示例实现的原理：

• va_list args;这一条语句即定义一个va_list类型(可以看成是一种特殊的指针类型)的变量args，args变量指向的对象是栈上的数据。
• va_start(args,cnt);这一条语句是初始化args，args指向第一个被压栈的参数，即函数的最后一个参数，而cnt则是栈上最后一个参数，系统由此确定栈上参数内存的范围。
• va_arg(args,int); 这个函数需要传入两个参数，一个是指向栈上参数的指针args，这个指针每取出一个数据移动一次，总是指向栈上第一个未取出的参数，int指代需要取出参数的类型，CPU根据这个类型所占地址空间来进行寻址。
• va_end(args);当args使用完之后，要将args置为空。
  整个函数实现的过程就是我们不需要通过形参来获取实参的值，而是直接从栈上将一个个参数取出来。

下面我用图来说明一下这个过程：

#define va\_start(ap,v) ( ap = (va\_list)&v + \_INTSIZEOF(v) )

这条语句就是获取add(4,1,2,3,4)中第二个参数的地址(即除去参数cnt外的第一个参数)

#define va\_arg(ap,t) ( \*(t \*)((ap += \_INTSIZEOF(t)) - \_INTSIZEOF(t)) )

这条语句有两个作用：一是返回 ap 指向的参数的值；二是让 指针 ap 移动了sizeof(t)的大小，这让我们在获取下一个参数时不需要再移动指针。

这样通过参数指针和参数类型，我们就可以一个一个的把参数取出来。

五、需要关注的一些问题

在这里，我们需要关注几个问题：

1. 压栈顺序从右往左是怎样实现可变参数传递的？
2. printf()函数和上述的add()实现都在可变参数前至少提供了一个具体参数，可不可以省略这个参数呢？
3. 在使用va_arg()取出函数的值时需要指定类型，如果指定一个错误的类型会怎么样呢？

第一和第二个问题其实可以同时来解释，参数从右往左压栈，在可变参函数调用时，先将最后一个参数入栈，最后将第一个参数入栈，可变参数主要是通过第一个参数来确定参数列表，但是这时候如果第一个参数没有被指定的话，编译器将无法定位参数在栈上的范围。

同时，如果可变参数函数在定义时没有第一个参数的话，编译器直接报错。(gcc)

test.c:10:10: error: ISO C requires a named argument before ‘...’

va_arg对应类型问题

我们再回到第三个问题，如果在va_arg()函数中传入一个错误的类型会发生什么情况呢？

下面是我传入一个int型数据，但是在用va_arg()获取参数时传入了char类型，编译时的信息：

warning: ‘char’ is promoted to ‘int’ when passed through ‘...’
sum += va\_arg(args,char);                  ^
note: (so you should pass ‘int’ not ‘char’ to ‘va_arg’)
note: if this code is reached, the program will abort

警告信息，但是不会报错，依然可以运行，那我们就运行看看结果：

Illegal instruction (core dumped)

果然，如编译时的警告预料的，当执行到那部分代码时，程序就会终止运行。

这是为什么呢？

其实原因也并不难想到，被调用函数并不知道参数的类型和个数，所以只能依靠用户给的信息来寻址获取数据，如果指定错误的类型，很可能会导致栈上数据的混乱，但是这里博主发现一个有意思的问题：

如果传入的参数为char类型，我们在从栈上取参数的时候也指定char类型参数：

sum += va\_arg(args,char);

按理说这是完全没有问题的，但是在编译的时候依然会有以下提示：

warning: ‘char’ is promoted to ‘int’ when passed through ‘...’