C语言可变参数函数（printf/scanf）

落日映苍穹つ 2023-01-15 09:25 188阅读 0赞

C 语言允许定义参数数量可变的函数，这称为**可变参数函数（variadic function）**。这种函数需要**固定数量的强制参数（mandatory argument）**，后面是数量**可变的可选参数（optional argument）**。  
  
这种函数必须至少有一个强制参数。可选参数的类型可以变化。可选参数的数量由强制参数的值决定，或由用来定义可选参数列表的特殊值决定。

平时我们写C语言函数时，一般是固定参数的，但是像打印输出格式化内容时，其参数个数就不确定了，类似如下：

> printf("This is a sample, %s, %d, %u", "variable-argument", -20, 50);

对printf函数来说，需要格式化的内容是怎样的形式，完全由程序员决定，这就导致参数个数不定（从第二个参数开始，第一个参数是固定的字符串类型），因此printf的函数原型只能采用可变参数的形式。下面是C语言中printf原型：

> extern int printf(const char \*format,...);

# a\_start、va\_arg、va\_end和va\_list #

对于每一个强制参数来说，函数头部都会显示一个适当的参数，像普通函数声明一样。参数列表的格式是强制性参数在前，后面跟着一个逗号和省略号（...），这个省略号代表可选参数。  
  
可变参数函数要获取可选参数时，必须通过一个类型为 **va\_list** 的对象，它包含了参数信息。这种类型的对象也称为**参数指针**（argument pointer），**它包含了栈中至少一个参数的位置**。**可以使用这个参数指针从一个可选参数移动到下一个可选参数，由此，函数就可以获取所有的可选参数**。va\_list 类型被定义在头文件 stdarg.h 中。va在这里是variable-argument(可变参数)的意思。  
  
当编写支持参数数量可变的函数时，必须用 va\_list 类型定义参数指针，以获取可选参数。在下面的讨论中，va\_list 对象被命名为 argptr。可以用 4 个宏来处理该参数指针，这些宏都定义在头文件 stdarg.h 中：

> void va\_start(va\_list argptr, lastparam);

宏 **va\_start** 使用第一个可选参数的位置来初始化 argptr 参数指针。该宏的第二个参数必须是该函数最后一个有名称参数的名称。必须先调用该宏，才可以开始使用可选参数。

> type va\_arg(va\_list argptr, type);

展开宏 **va\_arg** 会得到当前 argptr 所引用的可选参数，也会将 argptr 移动到列表中的下一个参数。宏 va\_arg 的第二个参数是刚刚被读入的参数的类型。

> void va\_end(va\_list argptr);

当不再需要使用参数指针时，必须调用宏 **va\_end**。如果想使用宏 va\_start 或者宏 va\_copy 来重新初始化一个之前用过的参数指针，也必须先调用宏 va\_end。

>     void va_copy(va_list dest, va_list src);

宏 va\_copy 使用当前的 src 值来初始化参数指针 dest。然后就可以使用 dest 中的备份获取可选参数列表，从 src 所引用的位置开始。

typedef int *va_list[1];
    
    #define va_start(ap, parmN)    (void)(*(ap) = __va_start(parmN))
    #define va_arg(ap, type)      __va_arg(*(ap), type)
    #define va_end(ap)          ((void)(*(ap) = 0))

它的实现原理利用了**内存的压栈技术**，将参数压入（push）栈内，使用时，再逐个从栈里pop出来。需要注意的是，压栈的顺序是从**最右边参数开始**的，再向左逐个压入，根据栈的原理，在取参数时，就从第一个可变参数开始了。

在VS2017-X86平台下的源码：

typedef char* va_list;
    #define _ADDRESSOF(v) (&(v))
    #define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
    
    #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))
    #define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
    
    #define va_start __crt_va_start
    #define va_arg   __crt_va_arg
    #define va_end   __crt_va_end
    #define va_copy(destination, source) ((destination) = (source))

## 使用方法 ##

> 1.  定义一个函数，最后一个参数为省略号，省略号前面可以设置自定义参数。
> 2.  在函数定义中创建一个 va\_list 类型变量，该类型是在 stdarg.h 头文件中定义的。
> 3.  使用 int 参数和 va\_start 宏来初始化 va\_list 变量为一个参数列表。宏 >- va\_start 是在 stdarg.h 头文件中定义的。
> 4.  使用 va\_arg 宏和 va\_list 变量来访问参数列表中的每个项。
> 5.  使用宏 va\_end 来清理赋予 va\_list 变量的内存。

## 注意事项 ##

1.  定义的函数**必须至少有一个固定参数**；这么做的目的很明显，就是要定位变参的首地址，也就是固定参数地址+sizeof（固定参数类型）啦；
2.  固定参数和可变参数之间可以没有任何关系；虽然经典的printf函数中，第一个固定参数里（格式化字符串）包含了后续变参的类型，但是这仅仅是函数功能的需要，语法上没有任何要求，下面的例子就可以证明这一点；

#include <stdarg.h>
    #include <stdio.h>
    
    void variable_argument(int fix_argument1, int fix_argument2, ...)
    {
        va_list ptr;
    
        va_start(ptr, fix_argument2);
        int first = va_arg(ptr, int);
        int second = va_arg(ptr, int);
        int third = va_arg(ptr, int);
        char* four = va_arg(ptr, char*);
        float five = va_arg(ptr, double);
    
        va_end(ptr);
    
        printf("first is %d, second is %d, third is %d, four is %s, five is %f\n", first, second, third, four, five);
    
        return;
    }
    
    int main(int argc, char** argv[])
    {
        variable_argument(1, 2, 5, 2, -5, "Hello", 3.14159);
        return 0;
    }

// 函数add() 计算可选参数之和
    // 参数：第一个强制参数指定了可选参数的数量，可选参数为double类型
    // 返回值：和值，double类型
    double add(int n, ...)
    {
    	int i = 0;
    	double sum = 0.0;
    	va_list argptr;
    	va_start(argptr, n);             // 初始化argptr
    	for (i = 0; i < n; ++i)       // 对每个可选参数，读取类型为double的参数，
    		sum += va_arg(argptr, double); // 然后累加到sum中
    	va_end(argptr);
    	return sum;
    }
    
    //double s = add(5, 1.0, 2.0, 3.0, 4.0, 5.0);

#include <stdio.h>
    #include <stdlib.h>
    #include <stdarg.h>
    
    int average(int n, ...)
    {
        va_list arg;
        int i = 0;
        int sum = 0;
        va_start (arg, n);
        for (i=0; i<n; i++)
        {
            sum += va_arg(arg, int);
        }
        return sum/n;
        va_end (arg);
    }
    
    int main()
    {
        int ret1 = average (5, 4, 5, 6, 7, 8);
        int ret2 = average (3, 4, 5, 6);
        printf ("ret1 = %d, ret2 = %d\n", ret1, ret2);
        system ("pause");
        return 0;
    }

参考文章：

[C语言中可变参数的使用方法][C]

[C语言可变参数列表知识总结][C 1]

[【干货】C语言可变参数][C 2]

[C]: https://blog.csdn.net/ericbar/article/details/79558827
[C 1]: https://blog.csdn.net/A__B__C__/article/details/80240736
[C 2]: https://blog.csdn.net/cbwem/article/details/85332094