C 语言命令行参数：argc、argv 与安全解析

你在终端里运行的每个程序都可以接收参数：gcc -Wall hello.c -o hello 就传了四个。你自己写的 C 程序通过 main 的两个参数读取它们，整个机制就这么简单：不需要调用库函数，也不需要任何设置。

函数签名

到目前为止，这些文档中的每个例子都用的是 int main(void)。另一种标准形式会接收命令行：

int main(int argc, char *argv[]) {
    /* ... */
}

• argc（argument count，参数个数）表示有多少个参数，包括程序名。
• argv（argument vector，参数向量）是一个字符串数组。char *argv[] 的意思是“指向 char 的指针数组”，也就是由 C 字符串组成的数组。

你也会经常看到等价的写法 char **argv；数组形参会退化为指针，所以这两种写法声明的是同一个东西。

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("argc = %d\n", argc);

    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = \"%s\"\n", i, argv[i]);
    }

    printf("argv[%d] = %s\n", argc, argv[argc] == NULL ? "NULL" : "not null");
    return 0;
}

用编辑器的 参数 面板提供参数（每个输入框是一个参数），然后点击运行。试试填三个：hello、world、42。

参数的构成

运行 ./greet Ada Lovelace 会得到：

值得记住的四个事实：

• 实际使用中，argc 至少为 1，因为 argv[0] 是程序名。真正的参数从下标 1 开始，所以遍历参数的循环从 i = 1 开始。
• 一切都是字符串。 ./prog 42 给你的是 "42" 这两个字符，而不是数字 42。转换是你自己的工作。
• argv[argc] 是 NULL。 这由标准保证，所以如果你愿意，也可以不用 argc 来遍历数组：for (char **p = argv + 1; *p != NULL; p++)。
• 拆分单词的是 shell，不是你的程序。 ./prog "Ada Lovelace" 是一个参数；引号被 shell 吃掉了，永远不会出现在 argv 里。

读取之前先检查

没有传入的参数并不是空字符串，而是一块你无权访问的内存。一定要先验证 argc：

#include <stdio.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s NAME\n", argv[0]);
        return 1;
    }

    printf("Hello, %s!\n", argv[1]);
    return 0;
}

这个小程序里有两个约定，在 Unix 工具中都是标准做法：

• 用法提示输出到 stderr，而不是 stdout，这样就不会污染通过管道传给其他程序的输出。
• main 返回非零值，向运行它的程序表示失败。0 表示成功，其他任何值都表示出了问题。Shell 脚本会检查这个值。

打印 argv[0] 而不是写死程序名，可以让提示信息与用户的实际调用方式一致，即使程序被改了名或通过不同路径调用也一样。

转换数字参数

argv[1] 是文本。要做算术运算就必须先转换，应该使用的函数是 <stdlib.h> 中的 strtol：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <limits.h>

/* Returns 1 on success and stores the value; 0 if the text is not a clean integer. */
int parse_int(const char *text, long *out) {
    char *end;
    errno = 0;
    long value = strtol(text, &end, 10);

    if (end == text)        return 0;   /* no digits at all      */
    if (*end != '\0')       return 0;   /* trailing junk: "12abc" */
    if (errno == ERANGE)    return 0;   /* out of long's range    */

    *out = value;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s NUMBER...\n", argv[0]);
        return 1;
    }

    long total = 0;
    for (int i = 1; i < argc; i++) {
        long n;
        if (!parse_int(argv[i], &n)) {
            fprintf(stderr, "%s: not an integer: %s\n", argv[0], argv[i]);
            return 1;
        }
        total += n;
    }

    printf("sum = %ld\n", total);
    return 0;
}

在参数面板中添加 10、20、30 三个参数，然后把其中一个换成 banana，看看出错时的处理。

strtol 的第三个参数是进制：10 表示十进制，16 表示十六进制，0 表示根据 0x 或前导零前缀自动识别。第二个参数用来存放一个指针，指向它没有处理的第一个字符，正是这一点让错误检查成为可能：

• end == text 表示什么都没解析到：参数不是以数字开头的。
• *end != '\0' 表示数字后面还有剩余文本，所以 "12abc" 会被拒绝，而不是悄悄变成 12。
• errno == ERANGE 表示值超出了 long 的范围。

对比一下 atoi，它更短，但这些情况一个都报告不了：

int n = atoi(argv[1]);   /* "banana" -> 0, "0" -> 0, overflow -> undefined */

atoi 对无效输入返回 0，这和真正的零无法区分。只要输入来自程序外部，就用 strtol（浮点数用 strtod）。更多内容见字符串转换。

一个小计算器

把这些组合起来：一个接收数字、运算符、数字的程序：

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

int parse_double(const char *text, double *out) {
    char *end;
    double v = strtod(text, &end);
    if (end == text || *end != '\0') {
        return 0;
    }
    *out = v;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "usage: %s NUMBER OPERATOR NUMBER\n", argv[0]);
        fprintf(stderr, "  operators: + - x /   (use x, not *, so the shell leaves it alone)\n");
        return 1;
    }

    double a, b;
    if (!parse_double(argv[1], &a) || !parse_double(argv[3], &b)) {
        fprintf(stderr, "%s: both operands must be numbers\n", argv[0]);
        return 1;
    }

    const char *op = argv[2];
    double result;

    if      (strcmp(op, "+") == 0) result = a + b;
    else if (strcmp(op, "-") == 0) result = a - b;
    else if (strcmp(op, "x") == 0) result = a * b;
    else if (strcmp(op, "/") == 0) {
        if (b == 0.0) {
            fprintf(stderr, "%s: division by zero\n", argv[0]);
            return 1;
        }
        result = a / b;
    } else {
        fprintf(stderr, "%s: unknown operator \"%s\"\n", argv[0], op);
        return 1;
    }

    printf("%g\n", result);
    return 0;
}

试试 12 + 30，然后是 7 x 6，再试 5 / 0。

注意这里写的是 strcmp(op, "+") == 0，而不是 op == "+"。用 == 比较 char * 值比较的是地址而不是内容，即使文本完全相同，结果也会是假。参见字符串函数。

用 x 代替 * 是一个来自实际使用的细节：大多数 shell 会在你的程序运行之前，把单独的 * 展开成当前目录下的文件列表。给它加上引号（'*'）也行，但选一个 shell 不会处理的字符更友好。

解析选项

按照惯例，选项以 - 开头。一个简单的手写循环就能处理常见情况：

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    long count = 1;
    const char *message = NULL;

    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
            verbose = 1;
        } else if (strcmp(argv[i], "-n") == 0) {
            if (i + 1 >= argc) {                 /* the value must exist */
                fprintf(stderr, "%s: -n needs a number\n", argv[0]);
                return 1;
            }
            count = strtol(argv[++i], NULL, 10); /* consume the next argument */
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "%s: unknown option %s\n", argv[0], argv[i]);
            return 1;
        } else {
            message = argv[i];
        }
    }

    if (message == NULL) {
        fprintf(stderr, "usage: %s [-v] [-n COUNT] MESSAGE\n", argv[0]);
        return 1;
    }

    if (verbose) {
        printf("printing \"%s\" %ld time(s)\n", message, count);
    }
    for (long i = 0; i < count; i++) {
        printf("%s\n", message);
    }
    return 0;
}

用四个参数试试：-v、-n、3、hello。

argv[++i] 之前的 i + 1 >= argc 检查是最关键的一行：需要值的选项必须确认这个值真的存在，否则当 -n 是最后一个参数时，程序就会读到数组末尾之外。在真正的 Unix 系统上，<unistd.h> 中的 getopt 会帮你完成这一切，包括 -vn3 这样合并在一起的短选项；一旦程序的选项超过两三个，就值得用它。

浏览器编辑器中的参数

本页的编辑器代码块会为你编译并运行，参数 面板就是你填写终端中程序名后面那些内容的地方。你用 添加参数 加上的每个输入框，正好对应 argv 中的一项。中间没有 shell，所以不会按空格拆分，也不需要引号：内容为 hello world 的输入框会作为单个参数 hello world 传入。要传 -n 3 hello，就添加三个输入框。面板留空时 argc == 1，这就是为什么第一次运行时 argc < 2 的检查会触发，也是它值得写上的原因。

常见错误

• 不检查 argc 就读取 argv[1]。 没有传入参数时会导致未定义行为，这也是这方面最常见的崩溃原因。
• 循环从 i = 0 开始。 这样会把程序名当成数据处理。
• 把 argv[1] 当成数字。 在你转换之前，它都是文本。
• 对用户输入使用 atoi。 无法区分错误的参数和零。
• 用 == 比较字符串。 请用 strcmp。
• 往 argv 的字符串里写入。 标准允许修改它们，但空间有限且依赖平台；如果需要修改，就复制到你自己的缓冲区里。