概要

众所周知，C++支出函数重载，而C语言默认是不支持。但是，C语言可以通过可变参数实现类似函数重载的功能。

如 Linux C 的open()函数，这个函数有2个版本。有一个可选的第三个参数时只需要文件可能被创建。第三个参数描述了使用新文件的权限设置。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int

那么我们如何指定一个可选的额外参数给C函数呢？这是一种C版本的函数重载。显然它不是由C++的”碾压”技术实现的，而是可以使用va_args包。

此函数的实现需要三个参数，最后一个参数为可选的可变参数，而需要使用可选的第三个参数时，需要借助第二个参数某个特定的值：

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

void va_overload2(int p1, int p2)
{
    printf("va_overload2 %d %d\n", p1, p2);
}

void va_overload3(int p1, int p2, int p3)
{
    printf("va_overload3 %d %d %d\n", p1, p2, p3);
}

//第三个参数为可变参数，使用...表示
static void va_overload(int p1, int p2, ...)
{
    if (p2 == 7)
    {
        va_list v;
        va_start(v, p2);

        int p3 = va_arg(v, int);
        va_end(v);
        va_overload3(p1, p2, p3);

        return;
    }

    va_overload2(p1, p2);
}

在上面的代码中，我们通过解析参数，然后选择调用 va_overload2() 或 va_overload3()。POSIX open()函数的原理和这个过程类似。

可变参数说明

#include <stdarg.h>//可变参数使用所需头文件
#include <stdio.h>

//可变参数( ... )的前面，必须需要一个有名字的变量，通常值为可变参数的个数
void func(int a, int n, ...)
{
    int i = 0;
    va_list ap; //可变参数列表

    //获得不定参数的首地址
    //第一个参数为可变参数列表变量
    //第二个参数必须为可变参数前面的最后一个参数值，如这里的n
    va_start(ap, n);

    for(i = 0; i < n; ++i)
    {
        // 获得每一个可变参数
        // 每次调用va_arg都会改变ap值，使得后续的参数值能被依次添加
        //第一个参数为可变参数列表变量
        //第二个参数为类型
        int num = va_arg(ap, int);
        printf("num = %d\n", num);
    }

    //参数获取完毕
    va_end(ap);
}

int main()
{
    func(1, 3, 10, 20, 30);

    return 0;
}

程序运行结果如下：

C语言可变参数的使用_#include

上述的宏原型如下所示：

#include <stdarg.h>
void va_start(va_list ap, last_parm);
type va_arg(va_list ap, type);
void

va_list是在C语言中解决变参问题的一组宏，用于获取不确定个数的参数。

在函数定义中，可变参数表之前必须有一个或多个已知参数，其中最右者为last_parm。在调用va_start()时，last_parm名被用作第二个参数。

任何可变长度的变元被访问之前，必须先用va_start()初始化变元指针ap。初始化ap后，经过对va_arg()的调用，以作为下一个参数类型的参数类型，返回参数。最后取完所有参数并从函数返回之前,必须调用va_end()。由此确保堆栈的正确恢复。

案例

案例1

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

//可变参数( ... )的前面，必须需要一个有名字的变量，通常值为可变参数的个数
int sum(int n, ...)
{
    int i = 0;
    int all = 0;
    va_list ap; //可变参数列表

    //获得不定参数的首地址
    //第一个参数为可变参数列表变量
    //第二个参数必须为可变参数前面的最后一个参数值，如这里的n
    va_start(ap, n);

    for(i = 0; i < n; ++i)
    {
        // 获得每一个可变参数
        // 每次调用va_arg都会改变ap值，使得后续的参数值能被依次添加
        //第一个参数为可变参数列表变量
        //第二个参数为类型
        int num = va_arg(ap, int);
        all += num; //累加
    }

    //参数获取完毕
    va_end(ap);

    return all;
}

int main()
{
    //第一个参数为可变参数个数
    int num = sum(5, 1, 2, 3, 4, 5);
    printf("num = %d\n", num);

    return 0;
}

案例2

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

//可变参数( ... )的前面，必须需要一个有名字的变量
void my_print(const char *s, ...)
{
    const char *arg = s;
    va_list ap; //可变参数列表

    //获得不定参数的首地址
    va_start(ap, s);

    while(arg)
    {
        // 获得每一个可变参数
        // 每次调用va_arg都会改变ap值，使得后续的参数值能被依次添加
        // 第一个参数为可变参数列表变量
        // 第二个参数为类型
        printf("%s\n", arg);
        arg = va_arg(ap, const char*);
    }

    //参数获取完毕
    va_end(ap);
}

int main()
{
    //最后一个参数为NULL，作为可变参数的结束符
    my_print("hello", "mike", "jiang", NULL);

    return 0;
}

案例3

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

//C99规范支持了可变参数的宏
//'...'指可变参数, 这类宏在被调用时，它(这里指'...')被表示成零个或多个符号，包括里面的逗号，一直到到右括弧结束为止
//当被调用时，在宏体(macro body)中，那些符号序列集合将代替里面的__VA_ARGS__标识符
#define debug1(fmt, ...) printf(fmt, __VA_ARGS__)

#define debug2(format, arg...) printf("[%s: %d] " format, __FILE__, __LINE__, ##arg)

#define debug3(fmt, ...) my_print(__FILE__, __LINE__, fmt, __VA_ARGS__)
void my_print(const char* filename, int line, const char* fmt, ...)
{
    printf("[%s: %d] ", filename, line);
    va_list ap;
    va_start(ap, fmt);
    vprintf(fmt, ap);
    va_end(ap);
}

int main()
{
    debug1("hello %s, a = %d\n", "mike", 250);
    debug2("hello %s, a = %d\n", "mike", 250);
    debug3("hello %s, a = %d\n", "mike", 250);

    return 0;
}

程序运行结果如下：

C语言可变参数的使用_可变参数_02

github源代码：​​https://github.com/mikejiangsky/c_overload.git​​