如何优雅地处理命令行参数？

朴灿烈づ我的快乐病毒、 2021-10-29 07:16 321阅读 0赞

原文地址： https://www.yanbinghu.com/2019/08/17/57486.html

## 前言 ##

我们在Linux用到的命令常常支持很多参数，那么如何写一个程序，也像Linux命令一样支持很多参数呢？有什么什么优雅的处理方法？

## 命令行参数 ##

在介绍如何处理命令行参数之前，简单介绍一下命令行参数，已经了解的朋友可以跳过此小节。  
我们用一段代码，打印传给程序的每一个参数

//来源：公众号【编程珠玑】
    //博客：https://www.yanbinghu.com
    //main.c
    #include<stdio.h>
    int main(int argc,char *argv[])
    {
        
        int i = 0;
        for(i = 0;i < argc;i++)
        {
        
            printf("the %d para is %s\n",i,argv[i]);
        }
        return 0;
    }

其中argc代表输入的参数个数，而argv中保存着参数具体的值，我们编译运行：

$ gcc -o main main.c
    $ ./main 编程珠玑 C C++ Java 博客
    the 0 para is ./main
    the 1 para is 编程珠玑
    the 2 para is C
    the 3 para is C++
    the 4 para is Java
    the 5 para is 博客

我们依次打印了程序的输入参数，其中特别注意的是，第一个（下标为0）的参数是程序本身。

## 如何优雅地处理命令行参数 ##

实际上我们通过getopt函数很容易实现。

#### 函数声明 ####

getopt就可以非常方便地处理简单参数了，其声明如下：

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

#### 参数介绍 ####

几个参数说明如下：

*  argc 参数个数，可从main函数入口传入
 *  argv 参数字符串数组，可从main函数入口传入
 *  optstring 支持的选项字符串

第一个和第二个参数我们很熟悉，它和main函数的参数是一样的：

int main(int argc,char *argv[]);

第三个参数是什么意思呢？指的是你支持的选项，假设你的程序支持-h,-a,-n选项，并且-n选项后面要跟具体参数，那么optstring可以是：

“han:”

选项后面有一个冒号表示这个选项需要带参数。

它的返回值是int类型，如果出错，则返回-1，如果命令参数不识别，则返回’?‘。

#### 外部变量 ####

它有四个外部变量，含义分别如下：

*  optind 存放下一个要处理的字符串在argv数组中的下标，从1开始
 *  opterr 如果选项发生错误，getopt会打印出错消息，如果设置为0，则不打印。
 *  optopt 如果选项处理发生错误，它会指向导致出错的选项字符串
 *  optarg 如果一个选项需要参数，如前面提到的n参数，由于后面有:，所以它需要参数，处理到它时，optarg会指向这个参数。

#### 程序示例 ####

我们仍然通过一个示例程序来看：

//来源：公众号【编程珠玑】
    //博客：https://www.yanbinghu.com
    //main1.c
    #include<stdio.h>
    #include<unistd.h>
    extern int optind,opterr,optopt;
    extern char *optarg;
    int main(int argc,char *argv[])
    {
        
        int c = 0; //用于接收选项
        /*循环处理参数*/
        while(EOF != (c = getopt(argc,argv,"han:")))
        {
        
            //打印处理的参数
            printf("start to process %d para\n",optind);
            switch(c)
            {
        
                case 'h':
                    printf("we get option -h\n");
                    break;
                case 'a':
                    printf("we get option -a\n");
                    break;
                //-n选项必须要参数
                case 'n':
                    printf("we get option -n,para is %s\n",optarg);
                    break;
                //表示选项不支持
                case '?':
                    printf("unknow option:%c\n",optopt);
                    break;
                default:
                    break;
            }    
        }
        return 0;
    }

编译运行：

$ gcc -o main1 main1.c

输入正常选项时，我们可以看到能正确获取到选项，获取到之后自然就可以做对应的动作了。

$ ./main1 -h -a
    start to process 2 para
    we get option -h
    start to process 3 para
    we get option -a

如果输入的选项不支持，就会提示未知选项：

$ ./main1 -u
    ./main1: invalid option -- 'u'
    start to process 2 para
    unknow option:u

对于-n选项，我们需要参数，如果没有参数会怎样？

$ ./main1 -n
    ./main1: option requires an argument -- 'n'
    start to process 2 para
    unknow option:n

它会提示我们n选项需要参数，于是带上参数：

$ ./main1 -n
    start to process 3 para
    we get option -n,para is 2

怎么样？是不是很简单？

#### 问题 ####

但是不知道你有没有发现，上面的处理有个问题，那就是不支持长选项。

什么意思呢？

$ ./main1 -ha
    start to process 1 para
    we get option -h
    start to process 2 para
    we get option -a

这种情况下，-ha被当成了两个选项，而不是一个选项，选项名为ha。

那么这种情况应该如何处理呢？就需要用到后面的函数啦。

> 来源：公众号【编程珠玑】  
> https://www.yanbinghu.com/2019/08/17/57486.html  
> 专注分享Linux/C/C++等

## 长选项处理 ##

为了应对前面说的这种情况，需要用到下面两个函数中的一个：

#include<getopt.h>
    int getopt_long(int argc, char * const argv[],
                      const char *optstring,
                      const struct option *longopts, int *longindex);
    
    int getopt_long_only(int argc, char * const argv[],
                      const char *optstring,
                      const struct option *longopts, int *longindex);

它们的第一个第二个参数和getopt一样，第三个参数是一个struct option指针：

struct option {
        
                   const char *name;
                   int         has_arg;
                   int        *flag;
                   int         val;
               };

其成员含义分别如下：

*  name 长选项名称
 *  has\_arg 参数可选项，no\_argument表示该选项后不带参，required\_argument表示该选项后面带参数
 *  \*flag 匹配到选项后，如果flag是NULL，则返回val；如果不是NULL，则返回0，并且将val的值赋给flag指向的内存
 *  val 匹配到选项后的返回值

longindex表示**长选项**在longopts中的索引值。

那getopt\_long和getopt\_long\_only有什么区别呢？  
实际上主要功能是差不多的，只是前者一个-时被解析成短选项，–被解析成长选项，而后者都被解析为长选项，举个例子，-help在前者被解析为h,e,l,p四个选项，而在后者是和–help一样的效果，即被认为是长选项。在getopt\_long\_only中，optstring可以为“”。

我们来看一个示例程序：

//来源：公众号【编程珠玑】
    //博客：https://www.yanbinghu.com
    //main2.c
    #include<stdio.h>
    #include<getopt.h>
    extern int optind,opterr,optopt;
    extern char *optargi;
    //定义长选项
    static struct option long_options[] = 
    {
        
        {
        "help",no_argument,NULL,'h'},
        {
        "verbose",no_argument,NULL,'v'},
        {
        "number",required_argument,NULL,'n'}
    };
    int main(int argc,char *argv[])
    {
        
        int index = 0;
        int c = 0; //用于接收选项
        /*循环处理参数*/
        while(EOF != (c = getopt_long(argc,argv,"hvn:",long_options,&index)))
        {
        
            switch(c)
            {
        
                case 'h':
                    printf("we get option -h，index %d\n",index);
                    break;
                case 'v':
                    printf("we get option -v，index %d\n",index);
                    break;
                //-n选项必须要参数
                case 'n':
                    printf("we get option -n,para is %s\n",optarg);
                    break;
                //表示选项不支持
                case '?':
                    printf("unknow option:%c\n",optopt);
                    break;
                default:
                    break;
            }   
        }
        return 0;
    }

编译运行：

$ gcc -o main2 main2.c
    $ ./main2 --verbose --help 
    we get option -v，index 1
    we get option -h，index 0

注意，为什么-v参数的index是0？因为只有长选项才会对应index。

可以看到，使用–跟长选项，单个-后面跟短选项，但是如果是下面这样呢？

$ ./main2 -help 
    we get option -h，index 0
    ./main2: invalid option -- 'e'
    unknow option:e
    ./main2: invalid option -- 'l'
    unknow option:l
    ./main2: invalid option -- 'p'
    unknow option:p

在这里，由于使用的getopt\_long，它对于单个-的字符串，里面每个字符都当成了一个选项，因此help对它来说，其实是四个选项，但是后三个不被识别。如果想要-help也被当成长选项，那么就需要用到getopt\_long\_only函数了。

最后，再完整的用一遍：

$ ./main2 --help --verbose --number 10
    we get option -h，index 0
    we get option -v，index 1
    we get option -n,para is 10

## 扩展说明 ##

其实在处理选项的时候，如果参数前面有-，比如：

rm -bar

这里的-bar会被当成一个选项，而不是文件名，因此想要把它当成文件名，而不是选项，需要采用下面这种方式：

rm -- -bar

具体可以参考《[linux中删除特殊名称文件的多种方式][linux]》。

## 总结 ##

想要优雅地处理命令行参数，今天介绍的几个函数是有必要掌握了，那么是不是很想自己尝试一下呢？更多细节等你去发现。

[linux]: https://www.yanbinghu.com/2019/01/19/8873.html

发表评论取消回复

表情：

评论列表（有 0 条评论，321人围观）

还没有评论，来说两句吧...

相关阅读

相关如何优雅地处理空指针异常？

在编程中，空指针异常（NullPointerException）是一种常见的运行时错误，通常发生在尝试访问或操作一个为null的对象时。优雅地处理空指针异常意味着在代码中采取预

本是古典何须时尚/ 2024年11月06日 09:54/ 0 赞/ 12 阅读

相关如何优雅地处理Java并发问题？

在Java中，优雅地处理并发问题通常涉及以下几个方面： 1. **线程池**：使用`ExecutorService`创建线程池，可以重复利用已有线程，避免频繁创建和销毁线程。

心已赠人/ 2024年10月20日 17:03/ 0 赞/ 44 阅读

相关异常处理：Java中如何优雅地处理异常

在Java中，优雅地处理异常可以通过使用try-catch-finally结构来实现。以下是一些基本的步骤： 1. 使用`try`块：这是捕获和处理可能异常的地方。将可能会抛

朱雀/ 2024年09月20日 06:18/ 0 赞/ 79 阅读

相关 Python模块学习——optparse：优雅地处理命令行参数

Python模块学习——optparse：优雅地处理命令行参数作为Python的一个非常重要的模块，optparse模块是用于处理命令行参数的。在开发Python脚本或应用

矫情吗；*/ 2024年03月26日 21:27/ 0 赞/ 75 阅读

相关使用Argparse模块优雅地解析命令行参数

使用Argparse模块优雅地解析命令行参数在Python编写脚本时，通常需要通过命令行传递一些参数，和Java中的main函数类似。在不使用框架的情况下，我们可以使用 s

短命女/ 2024年03月24日 13:10/ 0 赞/ 69 阅读

相关如何优雅地处理重复请求（并发请求）

对于一些用户请求，在某些情况下是可能重复发送的，如果是查询类操作并无大碍，但其中有些是涉及写入操作的，一旦重复了，可能会导致很严重的后果，例如交易的接口如果重复请求可能会重复下

浅浅的花香味﹌/ 2022年12月24日 12:56/ 0 赞/ 187 阅读

相关 pycharm处理命令行参数

转自：[https://www.cnblogs.com/SCCQ/p/12298740.html][https_www.cnblogs.com_SCCQ_p_12298740.

女爷i/ 2022年11月20日 09:39/ 0 赞/ 217 阅读

相关 getopts命令行参数处理

[getopts命令行参数处理][getopts] 一、getopts 简介　　由于shell命令行的灵活性，自己编写代码判断时，复杂度会比较高。使用内部命令 get

小灰灰/ 2022年08月08日 06:24/ 0 赞/ 224 阅读

相关如何优雅地处理命令行参数？

原文地址： https://www.yanbinghu.com/2019/08/17/57486.html 前言我们在Linux用到的命令常常支持很多参数，那么如何写

朴灿烈づ我的快乐病毒、/ 2021年10月29日 07:16/ 0 赞/ 322 阅读

相关如何优雅地编码？

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg] 作者 | 会长链接 | cnblogs.com/zzy0471/p/7236309.htm

╰半夏微凉°/ 2021年08月01日 02:28/ 0 赞/ 613 阅读