linux 可变参数

什么是可变参数？

在 C 语言中,函数通常需要预先定义好其参数的数量和类型。

int add(int a, int b); // 必须传两个 int

可变参数（Variadic Arguments）是一种允许你定义一个可以接受不确定数量参数的函数的技术，最经典的例子就是 C 语言标准库中的 printf 函数：

int printf(const char *format, ...); // 可以接受任意数量的参数

你可以这样调用它：

printf("Hello, world!\n");       // 0 个额外参数
printf("Value: %d\n", 10);      // 1 个额外参数
printf("Name: %s, Age: %d\n", "Alice", 30); // 2 个额外参数

核心概念与宏

可变参数的实现依赖于 C 标准库 <stdarg.h> 中定义的一组宏和类型,这些宏允许你在运行时访问那些在编译时数量未知的参数。

关键组件：

1. va_list:

   • 这是一个类型,通常被实现为一个指向参数列表的指针。
   • 你需要创建一个 va_list 类型的变量来“遍历”可变参数列表。

2. va_start(va_list ap, last_fixed_arg):

   • 这是一个宏，用于初始化 va_list 变量 ap。
   • 它需要两个参数：
     • ap: 你的 va_list 变量。
     • last_fixed_arg: 函数中最后一个固定参数,编译器需要这个信息来确定可变参数在栈上的起始位置。

3. va_arg(va_list ap, type):

   • 这是最核心的宏，用于从参数列表中依次取出一个参数。
   • 它需要两个参数：
     • ap: 已初始化的 va_list 变量。
     • type: 你期望取出的参数的数据类型。
   • 它会返回当前参数，并将 va_list 指针移动到下一个参数。

4. va_end(va_list ap):

   • 这是一个宏，用于清理 va_list 变量。
   • 在使用完所有可变参数后，必须调用此宏，以避免潜在的内存泄漏或未定义行为，它通常将 ap 指针设为 NULL。

实现一个简单的可变参数函数

让我们实现一个简单的求和函数 my_sum,它可以计算任意数量整数的和。

代码示例: variadic_example.c

#include <stdio.h>
#include <stdarg.h> // 必须包含这个头文件
// 一个可变参数函数，计算所有 int 参数的和
// 第一个参数 count 是参数的个数，这样函数才知道何时停止
int my_sum(int count, ...) {
    va_list args;       // 1. 创建一个 va_list 变量
    int total = 0;
    // 2. 初始化 va_list
    //    'count' 是最后一个固定参数，va_start 会根据它找到可变参数的起始位置
    va_start(args, count);
    // 3. 循环遍历可变参数
    for (int i = 0; i < count; i++) {
        // 4. 使用 va_arg 获取下一个 int 类型的参数
        int num = va_arg(args, int);
        total += num;
    }
    // 5. 清理 va_list
    va_end(args);
    return total;
}
int main() {
    printf("Sum of 3, 5, 7 is: %d\n", my_sum(3, 3, 5, 7));       // 输出: 15
    printf("Sum of 10, 20, 30, 40 is: %d\n", my_sum(4, 10, 20, 30, 40)); // 输出: 100
    printf("Sum of a single number 100 is: %d\n", my_sum(1, 100));     // 输出: 100
    return 0;
}

编译和运行:

gcc variadic_example.c -o variadic_example
./variadic_example

代码解析:

1. 我们定义 my_sum(int count, ...)，count 是一个固定参数，用来告诉函数接下来有多少个可变参数,这是处理可变参数最安全的方式之一。
2. va_list args; 声明了一个用于遍历参数的列表。
3. va_start(args, count); 初始化了这个列表，va_start 会利用 count 在栈帧上定位到第一个可变参数。
4. va_arg(args, int); 在每次循环中，从 args 中取出一个 int 类型的值。
5. va_end(args); 完成清理工作。

重要注意事项与陷阱

使用可变参数非常强大，但也非常危险，因为 C 语言不会进行类型安全检查。

类型不匹配是致命的

va_arg 的第二个参数 type 必须和实际传入的参数类型完全匹配，如果不匹配，会导致未定义行为,通常是程序崩溃或得到错误的结果。

错误示例:

void print_args(int count, ...) {
    va_list args;
    va_start(args, count);
    for (int i = 0; i < count; i++) {
        // 假设调用方传了一个 double，但你用 int 去接收
        // double d = 3.14;
        // print_args(1, d); // 调用方
        int num = va_arg(args, int); // 错误：类型不匹配！
        printf("%d\n", num); // 可能打印出垃圾值或导致崩溃
    }
    va_end(args);
}

必须知道参数的数量或类型

C 语言没有内置机制让函数自动知道它收到了多少个可变参数，或者每个参数是什么类型,你必须通过某种方式来传递这个信息。

• 像 my_sum 一样，用一个参数明确指定数量。
• 像 printf 一样，通过格式化字符串 %s, %d 等来推断参数的类型和数量。 printf 的内部实现会解析 format 字符串，并使用 va_arg 以正确的类型和顺序取出参数。format 字符串中的格式说明符与实际传入的参数不匹配,同样会导致灾难性后果。

没有编译时检查

编译器无法检查你传入的可变参数是否与你的期望一致,错误只有在运行时才会暴露。

无法安全地传递结构体

将结构体作为可变参数传递是不安全的，在 C 中，结构体在函数调用时通常是通过“值传递”的方式拷贝到栈上的，如果结构体的定义发生变化（比如增加了成员），它的内存布局也会改变，这会导致新旧代码在传递同一个结构体时，栈上的大小不匹配,从而引发崩溃。

推荐做法： 如果需要传递复杂对象，最好传递指向该对象的指针。

Linux 内核中的可变参数

在 Linux 内核编程中，可变参数同样被广泛使用，尤其是在日志记录系统中，内核提供了自己的、更安全的实现。

核心函数:

• vprintk(const char *fmt, va_list args): 内核的 vprintf 等价物。
• printk(const char *fmt, ...): 内核的 printf 等价物。

示例: 在内核模块中使用 printk

#include <linux/module.h>
#include <linux/kernel.h> // 包含 printk 的头文件
static int __init my_init_module(void) {
    printk(KERN_INFO "Loading my module...\n");
    // 使用可变参数
    int a = 100;
    const char *str = "Hello from kernel!";
    printk(KERN_INFO "Values: %d, %s\n", a, str);
    return 0;
}
static void __exit my_cleanup_module(void) {
    printk(KERN_INFO "Removing my module.\n");
}
module_init(my_init_module);
module_exit(my_cleanup_module);
MODULE_LICENSE("GPL");

内核的 printk 函数内部会解析 fmt 字符串，并使用类似 va_arg 的机制（但内核有自己的一套宏）来获取参数，它还提供了日志级别（如 KERN_INFO, KERN_ERR）等额外功能。

可变参数是 C 语言的一把“双刃剑”，它提供了强大的灵活性,但也要求使用者具备极高的责任心和对底层机制的深刻理解。