C语言编程—可变参数

有时，您可能会碰到这样的情况，您希望函数带有可变数量的参数，而不是预定义数量的参数。

C 语言为这种情况提供了一个解决方案，它允许您定义一个函数，能根据具体的需求接受可变数量的参数。

声明方式为：

int func_name(int arg1, ...);

其中，省略号 ... 表示可变参数列表。

下面的实例演示了这种函数的使用：

int func(int, ... )  {
   .
   .
   .
}
 
int main() {
   func(2, 2, 3);
   func(3, 2, 3, 4);
}

请注意，函数 func() 最后一个参数写成省略号，即三个点号（...），省略号之前的那个参数是 int，代表了要传递的可变参数的总数。为了使用这个功能，您需要使用 stdarg.h 头文件，该文件提供了实现可变参数功能的函数和宏。具体步骤如下：

• 定义一个函数，最后一个参数为省略号，省略号前面可以设置自定义参数。

• 在函数定义中创建一个 va_list 类型变量，该类型是在 stdarg.h 头文件中定义的。

• 使用 int 参数和 va_start() 宏来初始化 va_list 变量为一个参数列表。宏 va_start() 是在 stdarg.h 头文件中定义的。

• 使用 va_arg() 宏和 va_list 变量来访问参数列表中的每个项。

• 使用宏 va_end() 来清理赋予 va_list 变量的内存。

常用的宏有：

• va_start(ap, last_arg)：初始化可变参数列表。ap 是一个 va_list 类型的变量，last_arg 是最后一个固定参数的名称（也就是可变参数列表之前的参数）。该宏将 ap 指向可变参数列表中的第一个参数。

• va_arg(ap, type)：获取可变参数列表中的下一个参数。ap 是一个 va_list 类型的变量，type 是下一个参数的类型。该宏返回类型为 type 的值，并将 ap 指向下一个参数。

• va_end(ap)：结束可变参数列表的访问。ap 是一个 va_list 类型的变量。该宏将 ap 置为 NULL。

现在让我们按照上面的步骤，来编写一个带有可变数量参数的函数，并返回它们的平均值：

#include <stdio.h>
#include <stdarg.h>
 
double average(int num,...)
{
 
    va_list valist;
    double sum = 0.0;
    int i;
 
    /* 为 num 个参数初始化 valist */
    va_start(valist, num);
 
    /* 访问所有赋给 valist 的参数 */
    for (i = 0; i < num; i++)
    {
       sum += va_arg(valist, int);
    }
    /* 清理为 valist 保留的内存 */
    va_end(valist);
 
    return sum/num;
}
 
int main()
{
   printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
   printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}

在上面的例子中，average() 函数接受一个整数 num 和任意数量的整数参数。函数内部使用 va_list 类型的变量 va_list 来访问可变参数列表。在循环中，每次使用 va_arg() 宏获取下一个整数参数，并输出。最后，在函数结束时使用 va_end() 宏结束可变参数列表的访问。

当上面的代码被编译和执行时，它会产生下列结果。应该指出的是，函数 average() 被调用两次，每次第一个参数都是表示被传的可变参数的总数。省略号被用来传递可变数量的参数。

Average of 2, 3, 4, 5 = 3.500000
Average of 5, 10, 15 = 10.000000

一、可变参数

#include <stdio.h>

void debug_arg(unsigned int num, ...) 
{
    unsigned int i = 0;
    unsigned int *addr = &num;
    for (i = 0; i <= num; i++) 
    {
        /* *(addr + i) 从左往右依次取出传递进来的参数,类似于出栈过程 */
        printf("i=%d,value=%d\r\n", i, *(addr + i));
    }
}
int main(void)
{
    debug_arg(3, 66, 88, 666);
    return 0;
}

可变参数的工作原理,以32位机为例:

• 1.函数参数的传递存储在栈中,从右至左压入栈中,压栈过程为递减。

• 2.参数的传递以4字节对齐,float/double这里不讨论。

// 64 位机器用 8 字节对齐, 32 位 4 位对齐
#ifdef X64
#defin t long long
#else
#define t int
#endif

//VA_LIST套宏中可以使用，用来改变INTSIZEOF中t的类型
//固定参数详见
void test(int a, double b, char* c)
{
    char *p = (char*)&a;
    //因为&a = void 类型 需要转换,void * =&a 不需要转换但是使用时要转换
    printf("%p %p %p\n", &a, &b, &c);
    //观察地址变化
    printf("%p %s",(p+8),*(char**)(p+8+8));//64位机器时加8内存大小8字节对齐
    return;
}

//可变参数实验
void test1(char* s,char *st,...)
{
    char *ppt =(char*)&s;
    //printf("%p %p %p %p,",ppt,&s,&st,(char*)ppt+8);
    printf("%p %p %p %p\n", ppt, &s, &st, ppt + 8);
    printf("%s\n", *(char**)(ppt+4));
    printf(" %d\n",*(int*)(ppt + 4+4));//当是X64就加8 X86就加4因为内存对齐规则
    return;
}

int main()
{
    char *p = "Hello world";
    test1("111","eee",45234,23);
    //test(2, 2.2, "Hello world");x
    void *s = &p;
    printf("%s", *(char**)s);
    return 0;
}

C 语言提供了可变参数的支持，通过使用 <stdarg.h> 头文件中的宏和函数可以实现可变参数。主要涉及到的函数和宏如下：

• va_start(va_list ap, last_arg) 宏：用于将ap指向可变参数列表的第一个参数，last_arg为可变参数列表中的最后一个已知参数，通常是一个函数形参。在使用可变参数前应该先调用该宏。

• va_arg(va_list ap, type) 宏：用于获取ap指向的当前参数，并将指针移动到下一个参数。type表示当前参数的类型。

• va_copy(va_list dest, va_list src) 宏：用于将src指向的参数复制到dest中。

• va_end(va_list ap) 宏：用于结束可变参数的获取，并释放资源。

下面是一个示例程序，展示了如何使用可变参数：

#include <stdarg.h>
#include <stdio.h>

int sum(int count, ...) {
    va_list ap;  // 定义可变参数列表
    int result = 0;
    va_start(ap, count);  // 将ap指向可变参数列表的第一个参数
    for (int i = 0; i < count; ++i) {
        result += va_arg(ap, int);  // 获取当前参数，并将指针移动到下一个参数
    }
    va_end(ap);  // 结束可变参数的获取
    return result;
}

int main() {
    printf("sum(3, 1, 2, 3) = %d\n", sum(3, 1, 2, 3));
    printf("sum(5, 1, 2, 3, 4, 5) = %d\n", sum(5, 1, 2, 3, 4, 5));
    return 0;
}

输出结果为：

sum(3, 1, 2, 3) = 6
sum(5, 1, 2, 3, 4, 5) = 15