可变参数函数

前置知识#

• 函数指针与回调：建议先完成前一篇的学习

学习目标#

• 掌握「1. 历史动机与演化」的核心机制、典型用法与常见陷阱
• 掌握「2. 形式化定义」的核心机制、典型用法与常见陷阱
• 掌握「3. 理论推导与证明」的核心机制、典型用法与常见陷阱
• 掌握「4. 代码示例」的核心机制、典型用法与常见陷阱
• 掌握「5. 对比分析」的核心机制、典型用法与常见陷阱

1. 历史动机与演化#

1.1 早期 C 语言的”参数不检查”传统#

C 语言的早期版本（K&R C，1978）允许函数在声明时不指定参数列表，仅写 () 表示”接受任意参数”，且不会进行参数类型与数量检查。这一设计源自 Unix 系统编程的灵活性需求：printf、open、exec 等系统调用必须接受可变数量的参数。

K&R C 时期，编译器不检查函数调用与定义之间的参数匹配。printf("%d %d", 1) 这种错误只能等到运行时才暴露（甚至不暴露，直接读取栈上的垃圾数据）。

1.2 C89 标准化：<stdarg.h> 与 <varargs.h>#

C89（ISO/IEC 9899:1990）正式引入 <stdarg.h> 头文件，提供标准化的可变参数访问机制：

• va_list：保存可变参数迭代状态的类型
• va_start(ap, last_named)：初始化 va_list，从最后一个命名参数之后开始
• va_arg(ap, type)：获取下一个参数并推进 va_list
• va_end(ap)：清理 va_list

C89 同时废弃了 K&R 时代的 <varargs.h>（无命名参数，无法跳过最后一个命名参数）。<varargs.h> 在 System V 早期 Unix 中存在，但已被 GCC 标记为过时。

1.3 C99：va_copy#

C99 引入 va_copy(dest, src) 宏，用于复制 va_list。这是因为在某些 ABI（如 IA-64）上，va_list 是数组类型，直接赋值 dest = src 实际是把数组首地址赋给指针，导致 dest 与 src 共享状态，遍历其中一个会破坏另一个。va_copy 提供了语义正确的深拷贝。

1.4 C11 与原子化#

C11 引入 _Generic 泛型选择宏，使得”类型安全的可变参数”成为可能。例如，可以编写一个宏，根据参数类型分发到不同的强类型函数，避免 va_arg 的类型不安全。

C11 的 Annex K（边界检查库）提供了 printf_s、scanf_s 等带额外大小参数的可变参数函数，但被广泛批评为”安全假象”，Microsoft 与 GNU/Clang 之间未能达成一致，导致 Annex K 在 C17 中被标记为可选。

1.5 C23 与未来#

C23 引入 _BitInt(N) 类型，扩展了整型家族，但默认参数提升规则不变（小于 int 的整型提升为 int，float 提升为 double）。C23 也强化了 [[deprecated]]、[[nodiscard]] 等属性，可用于增强可变参数 API 的可诊断性。

C2y 草案中讨论的”反射”与”契约”特性，若通过，将允许在编译期检查可变参数的类型签名，从根本上消除 printf 类函数的安全隐患。

1.6 调用约定演进#

2. 形式化定义#

2.1 可变参数函数的签名#

设函数 $f$ 的签名为：

其中 $T_1, \ldots, T_n$ 为命名参数（必须至少 1 个），” $\ldots$” 表示可变参数部分（variadic arguments），其类型与数量在编译期不固定。

2.2 默认参数提升#

可变参数部分会发生”默认参数提升”（default argument promotions）：

因此 va_arg(ap, char) 是未定义行为（UB），正确写法是 va_arg(ap, int)，然后显式转换为 char。

2.3 va_list 的形式化语义#

va_list 是一个不透明类型，封装了遍历可变参数的状态。其操作语义为：

• $\text{va\_start}(ap, P_n)$：将 $ap$ 初始化为指向 $P_n$ 之后的第一个可变参数。
• $\text{va\_arg}(ap, T)$：返回 $ap$ 当前指向的参数（类型 $T$），将 $ap$ 推进到下一个参数。
• $\text{va\_copy}(ap_2, ap_1)$：将 $ap_1$ 的当前状态深拷贝到 $ap_2$。
• $\text{va\_end}(ap)$：使 $ap$ 处于”已完成”状态，后续使用是 UB。

2.4 调用约定的栈布局（x86-64 System V）#

设可变参数函数 void f(int count, ...) 被调用为 f(3, 10, 20, 30)。System V AMD64 ABI 下栈布局：

flowchart TD
    B0["返回地址 (8 字节)"]
    B1["调用方栈帧"]
    B0 --> B1
    B2["30 (栈上参数 3) / 20 (栈上参数 2) / 10 (栈上参数 1)"]
    B1 --> B2
    B3["寄存器保存区 (由 va_start 填充) / rdi_args[0..5] (48 字节) / xmm_args[0..7] (128 字节)"]
    B2 --> B3
    B4["栈上参数区 / overflow[0..n]"]
    B3 --> B4

va_start 通过 %al 寄存器（调用方需告知使用了多少个 SSE 寄存器参数）决定是否保存 XMM 寄存器。va_arg 根据类型从寄存器保存区或栈上参数区读取。

3. 理论推导与证明#

3.1 可变参数函数的不可类型安全定理#

命题：C 语言的可变参数机制无法在编译期保证类型安全。

证明：可变参数部分由 ... 表示，编译器不记录参数类型。va_arg(ap, T) 中的 $T$ 由调用方程序员填写，编译器无法验证 $T$ 与实际传入类型是否一致。若调用方传入 int，调用方用 va_arg(ap, double) 读取，则读取 8 字节但只写了 4 字节，行为未定义。

推论：所有可变参数函数都必须依赖某种”运行期类型识别”机制（如 printf 的格式字符串、open 的标志位）来推断参数类型，否则必然存在 UB 风险。

3.2 默认参数提升的等价性#

命题：对于任何整型 $T$ 满足 $\text{sizeof}(T) \leq \text{sizeof}(\text{int})$，可变参数传递时 $T$ 被提升为 int，且 va_arg(ap, int) 读取的值与原值在数值上相等。

证明：调用约定规定可变参数按提升后的类型传递。设 $v \in T$，提升后 $v' = \text{int}(v)$。由于 int 至少与 $T$ 同宽，且 $v$ 在 $T$ 的值域内，$v'$ 的低 $\text{sizeof}(T) \times 8$ 位与 $v$ 一致。va_arg(ap, int) 读取 $v'$，再强制转换回 $T$ 即可恢复 $v$。$\square$

反例：若 $T = \text{long long}$（64 位），而 va_arg(ap, int) 读取（32 位），则只读取了 $v'$ 的低 32 位，高 32 位丢失，行为未定义。

3.3 调用约定与可变参数的兼容性#

命题：在 System V AMD64 ABI 下，可变参数函数与固定参数函数使用不同的调用序列。

证明思路：固定参数函数的参数完全通过寄存器传递，无需在栈上保存寄存器副本。可变参数函数无法预先知道哪些寄存器用于参数，因此 va_start 必须把所有可能用于参数的寄存器（6 个整型 + 8 个 SSE）保存到栈上的”寄存器保存区”。这一保存操作仅在函数声明为可变参数时由编译器插入。$\square$

推论：将可变参数函数的地址赋给固定参数函数指针，调用时行为未定义（虽然 GCC 在某些情况下能工作）。

4. 代码示例#

4.1 基础示例：求和函数#

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

/* 求任意多个整数的和，count 为参数个数 */
int sum(int count, ...)
{
    va_list ap;
    va_start(ap, count);

    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(ap, int);
    }

    va_end(ap);
    return total;
}

int main(void)
{
    printf("sum(3, 1,2,3) = %d\n", sum(3, 1, 2, 3));
    printf("sum(5, 10,20,30,40,50) = %d\n", sum(5, 10, 20, 30, 40, 50));
    return 0;
}

编译与运行：

gcc -Wall -Wextra -std=c11 sum.c -o sum
./sum
# 输出：sum(3, 1,2,3) = 6
#       sum(5, 10,20,30,40,50) = 150

4.2 哨兵终止的可变参数#

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

/* 字符串拼接，以 NULL 作为终止哨兵 */
char *concat_strings(char *dst, size_t cap, const char *first, ...)
{
    if (!dst || cap == 0 || !first) return NULL;

    size_t total = 0;
    const char *s = first;

    va_list ap;
    va_start(ap, first);

    while (s != NULL) {
        size_t len = strlen(s);
        if (total + len + 1 > cap) {
            va_end(ap);
            return NULL;
        }
        memcpy(dst + total, s, len);
        total += len;
        s = va_arg(ap, const char *);
    }

    dst[total] = '\0';
    va_end(ap);
    return dst;
}

int main(void)
{
    char buf[256];
    concat_strings(buf, sizeof(buf), "Hello, ", "World", "! ", "你好", NULL);
    printf("%s\n", buf);
    return 0;
}

4.3 自定义 printf 实现#

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

/* 简易 printf：支持 %d、%s、%c、%x、%% */
void my_printf(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);

    for (const char *p = fmt; *p != '\0'; p++) {
        if (*p != '%') {
            putchar(*p);
            continue;
        }
        p++;  /* 跳过 % */
        switch (*p) {
        case 'd': {
            int v = va_arg(ap, int);
            printf("%d", v);  /* 简化实现，复用标准 printf */
            break;
        }
        case 's': {
            const char *s = va_arg(ap, const char *);
            if (!s) s = "(null)";
            fputs(s, stdout);
            break;
        }
        case 'c': {
            /* 注意：char 提升为 int */
            int c = va_arg(ap, int);
            putchar(c);
            break;
        }
        case 'x': {
            unsigned int v = va_arg(ap, unsigned int);
            printf("%x", v);
            break;
        }
        case '%': {
            putchar('%');
            break;
        }
        case '\0':
            /* 格式字符串以 % 结尾，UB */
            goto done;
        default:
            /* 未知格式说明符 */
            putchar('%');
            putchar(*p);
            break;
        }
    }
done:
    va_end(ap);
}

int main(void)
{
    my_printf("int=%d, str=%s, char=%c, hex=%x, pct=%%\n",
              42, "hello", 'A', 0xDEAD);
    return 0;
}

4.4 va_copy 多次遍历#

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

/* 第一次遍历：计算最大值；第二次遍历：找出哪些等于最大值 */
void analyze(int count, ...)
{
    va_list ap1, ap2;
    va_start(ap1, count);
    va_copy(ap2, ap1);

    /* 第一次遍历：找最大值 */
    int max = va_arg(ap1, int);
    for (int i = 1; i < count; i++) {
        int v = va_arg(ap1, int);
        if (v > max) max = v;
    }
    va_end(ap1);

    /* 第二次遍历：输出等于最大值的索引 */
    printf("Indices of max (%d):", max);
    for (int i = 0; i < count; i++) {
        int v = va_arg(ap2, int);
        if (v == max) printf(" %d", i);
    }
    printf("\n");
    va_end(ap2);
}

int main(void)
{
    analyze(6, 1, 5, 3, 5, 2, 5);
    /* 输出：Indices of max (5): 1 3 5 */
    return 0;
}

4.5 跨平台调用约定验证#

以下代码通过汇编分析，展示不同 ABI 下可变参数的栈布局：

/* variadic_abi.c */
#include <stdarg.h>
#include <stdio.h>

int variadic_sum(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    int s = 0;
    for (int i = 0; i < n; i++) s += va_arg(ap, int);
    va_end(ap);
    return s;
}

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

x86-64 System V 下反汇编：

gcc -O0 -S variadic_abi.c -o variadic_abi.s
cat variadic_abi.s | grep -A 30 variadic_sum:

可以看到 variadic_sum 函数序言包含以下操作：

variadic_sum:
    pushq   %rbp
    movq    %rsp, %rbp
    subq    $240, %rsp             # 预留 240 字节寄存器保存区
    movl    %edi, -116(%rbp)       # 保存 n
    movl    $8, %eax               # 8 个 SSE 寄存器使用（va_list 的 gp_offset/fp_offset）
    movl    %eax, %eax
    movq    %rsi, -224(%rbp)       # 保存 RSI
    movq    %rdx, -216(%rbp)       # 保存 RDX
    movq    %rcx, -208(%rbp)       # 保存 RCX
    movq    %r8, -200(%rbp)        # 保存 R8
    movq    %r9, -192(%rbp)        # 保存 R9
    movsd   %xmm0, -176(%rbp)     # 保存 XMM0
    ...
    leaq    -224(%rbp), %rax       # va_list 指向寄存器保存区

va_arg(ap, int) 在 System V ABI 下的展开（伪代码）：

/* System V AMD64 va_arg 实现（简化） */
#define va_arg(ap, type) \
    (*(type*)((ap).gp_offset < 48 \
        ? ((ap).reg_save_area + (ap).gp_offset) \
        : ((ap).overflow_arg_area + ((ap).gp_offset - 48)), \
      (ap).gp_offset += 8, ...))

4.6 类型属性 __attribute__((format))#

GCC/Clang 提供 format 属性，让编译器检查可变参数与格式字符串的类型匹配：

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

/* 自定义日志函数，使用 printf 风格格式字符串 */
__attribute__((format(printf, 2, 3)))
void log_msg(int level, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fputc('\n', stderr);
}

int main(void)
{
    log_msg(0, "value = %d\n", 42);       /* OK */
    log_msg(0, "value = %d\n", "hello");  /* 警告：format %d expects int, but arg is char* */
    return 0;
}

format(printf, 2, 3) 的含义：

• printf：使用 printf 风格的格式说明符
• 2：格式字符串是第 2 个参数（fmt）
• 3：可变参数从第 3 个参数开始

4.7 可变参数与 va_list 的转发#

当需要把可变参数转发给另一个可变参数函数时，必须使用 vprintf / vfprintf / vsprintf 系列”v”前缀函数：

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

/* 自定义 fprintf 包装器，加上时间戳前缀 */
void logf(FILE *fp, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);

    /* 输出时间戳 */
    fprintf(fp, "[timestamp] ");

    /* 转发可变参数给 vfprintf */
    vfprintf(fp, fmt, ap);

    fputc('\n', fp);
    va_end(ap);
}

int main(void)
{
    logf(stdout, "user %s logged in from %s", "alice", "192.168.1.1");
    return 0;
}

4.8 C11 _Generic 实现类型安全”伪可变参数”#

#include <stdio.h>

/* 类型安全的 print_value 宏，根据参数类型分发 */
#define print_value(x) _Generic((x), \
    int:    print_int, \
    double: print_double, \
    char *: print_string, \
    default: print_unknown \
)(x)

void print_int(int v)         { printf("int: %d\n", v); }
void print_double(double v)   { printf("double: %f\n", v); }
void print_string(char *s)    { printf("string: %s\n", s); }
void print_unknown(...)       { printf("unknown type\n"); }

int main(void)
{
    print_value(42);          // int: 42
    print_value(3.14);        // double: 3.140000
    print_value("hello");     // string: hello
    return 0;
}

_Generic 在编译期完成类型分发，无 UB 风险，但只能处理固定数量参数。可配合宏递归实现”N 个参数”的类型安全调度。

5. 对比分析#

5.1 可变参数方案的四种模式#

5.2 与其他语言的对比#

5.2.1 C++ 的可变参数模板

C++11 引入可变参数模板（variadic templates），在编译期展开参数包：

template<typename... Args>
void print(Args... args) {
    (std::cout << ... << args) << '\n';  // C++17 折叠表达式
}

优势：类型安全（编译期检查每个参数类型）、零开销（编译期展开）、无栈遍历。劣势：编译时间长、错误信息晦涩、不能跨翻译单元隐藏实现。

5.2.2 Rust 的可变参数

Rust 标准库不直接支持 C 风格可变参数，但通过 extern "C" 函数可与 C 可变参数交互：

extern "C" {
    fn printf(fmt: *const u8, ...) -> i32;
}

fn main() {
    unsafe {
        printf(b"Hello %s!\n\0".as_ptr(), b"World\0".as_ptr());
    }
}

Rust 推荐使用宏（println!、format!）实现类型安全的”伪可变参数”，宏在编译期展开为强类型代码。

5.2.3 Go 的可变参数

Go 内置支持可变参数，语法为 func f(args ...int)，参数被收集为切片：

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

sum(1, 2, 3)         // 直接传
nums := []int{1,2,3}
sum(nums...)         // 切片展开

优势：类型安全、无 UB；劣势：必须同类型，跨类型需 interface{} 与类型断言。

5.2.4 Java 的可变参数

Java 5 引入可变参数，语法为 void f(Object... args)，参数被收集为数组：

void log(String fmt, Object... args) {
    System.out.printf(fmt, args);
}

优势：类型安全（编译期检查数组元素类型）；劣势：基本类型需装箱（autoboxing）有性能开销。

5.3 选型决策#

• 必须同类型 + 类型安全：优先用 C11 _Generic 宏或自定义结构体数组。
• 必须异类型 + 编译期已知类型列表：用宏递归 + _Generic。
• 必须异类型 + 运行期类型：用 C 可变参数 + 格式字符串（务必启用 format 属性检查）。
• 跨语言接口（FFI）：C 可变参数是事实标准，几乎所有 FFI 都支持。

6. 常见陷阱与反模式#

6.1 类型不匹配#

/* 反模式 */
void bad_print(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    while (*fmt) {
        if (*fmt == 'd') {
            /* 调用方传入了 double，但用 int 读取：UB */
            int v = va_arg(ap, int);
            printf("%d", v);
        }
        fmt++;
    }
    va_end(ap);
}

正确做法：格式字符串与参数类型必须严格对应，或使用 __attribute__((format)) 启用编译期检查。

6.2 忘记 va_end#

/* 反模式：提前 return 而未 va_end */
int buggy_sum(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    int s = 0;
    for (int i = 0; i < n; i++) {
        s += va_arg(ap, int);
        if (s < 0) return s;  /* BUG: 未 va_end */
    }
    va_end(ap);
    return s;
}

正确做法：使用 goto cleanup 或 RAII 风格确保所有路径都调用 va_end：

int safe_sum(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    int s = 0;
    for (int i = 0; i < n; i++) {
        s += va_arg(ap, int);
        if (s < 0) goto cleanup;
    }
cleanup:
    va_end(ap);
    return s;
}

6.3 va_arg 读取错误类型#

/* 反模式：调用方传入 short，用 short 读取 */
short v = 42;
my_func("%hd", v);  /* 调用方 */

void my_func(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    short s = va_arg(ap, short);  /* UB: short 提升为 int */
    va_end(ap);
}

正确做法：用 int 读取，再转换：

int i = va_arg(ap, int);
short s = (short)i;

6.4 传递 va_list 时未用 va_copy#

/* 反模式：直接传 va_list（在某些 ABI 上是数组，按值传递会退化为指针） */
void helper(va_list ap)  /* 错误签名 */
{
    int v = va_arg(ap, int);
}

void caller(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    helper(ap);  /* BUG */
    va_end(ap);
}

正确做法：使用 va_list * 或 va_copy：

void helper(va_list *ap)
{
    int v = va_arg(*ap, int);
}

void caller(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    helper(&ap);
    va_end(ap);
}

或用 v 前缀函数直接接收 va_list：

void vhelper(va_list ap)
{
    int v = va_arg(ap, int);
}

void caller(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    vhelper(ap);
    va_end(ap);
}

6.5 哨兵值遗漏#

/* 反模式：忘记 NULL 终止 */
execl("/bin/ls", "ls", "-l");  /* UB：缺少 NULL */

正确做法：

execl("/bin/ls", "ls", "-l", (char *)NULL);
/* 注意：必须强制转换 NULL 为 char*，避免在 64 位系统上 0 被解释为 int */

6.6 在可变参数中使用 _Bool / enum#

/* 反模式：传递 _Bool */
my_func("%d", true);  /* _Bool 提升为 int（通常 1） */

/* 反模式：传递 enum */
enum color { RED, GREEN, BLUE };
my_func("%d", RED);  /* enum 提升为 int */

读取时必须用 int：

int v = va_arg(ap, int);

6.7 跨调用约定混用#

/* 反模式：将可变参数函数地址赋给固定参数函数指针 */
typedef int (*sum_fn)(int, int);
sum_fn fn = (sum_fn)sum;  /* sum 是 int sum(int n, ...) */
fn(3, 4);  /* UB：调用约定可能不同 */

7. 工程实践与最佳实践#

7.1 提供 v 前缀版本#

每个可变参数函数都应提供一个 v 前缀版本，接收 va_list，便于其他函数转发：

void my_log(int level, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    my_vlog(level, fmt, ap);
    va_end(ap);
}

void my_vlog(int level, const char *fmt, va_list ap)
{
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
}

7.2 启用 format 属性#

所有接收 printf/scanf/strftime 风格格式字符串的函数都应启用 format 属性：

__attribute__((format(printf, 1, 2)))
void my_log(const char *fmt, ...);

__attribute__((format(scanf, 2, 3)))
int my_scanf(FILE *fp, const char *fmt, ...);

7.3 优先使用哨兵或计数器，避免纯格式字符串#

若 API 不需要类型推断，优先使用哨兵或计数器：

/* 优于 */
void append(char *buf, ...) /* 难以类型检查 */

/* 推荐做法 1：哨兵 */
void append_sentinel(char *buf, ..., NULL);

/* 推荐做法 2：计数器 */
void append_counted(char *buf, size_t n, ...);

/* 推荐做法 3：结构体数组 */
typedef struct { int type; union { int i; double d; } val; } arg_t;
void append_typed(char *buf, const arg_t *args, size_t n);

7.4 错误处理：可变参数函数的失败模式#

可变参数函数失败时（如参数数量不足、类型不匹配），由于无法在函数内检测，应采用以下策略：

1. 格式字符串严格校验：解析 fmt，若发现 % 后是非法说明符，立即报错并停止。
2. 计数器模式：若使用计数器，校验计数器与实际遍历是否一致。
3. 哨兵模式：限制哨兵值的总数量，防止无限循环。
4. 返回值：明确返回成功/失败，调用方需检查。

7.5 与宏结合：编译期类型检查#

/* 类型安全的"add"宏，编译期检查参数数量 */
#define ADD_2(a, b)          ((a) + (b))
#define ADD_3(a, b, c)       ((a) + (b) + (c))
#define ADD_4(a, b, c, d)    ((a) + (b) + (c) + (d))

#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define ADD(...) GET_MACRO(__VA_ARGS__, ADD_4, ADD_3, ADD_2)(__VA_ARGS__)

int main(void)
{
    ADD(1, 2);        /* 调用 ADD_2 */
    ADD(1, 2, 3);     /* 调用 ADD_3 */
    ADD(1, 2, 3, 4);  /* 调用 ADD_4 */
    return 0;
}

7.6 性能考量#

可变参数函数的性能开销：

1. 寄存器保存：va_start 在 x86-64 System V 下需保存最多 6+8=14 个寄存器到栈，约 176 字节写入。
2. 分支判断：每次 va_arg 需判断从寄存器保存区还是栈上参数区读取。
3. 无法内联：可变参数函数通常不会被内联（即使加 static inline）。
4. 指令缓存：复杂的 va_arg 展开会增加代码体积，影响 icache。

对性能敏感场景，可考虑：

• 用宏替代简单可变参数函数。
• 用结构体数组 + 循环替代。
• 用 SIMD 一次处理多个同类型参数。

7.7 与 C++ 异常的交互#

C 函数中抛出 C++ 异常是未定义行为。可变参数函数中如果调用方传入 C++ 对象，析构顺序无法保证。最佳实践：

• 在 C 接口边界处捕获所有异常（try/catch(...)）。
• 不要在 C 接口中传递 C++ 对象指针。
• 使用 noexcept 确保 C++ 实现不抛异常。

8. 案例研究#

8.1 printf 的实现：glibc vfprintf#

glibc 的 vfprintf 是工业级可变参数函数的标杆，处理以下复杂场景：

• 格式说明符完整支持：%d、%s、%f、%e、%g、%x、%o、%c、%p、%n、%%、%ls、%lf 等。
• 标志位组合：-、+、空格、#、0。
• 宽度与精度：%10.3f、%*d（运行期宽度）。
• 位置参数：%1$d %1$d（同一参数多次引用，需先扫描一遍 fmt 确定所有参数位置）。
• 多语言本地化：根据 LC_NUMERIC 决定小数点。
• 错误处理：输出失败时返回负值。

源码位置：glibc/stdio-common/vfprintf-internal.c，约 2000 行 C 代码。

8.2 open 系统调用的可变参数#

POSIX open 函数签名：

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

仅当 flags 包含 O_CREAT 时才需要第三个参数 mode_t mode。实现：

int open(const char *pathname, int flags, ...)
{
    mode_t mode = 0;
    if (flags & O_CREAT) {
        va_list ap;
        va_start(ap, flags);
        mode = va_arg(ap, mode_t);  /* mode_t 通常提升为 int */
        va_end(ap);
    }
    return syscall(SYS_open, pathname, flags, mode);
}

注意：若调用方在 O_CREAT 时忘记传 mode，则 va_arg 读取栈上垃圾，UB。这是 POSIX 设计的妥协——若使用固定参数，则非 O_CREAT 调用必须传 0，冗余且易错。

8.3 execl / execv 系列的可变参数#

int execl(const char *path, const char *arg0, ... /*, (char *)NULL */);
int execlp(const char *file, const char *arg0, ... /*, (char *)NULL */);
int execle(const char *path, const char *arg0, ... /*, (char *)NULL, char *const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

execl 内部把可变参数转换为 argv 数组，然后调用 execv：

int execl(const char *path, const char *arg0, ...)
{
    va_list ap;
    va_start(ap, arg0);

    /* 第一遍：计数 */
    size_t argc = 1;
    const char *s = arg0;
    va_list ap_count;
    va_copy(ap_count, ap);
    while ((s = va_arg(ap_count, const char *)) != NULL) argc++;
    va_end(ap_count);

    /* 第二遍：构建 argv */
    char **argv = malloc((argc + 1) * sizeof(char *));
    argv[0] = (char *)arg0;
    for (size_t i = 1; i < argc; i++) {
        argv[i] = (char *)va_arg(ap, const char *);
    }
    argv[argc] = NULL;
    va_end(ap);

    int r = execv(path, argv);
    free(argv);
    return r;
}

8.4 syslog 的可变参数#

void syslog(int priority, const char *format, ...);
void vsyslog(int priority, const char *format, va_list ap);

syslog 是工业级日志 API，支持：

• 优先级（LOG_EMERG 到 LOG_DEBUG）
• printf 风格格式字符串
• %m 展开为 strerror(errno)（GNU 扩展）

实现要点：通过 vsyslog 提供 va_list 版本，避免代码重复。

8.5 Linux 内核的 printk#

Linux 内核的 printk 是可变参数函数的内核实现：

asmlinkage __printf(1, 2) __cold
int printk(const char *fmt, ...);

特点：

• 使用 asmlinkage 修饰，明确使用栈式调用约定（x86 上）。
• __printf(1, 2) 启用 GCC format 检查。
• 支持内核特定格式说明符：%pK（受 kptr_restrict 限制）、%pOF（设备树节点）、%pV（递归 va_format）。
• 在中断上下文也可安全调用（使用 lock-free ring buffer）。

8.6 Windows API 的 wsprintf#

Windows 的 wsprintf 是可变参数函数，但不支持浮点（早期 Windows 节省浮点库）：

int WINAPIV wsprintfA(LPSTR buf, LPCSTR fmt, ...);
int WINAPIV wsprintfW(LPWSTR buf, LPCWSTR fmt, ...);

WINAPIV 表示使用 CDECL 调用约定（__cdecl），而非 Windows API 默认的 STDCALL。这是为了支持可变参数。

8.7 PostgreSQL 的 elog / ereport#

PostgreSQL 数据库的错误报告 API elog 是可变参数函数：

elog(ERROR, "column \"%s\" does not exist", column_name);

实现要点：

• 使用 pg_attribute_printf(2, 3) 启用编译期格式检查。
• 错误级别（DEBUG5 到 PANIC）决定是否终止事务。
• 通过 longjmp 实现错误传播（避免栈展开开销）。

附录 A：<stdarg.h> 宏的展开示例#

A.1 x86-64 System V 下 va_list 的内部结构#

typedef struct {
    unsigned int gp_offset;       /* 下一个 GP 寄存器参数的偏移（0-48） */
    unsigned int fp_offset;       /* 下一个 FP 寄存器参数的偏移（48-176） */
    void *overflow_arg_area;      /* 栈上参数区指针 */
    void *reg_save_area;          /* 寄存器保存区指针 */
} va_list[1];  /* 数组类型，sizeof = 24 */

A.2 va_start 展开#

void f(int n, ...)
{
    va_list ap;
    va_start(ap, n);
    /* ... */
    va_end(ap);
}

在 GCC x86-64 上展开为：

f:
    pushq %rbp
    movq %rsp, %rbp
    subq $240, %rsp           ; 预留寄存器保存区

    ; 保存 GP 寄存器（按 System V ABI 顺序）
    movq %rdi, -216(%rbp)     ; n（命名参数，不在 va_list 中）
    movq %rsi, -208(%rbp)
    movq %rdx, -200(%rbp)
    movq %rcx, -192(%rbp)
    movq %r8,  -184(%rbp)
    movq %r9,  -176(%rbp)

    ; 保存 FP 寄存器
    movsd %xmm0, -160(%rbp)
    movsd %xmm1, -152(%rbp)
    ... ; 共 8 个 XMM

    ; 构造 va_list
    movl $8,  -120(%rbp)      ; gp_offset = 8（n 之后从 rsi 开始，偏移 8）
    movl $48, -116(%rbp)      ; fp_offset = 48
    leaq -176(%rbp), %rax     ; overflow_arg_area
    movq %rax, -112(%rbp)
    leaq -216(%rbp), %rax     ; reg_save_area（包含 n）
    movq %rax, -104(%rbp)

A.3 va_arg(ap, int) 展开#

int v = va_arg(ap, int);

GCC 内联展开（简化版）：

    ; 读取 gp_offset
    movl -120(%rbp), %eax
    cmpl $48, %eax            ; gp_offset < 48 ?
    jae  .L_from_stack

    ; 从寄存器保存区读取
    movq -104(%rbp), %rdx     ; reg_save_area
    addq %rdx, %rax
    movl (%rax), %eax         ; 读取 int
    addl $8, -120(%rbp)       ; gp_offset += 8
    jmp .L_done

.L_from_stack:
    ; 从栈上参数区读取
    movq -112(%rbp), %rax     ; overflow_arg_area
    movl (%rax), %eax
    addq $8, -112(%rbp)       ; overflow_arg_area += 8

.L_done:
    ; %eax 中为读取到的值

附录 B：跨平台可变参数宏实现#

某些库（如 Google Test、Boost.Preprocessor）需要在跨平台下使用可变参数宏。C99 引入了 __VA_ARGS__：

#define LOG(fmt, ...) printf(fmt, __VA_ARGS__)

C23 进一步引入 __VA_OPT__，处理”无参数”情况：

#define LOG(fmt, ...) printf(fmt __VA_OPT__(,) __VA_ARGS__)

LOG("hello");        /* 展开为 printf("hello") */
LOG("hello %d", 42); /* 展开为 printf("hello %d", 42) */

附录 C：性能基准测试#

不同可变参数实现方案的性能差异（gcc 13.2 -O2，x86-64，10 亿次调用）：

性能基准测试代码：

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

#define ITERS 1000000000ULL

static int sum_va(int count, ...) {
    va_list ap;
    va_start(ap, count);
    int s = 0;
    for (int i = 0; i < count; i++) s += va_arg(ap, int);
    va_end(ap);
    return s;
}

static int sum_array(int count, int *arr) {
    int s = 0;
    for (int i = 0; i < count; i++) s += arr[i];
    return s;
}

int main(void) {
    struct timespec t0, t1;
    volatile int sink = 0;

    /* va_list 测试 */
    clock_gettime(CLOCK_MONOTONIC, &t0);
    for (uint64_t i = 0; i < ITERS; i++) {
        sink += sum_va(3, 1, 2, 3);
    }
    clock_gettime(CLOCK_MONOTONIC, &t1);
    double va_ns = (t1.tv_sec - t0.tv_sec) * 1e9 + (t1.tv_nsec - t0.tv_nsec);
    printf("va_list:    %.2f ns/op\n", va_ns / ITERS);

    /* 数组测试 */
    int arr[3] = {1, 2, 3};
    clock_gettime(CLOCK_MONOTONIC, &t0);
    for (uint64_t i = 0; i < ITERS; i++) {
        sink += sum_array(3, arr);
    }
    clock_gettime(CLOCK_MONOTONIC, &t1);
    double arr_ns = (t1.tv_sec - t0.tv_sec) * 1e9 + (t1.tv_nsec - t0.tv_nsec);
    printf("array:      %.2f ns/op\n", arr_ns / ITERS);

    (void)sink;
    return 0;
}

性能优化的关键建议：

1. 热路径避免可变参数：在每秒调用百万次以上的热路径中，用 _Generic 分发或固定参数函数替代 va_list。
2. 减少参数数量：可变参数少于 6 个时全部走寄存器，超过 6 个会溢出到栈上。
3. 避免 va_copy 在热循环中：va_copy 在某些 ABI 上涉及内存拷贝。
4. 格式字符串解析缓存：printf 类函数的格式字符串解析是主要开销，可以预解析并缓存。

附录 D：不同编译器 va_arg 实现差异#

D.1 GCC 实现

GCC 在 x86-64 System V 上将 va_list 定义为：

typedef struct {
    unsigned int gp_offset;       /* 下一个整型参数在 reg_save_area 的偏移 */
    unsigned int fp_offset;       /* 下一个浮点参数在 reg_save_area 的偏移 */
    void *overflow_arg_area;      /* 指向栈上溢出参数区 */
    void *reg_save_area;          /* 指向寄存器保存区 */
} __va_list_tag;
typedef __va_list_tag va_list[1];

va_arg 内联展开为：

#define va_arg(ap, type)                                    \
    *(type *)((ap->gp_offset <= 48                          \
               ? (ap->gp_offset += 8, ap->reg_save_area    \
                  + ap->gp_offset - 8)                      \
               : (ap->overflow_arg_area += 8,               \
                  ap->overflow_arg_area - 8)))

D.2 Clang/LLVM 实现

Clang 在前端将 va_arg 转换为 LLVM IR 的 llvm.va_arg 指令，后端再降低为目标平台代码。在 x86-64 上结果与 GCC 等价，但在 ARM64 上使用更紧凑的 __builtin_va_list 表示（一个指针 + 一个边界指针）。

D.3 MSVC 实现

MSVC 在 x64 上使用简化的 va_list（仅一个 char* 指针），因为 Microsoft x64 ABI 对可变参数无特殊处理：所有参数（包括前 4 个寄存器参数）都在栈上有一份”shadow space”副本。va_arg 直接递增指针：

typedef char *va_list;
#define va_start(ap, v) ((ap) = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v))
#define va_arg(ap, t)   (*(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))

_INTSIZEOF 宏实现”按 4 字节向上对齐”（x86）或”按 8 字节向上对齐”（x64）：

#define _INTSIZEOF(n) (((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1)))

D.4 跨平台注意事项

跨平台代码应：

1. 永远不假设 va_list 的具体布局。
2. 不直接赋值 va_list（用 va_copy）。
3. 不在函数返回后使用 va_list（必须先 va_copy 并传递给另一个函数）。
4. 跨平台库推荐使用 void* 数组 + 计数器方案，避免 va_list 的 ABI 差异。

附录 E：可变参数与系统调用 wrapper#

Linux 内核的系统调用 wrapper（如 open、ioctl）使用可变参数简化用户接口，但实际系统调用号是固定的：

/* glibc 的 open 实现（简化版） */
int open(const char *pathname, int flags, ...) {
    mode_t mode = 0;
    if (flags & O_CREAT) {
        va_list ap;
        va_start(ap, flags);
        mode = va_arg(ap, mode_t);  /* mode_t 在 Linux 上是 unsigned int */
        va_end(ap);
    }
    return syscall(SYS_open, pathname, flags, mode);
}

这种设计的优点是用户接口简洁（不需要 creat 时不必传 mode），缺点是 O_CREAT 漏传 mode 时会读取栈上垃圾数据，是常见的潜在安全漏洞。现代 GCC 通过 __attribute__((warn_unused_result)) 和静态分析器缓解这一问题。

可变参数函数定义#

基本写法：可变参数函数声明 <return_type> <func_name>(<fixed_params>, ...);

// 声明可变参数函数
int sum(int count, ...);

基本写法：可变参数函数定义 <return_type> <func_name>(<fixed_params>, ...) { ... }

#include <stdarg.h>
// 定义可变参数函数
int sum(int count, ...) {
    va_list valist;
    va_start(valist, count);
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(valist, int);
    }
    va_end(valist);
    return total;
}

va_list 相关宏#

基本写法：声明 va_list 变量 va_list <valist>;

#include <stdarg.h>
// 声明参数列表变量
va_list valist;

基本写法：初始化 va_list va_start(<valist>, <last_named_param>);

#include <stdarg.h>
// 初始化参数列表，count 为最后一个命名参数
va_start(valist, count);

基本写法：获取下一个参数 <type> <val> = va_arg(<valist>, <type>);

#include <stdarg.h>
// 获取下一个 int 类型的参数
int num = va_arg(valist, int);

基本写法：清理 va_list va_end(<valist>);

#include <stdarg.h>
// 清理参数列表
va_end(valist);

拷贝写法：复制 va_list va_copy(<dest>, <src>);

#include <stdarg.h>
// 复制参数列表
va_list dest;
va_copy(dest, src);

可变参数函数示例#

求和写法：计算多个整数的和 int <func>(int <count>, ...) { ... }

#include <stdarg.h>
// 计算多个整数的和
int sum(int count, ...) {
    va_list valist;
    va_start(valist, count);
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(valist, int);
    }
    va_end(valist);
    return total;
}

最大值写法：找出多个整数的最大值 int <func>(int <count>, ...) { ... }

#include <stdarg.h>
// 找出多个整数的最大值
int max(int count, ...) {
    va_list valist;
    va_start(valist, count);
    int max_val = va_arg(valist, int);
    for (int i = 1; i < count; i++) {
        int num = va_arg(valist, int);
        if (num > max_val) {
            max_val = num;
        }
    }
    va_end(valist);
    return max_val;
}

打印写法：自定义打印函数 void <func>(const char *<format>, ...) { ... }

#include <stdarg.h>
#include <stdio.h>
// 自定义打印函数
void log_message(const char *format, ...) {
    va_list valist;
    va_start(valist, format);
    vprintf(format, valist);
    va_end(valist);
}

vprintf 系列函数#

vprintf 写法：使用 vprintf 输出 vprintf(<format>, <valist>);

#include <stdarg.h>
#include <stdio.h>
// 使用 vprintf 输出可变参数
void log_message(const char *format, ...) {
    va_list valist;
    va_start(valist, format);
    vprintf(format, valist);
    va_end(valist);
}

vfprintf 写法：使用 vfprintf 输出到文件 vfprintf(<fp>, <format>, <valist>);

#include <stdarg.h>
#include <stdio.h>
// 使用 vfprintf 输出到文件
void log_to_file(FILE *fp, const char *format, ...) {
    va_list valist;
    va_start(valist, format);
    vfprintf(fp, format, valist);
    va_end(valist);
}

vsprintf 写法：使用 vsprintf 写入字符串 vsprintf(<buffer>, <format>, <valist>);

#include <stdarg.h>
#include <stdio.h>
// 使用 vsprintf 写入字符串
void format_string(char *buffer, const char *format, ...) {
    va_list valist;
    va_start(valist, format);
    vsprintf(buffer, format, valist);
    va_end(valist);
}

vsnprintf 写法：使用 vsnprintf 安全写入字符串 vsnprintf(<buffer>, <size>, <format>, <valist>);

#include <stdarg.h>
#include <stdio.h>
// 使用 vsnprintf 安全写入字符串（限制长度）
void format_string_safe(char *buffer, size_t size, const char *format, ...) {
    va_list valist;
    va_start(valist, format);
    vsnprintf(buffer, size, format, valist);
    va_end(valist);
}

可变参数函数调用#

基本写法：调用可变参数函数 <func_name>(<fixed_args>, <var1>, <var2>, ...);

// 调用可变参数函数
int result = sum(5, 10, 20, 30, 40, 50);

混合类型写法：调用混合类型可变参数函数 <func_name>(<format>, <arg1>, <arg2>, ...);

// 调用 printf 函数
printf("Name: %s, Age: %d\n", "John", 30);

可变参数宏#

基本写法：可变参数宏定义 #define <NAME>(<fixed>, ...) <expr>(__VA_ARGS__)

// 可变参数宏
#define LOG(fmt, ...) printf(fmt, __VA_ARGS__)

使用写法：调用可变参数宏 <NAME>(<fixed_args>, <var_args>);

// 调用可变参数宏
LOG("Value: %d\n", 100);

可变参数函数注意事项#

哨兵值写法：使用哨兵值标记结束 <func>(<value1>, <value2>, ..., <sentinel>);

// 使用哨兵值标记参数结束
int sum_sentinel(int first, ...) {
    va_list valist;
    va_start(valist, first);
    int total = first;
    int num;
    while ((num = va_arg(valist, int)) != -1) {
        total += num;
    }
    va_end(valist);
    return total;
}

类型安全写法：使用格式字符串指定类型 <func>(const char *<format>, ...)

// 通过格式字符串指定参数类型
void print_values(const char *format, ...) {
    va_list valist;
    va_start(valist, format);
    const char *p = format;
    while (*p) {
        if (*p == 'd') {
            printf("%d ", va_arg(valist, int));
        } else if (*p == 'f') {
            printf("%f ", va_arg(valist, double));
        }
        p++;
    }
    va_end(valist);
}