Linux c编程之main函数参数解析与应用

浪游东戴河

已于 2022-11-20 14:38:39 修改

阅读量1.9k

点赞数 1

分类专栏： Linux C网络编程实践文章标签： main argc argv hello world linux c

于 2022-11-16 14:17:45 首次发布

本文链接：https://blog.csdn.net/szkbsgy/article/details/127027406

版权

Linux C网络编程实践专栏收录该内容

15 篇文章 1 订阅

订阅专栏

一、说明

main函数是C语言程序的入口函数，也称为主函数，C程序都是从main函数开始执行的，必须为小写。函数原型有两种，一种带参数，一种不带参数，如下所示：

带参数：int main(int argc, char *argv[])
不带参数：int main(void)

在实际编程应用中，都是使用带参数的形式。不带参数的形式一般用于测试程序或demo等非正式场合。
程序中必须包含main()函数，否则编译不成功，提示错误如下：
undefined reference to `main’

二、最简单的C程序：Hello world

2.1 示例代码

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("hello world\n");

    return 0;
}

2.2 编译

$ gcc  hello_world_main.c

2.3 运行

$ ./a.out 
hello world

2.4 Hello world 的起源

“Hello,World!” 中文翻译为"你好，世界"，在C语言编程中使用它做为第一个演示程序。后来程序员延用了这一习惯，在所有语言编程学习、代码工程创建、初始设备调试、第一次通信消息调试等场景中，广泛使用“hello world”作为软件工程的初步成果演示。

三、main函数参数

再来看原型：int main(int argc, char *argv[])
argc和argv是main函数的参数，argc是整型，表示参数的个数，argv是字符串数组，表示参数内容。
参数内容使用数据索引的形式进行引用。比如argv[0]、argv[1]……argv[n],意义如下：
argv[0]表示程序名称
argv[1]表示第一个参数
argv[2]表示第二个参数

示例代码：

#include <stdio.h>

int main(int argc, char *argv[])
{
    int i = 0;

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

    return 0;
}

运行：

不传入参数：

$ ./a.out 
argc: 1
argv[0]: ./a.out

传入一个参数：

$ ./a.out zhangsan
argc: 2
argv[0]: ./a.out
argv[1]: zhangsan

$ ./a.out zhangsan lisi
argc: 3
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: lisi

$ ./a.out zhangsan lisi 2 3
argc: 5
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: lisi
argv[3]: 2
argv[4]: 3

$ ./a.out zhangsan hello world
argc: 4
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: hello
argv[3]: world

$ ./a.out zhangsan hello\ world
argc: 3
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: hello world

关键说明：

参数以空格作为分隔符
参数个数是包含程序本身的
传入的参数无论是字符串还是数字，都按字符串引用
argv[0]是带着路径的程序名
参数如果含有空格，需要使用\进行转义

四、main参数解析

程序中直接用argv[1]、argv[2]来引用参数的话，那么传入参数位置和含义就是一一绑定的，如果传入参数的位置不对或少传参数，程序就会异常。如下示例：
示例代码：
TODO
正确传参顺序：

$ ./a.out zhangsan 18 dongdaihe 1
argv[1] name: zhangsan
argv[2] age: 18
argv[3] addr: dongdaihe
argv[4] marry: 1

顺序不一致：

$ ./a.out 18 zhangsan  1 dongdaihe
argv[1] name: 18
argv[2] age: zhangsan
argv[3] addr: 1
argv[4] marry: dongdaihe

少传参数：

$ ./a.out zhangsan dongdaihe 1
argv[1] name: zhangsan
argv[2] age: dongdaihe
argv[3] addr: 1
argv[4] marry: (null)

4.1 参数解析函数getopt

为了解决参数位置问题，可以使用getopt解决，原型如下：

#include <unistd.h>
int getopt(int argc, char * const argv[],
                  const char *optstring);
 extern char *optarg;
 extern int optind, opterr, optopt;

getopt()函数传入命令行参数，argc和argv来源于main()函数的参数，分别表示参数个数和参数数组。以-开头的参数(argv[n])表示选项名称，通过循环调用getopt()函数可以遍历所有的选项，getopt()返回-1时，则表示参数扫描完成。
变量optind是下一个要被处理的参数，系统初始值为1。用户可以将optind复位为1来重新开始扫描argv参数列表，或者在扫描新的参数数组时。
getopt函数参数optstring表示支持的合法选项名称，一个字符表示一个选项，有三种用法：

如果选项后面没有冒号，表示该选项没有选项值。
如果选项后面有冒号，表示该选项有选项值，选项值为下一个argv参数
如果选项后面有两个冒号，表示该选项有一个可选的选项值，选项值要紧跟选项，中间不能有空格

getopt函数返回值：
4. 如果成功解析选项，则返回选项字符
5. 所有的参数解析完成时，返回-1
6. 如果遇到不认识的选项，则返回？
7. 如果遇到缺失参数的选项，则返回：

示例代码：

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

void usage(char *program)
{
    fprintf(stderr, "Usage: %s [-n name] [-a age] [-d addr] [-m] [-h]\n",
            program);
    printf("n: name\n");
    printf("a: age\n");
    printf("d: addr\n");
    printf("m: marry flag\n");
    printf("h: usage\n");
    printf("example: ./a.out -n zhangsan -a 18 -d dongdaihe -m\n");
}

int main(int argc, char *argv[])
{
    int opt = 0;

    while ((opt = getopt(argc, argv, "n:a:d:mh")) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
                break;
            case 'n':
                printf("name:%s\n", optarg);
                break;
            case 'a':
                printf("age:%d\n", atoi(optarg));
                break;
            case 'd':
                printf("addr:%s\n", optarg);
                break;
            case 'm':
                printf("already marry\n");
                break;
            default: /* '?' */
                usage(argv[0]);
                exit(-1);
        }
    }

    return 0;
}

运行：

$ ./a.out 
Usage: ./a.out [-n name] [-a age] [-d addr] [-m] [-h]
n: name
a: age
d: addr
m: marry flag
h: usage
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m

$ ./a.out -n zhangsan -a 18 -d dongdaihe -m
name:zhangsan
age:18
addr:dongdaihe
already marry

$ ./a.out -n zhangsan -a 18 -d dongdaihe -m -o
name:zhangsan
age:18
addr:dongdaihe
already marry
no option value

$ ./a.out -n zhangsan -a 18 -d dongdaihe -m -ohello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

缺少参数：

$ ./a.out -n zhangsan -a 18 -d
name:zhangsan
age:18
./a.out: option requires an argument -- 'd'
Usage: ./a.out [-n name] [-a age] [-d addr] [-m] [-h]
n: name
a: age
d: addr
m: marry flag
h: usage
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m

$ ./a.out -n zhangsan
name:zhangsan

$ ./a.out -h
Usage: ./a.out [-n name] [-a age] [-d addr] [-m] [-h]
n: name
a: age
d: addr
m: marry flag
h: usage
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m

关键说明：

长选项可以使用=赋值
可选参数必须使用=赋值
通常使用usage()函数来提示用户程序及参数的使用说明
usage()一般在输入参数不合法或不满足要求时调用

4.2 参数解析函数getopt_long

getopt虽然能解决参数位置问题，但以单字符为选项参数不便于用户记忆和理解，程序员编程调试时也会增加耗时。因此需要一种可理解的字符串（单词或词组)形式的选项名称。Getopt_long()函数可以解决此问题。
getopt_long原型：

#include <getopt.h>

int getopt_long(int argc, char * const argv[],
              const char *optstring,
              const struct option *longopts, int *longindex);

函数说明：
getopt_long()函数像getopt函数一样工作，除此之外，还支持长选项，长选项以两个“-”开头，如–name.如果程序只接受长选项，可以将短选项optstring指定为""即可，但不能是NULL。长选项可以带一个参数，使用形式可以是–arg=param 或者 --arg param。
函数参数说明：

longopts : 指向struct option的结构体数组，数组最后一个元素要求为0.
长参数是一个结构体，如下：
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
name: 长选项的名称
has_arg: 是否有选项值参数，取值有3种：
no_argument：没参数
required_argument：有参数
optional_argument：可选参数
flag:指定如何返回长选项的结果，有以下情况:

如果flag是NULL,则getopt_long()返回val(val一般被设置为短选项名称）
如果flag不是NULL，则flag在选项被找到时，设置为val的值

val: 返回值
longindex: 如果该参数不为空，则该值被设置为解析成功的长选项在longopts数组中的索引值

getopt_long()如果识别到是短选项时，则返回短选项字符。对长选项，如果flag是NULL，则返回val,否则返回0.错误则返回-1.
getopt_long返回值：
1.如果成功解析选项，则返回选项字符
2.所有的参数解析完成时，返回-1
3.如果遇到不认识的选项，则返回？
4.如果遇到缺失参数的选项，则返回：
5. 如果识别到是短选项时，则返回短选项字符
6. 对长选项，如果flag是NULL，则返回val,否则返回0.错误则返回-1.

示例代码：

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

static struct option long_opts[] = {
    { "help", no_argument, NULL, 'h' },
    { "name", required_argument, NULL, 'n' },
    { "age", required_argument, NULL, 'a' },    
    { "addr", required_argument, NULL, 'd' },    
    { "marry", no_argument, NULL, 'm' },    
    { "option", optional_argument, NULL, 'o' },
    { 0, 0, 0, 0 },
};

void usage(char *program)
{
    fprintf(stderr, "Usage: %s [--name name] [--age age] [--addr addr] [--marry [--help] [--option option]\n",
            program);
    printf("example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption\n");
    printf("example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello\n");
}

int main(int argc, char *argv[])
{
    int flags = 0;
    int opt = 0;
    int nsecs = 0;
    char info[32] = {0};
    int option_index = 0;

    if (argc < 2) {
        usage(argv[0]);
        exit(1);
    }

    while ((opt = getopt_long(argc, argv, "n:a:d:mho::", long_opts, &option_index)) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
                break;
            case 'n':
                printf("name:%s\n", optarg);
                break;
            case 'a':
                printf("age:%d\n", atoi(optarg));
                break;
            case 'd':
                printf("addr:%s\n", optarg);
                break;
            case 'm':
                printf("already marry\n");
                break;
            case 'o':
                if (!optarg) {
                    printf("no option value\n");
                } else {
                    printf("option value:%s\n", optarg);
                }
                break;
            default: /* '?' */
                usage(argv[0]);
                exit(-1);
        }
    }

    return 0;
}

运行：
支持短选项：

./a.out -n zhangsan -a 18 -d dongdaihe -m -ohello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

选项与值可以用空格分开，也可以用“=”

$ ./a.out --name zhangsan --age 18
name:zhangsan
age:18

$ ./a.out --name=zhangsan --age=18
name:zhangsan
age:18

可选参数：

$ ./a.out --option=6
option value:6

$ ./a.out --option
no option value

$ ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

使用说明：

$ ./a.out -h
usage: ./a.out [--name name] [--age age] [--addr addr] [--marry [--help] [--option option]
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption
example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello

$ ./a.out --help
Usage: ./a.out [--name name] [--age age] [--addr addr] [--marry [--help] [--option option]
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption
example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello

五、实际应用

5.1 通过文件传递命令行参数

如果程序的启动参数太多，导致启动的命令行太长，每次输入命令行参数耗时太多，也容易出现漏参数或输入错误的问题。虽然实际应用中，可以写到脚本中，避免输入问题，但同样看起来混乱，不清晰。为了解决上述问题，有一种解决方法是：将参数写到参数配置文件中，每个选项/参数为一行，命令行只传入一个带路径的配置文件名，由程序自己读取文件中参数并存储到argv数组中，再调用命令行解析函数getopt_long()进行后续解析。

源码解析：



static struct option long_opts[] = {
    { "help", no_argument, NULL, 'h' },
    { "config_file", required_argument, NULL, 'c' },
    { "name", required_argument, NULL, 'n' },
    { "age", required_argument, NULL, 'a' },    
    { "addr", required_argument, NULL, 'd' },    
    { "marry", no_argument, NULL, 'm' },    
    { "option", optional_argument, NULL, 'o' },
    { 0, 0, 0, 0 },
};

int load_cfg_file(char *cfg_file, int *argc, char *argv[])
{
    FILE *fp = NULL; 
    char buf[1024] = {0};
    char *p = NULL;

    fp = fopen(cfg_file, "r");
    if (!fp) {
        printf("open cfg file[%s] failed \n", cfg_file);
        return -1;
    }

    while (fgets(buf, sizeof(buf), fp)) {
        if (buf[0] == '#') {
            continue;
        }
        buf[strlen(buf) - 1] = '\0';
        p = (char *)malloc(strlen(buf));
        memset(p, 0, sizeof(strlen(buf)));
        memcpy(p, buf, strlen(buf));
        argv[*argc] = p;
        *argc += 1;
    }
}

void usage(char *program)
{
    fprintf(stderr, "Usage: %s [--name name] [--config_file file] [--age age] [--addr addr] [--marry [--help] [--option option]\n",
            program);
    printf("example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption\n");
    printf("example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello\n");
    printf("example: ./a.out --config_file file\n");
}


int parse_args(int argc, char *argv[])
{
    int opt = 0;
    int option_index = 0;
    int original_argc = 0;

    if (argc < 2) {
        usage(argv[0]);
        exit(1);
    }
    optind = 1;
    while ((opt = getopt_long(argc, argv, "n:a:c:d:mho::", long_opts, &option_index)) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
                break;
            case 'c':
                /* already processed before, must ignore */
                break;
            case 'n':
                printf("name:%s\n", optarg);
                break;
            case 'a':
                printf("age:%d\n", atoi(optarg));
                break;
            case 'd':
                printf("addr:%s\n", optarg);
                break;
            case 'm':
                printf("already marry\n");
                break;
            case 'o':
                if (!optarg) {
                    printf("no option value\n");
                } else {
                    printf("option value:%s\n", optarg);
                }
                break;
            default: /* '?' */
                usage(argv[0]);
                exit(-1);
        }
    }

    return 0;
}

int main(int argc, char *argv[])
{
    int i = 0;
    int opt = 0;
    int option_index = 0;
    int original_argc = 0;

    if (argc < 2) {
        usage(argv[0]);
        exit(1);
    }

    original_argc = argc;
    while ((opt = getopt_long(argc, argv, "n:a:c:d:mho::", long_opts, &option_index)) != -1) {
        switch (opt) {
            case 'c':
                load_cfg_file(optarg, &argc, argv);
                break;
        }
    }

    parse_args(argc, argv);

    for (i = original_argc; i < argc; i++) {
        if (argv[i]) {
            free(argv[i]);
        }
    }
    //release argc

    return 0;
}

运行：

$ cat file.cfg 
--name=zhangsan
--age=18
--addr=dongdaihe
--marry
--option=hello

$ ./a.out  --config_file file.cfg 
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

$ ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

文件参数+命令行参数：

$ cat file.cfg 
--name=zhangsan
--age=18
--addr=dongdaihe
--marry

$ ./a.out  --config_file file.cfg --option=hello
option value:hello
name:zhangsan
age:18
addr:dongdaihe
already marry

关键说明：

从文件中加载参数后，再次解析时要忽略配置文件参数，否则会出现死循环
加载配置文件参数时，需要分配空间
解析参数后，需要释放为文件中参数分配的空间
可以从配置文件和命令行同时传入配置参数

浪游东戴河

关注

1
点赞
踩
16

收藏

觉得还不错? 一键收藏
打赏
0
评论
Linux c编程之main函数参数解析与应用

main函数是C语言程序的入口函数，也称为主函数，C程序都是从main函数开始执行的，必须为小写。在实际编程应用中，都是使用带参数的形式。不带参数的形式一般用于测试程序或demo等非正式场合。
复制链接

扫一扫