精华内容
参与话题
问答
  • getopt

    针对输入变量进行处理函数getopt,首先man大法:

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

    可以看出,该函数主要用在慢函数中。

    optarg——指向当前选项参数(如果有)的指针。
    optind——再次调用 getopt() 时的下一个 argv 指针的索引。
    optopt——最后一个已知选项

    返回值:

    If an option was successfully found, then getopt() returns the option character.  If all  command-line  options  have  been
           parsed,  then  getopt()  returns  -1.   If  getopt()  encounters an option character that was not in optstring, then '?' is
           returned.  If getopt() encounters an option with a missing argument, then the return value depends on the  first  character
           in optstring: if it is ':', then ':' is returned; otherwise '?' is returned.

    简单解释如下:如果选项在字符串optstring中,则getopt返回该字符串,且字符串指针optarg指向对应的选项对应的值(如果是无参选项,则对应null);

                               继续查找下一个选项,如果要查找的选项不在字符串optstring中,则返回‘?’;

                               如果输入的各个选项均已在optstring查找一遍,则getopt返回-1。

    所以一般对输入参数进行判定,在while中使用getopt进行判定。

    如果选项需要带值,在后面跟‘:’, 例如‘a:b’  表示选项a需要带值且以空格隔开或者不用空格,而b不带值

    ‘::’ 表示必须带值,且必须不加空格  比如 ‘a::b:’  只能写为: -atext1  -b text2

    程序示例:

    #include     <unistd.h>
    #include     <stdio.h>
    
    int     main(int argc, char *argv[])
    {
        int  ch;
        opterr = 0;
        while( (   ch  = getopt(argc,argv,"a:b:c:d::e") )  !=-1 )
        {
            switch(ch)
            { 
                case  'a': 
                    printf("a option: %s\n", optarg);    
                    break;
                case  'b':
                    printf("b option: %s\n", optarg);
                    break;
                case 'c':
                    printf("c option: %s\n",optarg);
                    break;
                case 'd':   
                    printf("d option: %s\n",optarg);
                    break;
                case 'e':
                    printf("e option: %s\n",optarg);
                    break;                
                case '?':
                    printf("illegal option:%c\n",ch);  
                    break;   
            }
    
        }
    
    }

    wln@iZ232ngsvp8Z:~/2015/11> ./getopt4 -a 1 -b 2 -c 3 -d4 -e 5 -w 6
    a option: 1
    b option: 2
    c option: 3
    d option: 4
    e option: (null)
    illegal option:?


    程序示例2:

    wln@iZ232ngsvp8Z:~/2015/11> cat getopt4.c
    #include     <unistd.h>   
    #include     <stdio.h>   
    
    int     main(int argc, char *argv[])   
    {   
        int  ch;   
        opterr = 0;   
        while( (   ch  = getopt(argc,argv,"a:b:c:d::e") )  !=-1 )   
        {   
            switch(ch)   
            { 
                case  'a':   
                    printf("a option: %s %s\n", optarg,argv[optind]);  
                    break;   
                case  'b':   
                    printf("b option: %s\n", optarg);   
                    break;   
                case 'c':   
                    printf("c option: %s\n",optarg);   
                    break;   
                case 'd':   
                    printf("d option: %s\n",optarg);   
                    break;
                case 'e':   
                    printf("e option: %s\n",optarg);   
                    break;
                case '?':   
                    printf("illegal option:%c\n",ch);   
                    break;   
            }             
    
        }
    
      int i=0;
      while(i++<argc)
          printf("%d\t%s\n",i,argv[i]);
      if (optind < argc) 
          printf("non-option ARGV-elements: \n");
      while (optind < argc)
            printf("%s\n", argv[optind++]);
    
    }

    wln@iZ232ngsvp8Z:~/2015/11> ./getopt4  -a 1 -b -c -d -e 1 2 3
    a option: 1 -b
    b option: -c
    d option: (null)
    e option: (null)
    1       -a
    2       1
    3       -b
    4       -c
    5       -d
    6       -e
    7       1
    8       2
    9       3
    10      (null)
    non-option ARGV-elements:
    1
    2

    3

    --------------

    optind : option index

    while (optind < argc)
            printf("%s\n", argv[optind++]);

    :: getopt解析了它能识别的参数,剩余的在此,从上面程序结果也可以看出


    函数getopt_long

    man 大法

    The getopt_long() function works like getopt() except that it also accepts long options, started with two dashes.  (If  the
           program  accepts  only  long  options,  then optstring should be specified as an empty string (""), not NULL.)  Long option
           names may be abbreviated if the abbreviation is unique or is an exact match for some defined option.   A  long  option  may
           take a parameter, of the form --arg=param or --arg param.
    
           longopts is a pointer to the first element of an array of struct option declared in <getopt.h> as
    
               struct option {
                   const char *name;
                   int         has_arg;
                   int        *flag;
                   int         val;
               };
    
           The meanings of the different fields are:
    
           name   is the name of the long option.
    
           has_arg
                  is:  no_argument  (or 0) if the option does not take an argument; required_argument (or 1) if the option requires an
                  argument; or optional_argument (or 2) if the option takes an optional argument.
    
           flag   specifies how results are returned for a long option.  If flag is NULL, then getopt_long() returns val.  (For  exam-
                  ple, the calling program may set val to the equivalent short option character.)  Otherwise, getopt_long() returns 0,
                  and flag points to a variable which is set to val if the option is found, but left unchanged if the  option  is  not
                  found.
    
           val    is the value to return, or to load into the variable pointed to by flag.
    
           The last element of the array has to be filled with zeros.
    
           If longindex is not NULL, it points to a variable which is set to the index of the long option relative to longopts.
    
           getopt_long_only()  is  like  getopt_long(),  but '-' as well as "--" can indicate a long option.  If an option that starts
           with '-' (not "--") doesn't match a long option, but does match a short option, it is parsed as a short option


    程序(来自linux man getopt)

    #include <stdio.h>     /* for printf */
    #include <stdlib.h>    /* for exit */
    #include <getopt.h>
    
    int
    main(int argc, char **argv)
    {
       int c;
       int digit_optind = 0;
    
       while (1) {
               int this_option_optind = optind ? optind : 1;
               int option_index = 0;
               static struct option long_options[] = {
                       {"add", 1, 0, 0},
                       {"append", 0, 0, 0},
                       {"delete", 1, 0, 0},
                       {"verbose", 0, 0, 0},
                       {"create", 1, 0, 'c'},
                       {"file", 1, 0, 0},
                       {0, 0, 0, 0}
               };
    
               c = getopt_long(argc, argv, "abc:d:012",
                                    long_options, &option_index);
               if (c == -1)
                       break;
    
               switch (c) {
               case 0:
                       printf("option %s", long_options[option_index].name);
                       if (optarg)
                               printf(" with arg %s", optarg);
                       printf("\n");
                       break;
    
               case '0':
               case '1':
               case '2':
                       if (digit_optind != 0 && digit_optind != this_option_optind)
                             printf("digits occur in two different argv-elements.\n");
                       digit_optind = this_option_optind;
                       printf("option %c\n", c);
                       break;
              case 'a':
                       printf("option a\n");
                       break;
    
               case 'b':
                       printf("option b\n");
                       break;
    
               case 'c':
                       printf("option c with value '%s'\n", optarg);
                       break;
    
               case 'd':
                       printf("option d with value '%s'\n", optarg);
                       break;
    
               case '?':
                       break;
    
               default:
                       printf("?? getopt returned character code 0%o ??\n", c);
               }
       }
    
       if (optind < argc) {
               printf("non-option ARGV-elements: ");
               while (optind < argc)
                       printf("%s ", argv[optind++]);
               printf("\n");
       }
    
       exit(EXIT_SUCCESS);
    }

    test:

    wln@iZ232ngsvp8Z:~/2015/11> ./getopt2 --add ADD --append --delete DELETE --verbose --create CREATE --file FILE  -c fae
    option add with arg ADD
    option append
    option delete with arg DELETE
    option verbose
    option c with value 'CREATE'
    option file with arg FILE
    option c with value 'fae'


    推荐阅读:

    1.http://www.cnblogs.com/caosiyang/archive/2012/03/26/2417689.html



    展开全文
  • 这个函数getopt_long,它能理解长短两种选项。要使用getopt_long,你必须提供两个数据结构。头一个是包含有效短选项的字符串,每个选项一个字符。需要参数的选项后面放一个冒号。比如我们的程序,这个字符串为ho:v...


    预备知识:

    1.getopt()
    getopt在UNIX下的命令列程式特别好用,特别是在你有许多参数要加入时。
    表头文件:#i nclude <unistd.h>
    函数声明:int getopt(int argc, char * const argv[], const char *optstring);
    函数说明:getopt()用来分析命令行参数。参数argc和argv是由main()传递的参数个数和内容。参数optstring 则代表欲处理的选项字符串。此函数会返回在argv 中下一个的选项字母,此字母会对应参数optstring 中的字母。如果选项字符串里的字母后接着冒号“:”,则表示还有相关的参数,全域变量optarg 即会指向此额外参数。如果getopt()找不到符合的参数则会印出错信息,并将全域变量optopt设为“?”字符,如果不希望getopt()印出错 信息,则只要将全域变量opterr设为0即可。
    返回值:如果找到符合的参数则返回此参数字母,如果参数不包含在参数optstring 的选项字母则返回“?”字符,分析结束则返回-1。

    2.getopt_long()                                       

    分析命令行选项是一件繁琐的工作。幸运的是GNU C库提供了一个函数使你在处理这项工作时能简单一点。这个函数是getopt_long,它能理解长短两种选项。

    要使用getopt_long,你必须提供两个数据结构。头一个是包含有效短选项的字符串,每个选项一个字符。需要参数的选项后面放一个冒号。比如我们的程序,这个字符串为ho:v,表示有效选项是-h,-o与-v并且第二个参数-o后面需要一个参数。


    要 指定可用的长选项,你要构建一个option结构的数组。每个元素对应一个长选项,并有四个域。一般情况下,第一个域是长选项的名字(一个字符串,不包含 两个连字符),第二个域如果是1表示这个选项接受一个参数,如果为0表示没有参数。第三个是NULL,第四个是一个字符常量指出与这个长选项对应的短选 项。最后的数组元素全部域应该都为0.

    调用getopt_long时,向它传递main的参数argc,argv,描述短选项的字符串与描述长选项的option结构数组。


    *每调用getopt_long一次,它分析一个选项,返回这个选项的短选项字母,如果没有发现选项则返回-1.


    *典型情况下,我们在一个循环中调用getopt_long,来处理所有用户指定的选项,并通过一个switch语句来处理特别的选项。


    *如果getopt_long遇到一个无效选项,它将打印一个错误信息并返回字符'?'。大多数程序将因此退出,并显示用法提示。


    *在处理需要参数的选项时,全局变量optarg指向这个参数正文。


    *当getopt_long完全全部选项分析时,全局变量optind包含第一个非选项参数在argv中的索引。



    程序清单1(getopt函数):

    编译运行程序及输出结果如下:
    obe-240 eagle/test> gcc -o getopt getopt.c
    obe-240 eagle/test> ./getopt
    Usage:./getopt [-a value][-b value][-c value][-d] arglist...
    obe-240 eagle/test> ./getopt -a hello
    a option:hello
    obe-240 eagle/test> ./getopt -b world
    b option:world
    obe-240 eagle/test> ./getopt -c eagle
    c option:eagle
    obe-240 eagle/test> ./getopt -d
    d option:(null)
    obe-240 eagle/test> ./getopt first seconde -a helloworld           #Attention!#
    a option:helloworld
    obe-240 eagle/test> ./getopt -e
    ./getopt: invalid option -- e
    illegal option:(null)


    程序清单(getopt_long函数):

     

     

    编译并运行程序:

    longmenyu@longmenyu-Vostro-1088:~/code$ gcc -o getopt_long getopt_long.c

    longmenyu@longmenyu-Vostro-1088:~/code$ ./getopt_long -h

    Usage:./getopt_long options [inputfile...]

    -h --help:            Display this usage information.

    -o --output filename: Write output to file.

     -v --verbose:         Print verbose message.

    longmenyu@longmenyu-Vostro-1088:~/code$ ./getopt_long -o

    ./getopt_long: option requires an argument -- 'o'

    Usage:./getopt_long options [inputfile...]

    -h --help:            Display this usage information.

    -o --output filename: Write output to file.

     -v --verbose:         Print verbose message.

    longmenyu@longmenyu-Vostro-1088:~/code$ ./getopt_long -v hello world eagle

    Argument[2]:hello

    Argument[3]:world

    Argument[4]:eagle


    展开全文
  • getopt函数和getopt_long函数详解

    万次阅读 2016-04-02 15:56:14
    getopt函数 函数功能:用来解析命令行参数,参数argc和argv分别代表参数个数和内容,跟main()函数里的命令行参数一样 函数所在头文件:#include 函数原型定义:int getopt(int argc, char* const argv[ ], ...

    getopt函数

    函数功能:用来解析命令行参数,参数argc和argv分别代表参数个数和内容,跟main()函数里的命令行参数一样

    函数所在头文件:#include<unistd.h>

    函数原型定义:int getopt(int argc, char* const argv[ ], const char *optstring )

    参数optstring: 为选项字符串,告知getopt可以处理那个选项以及哪个选项需要参数,如果选项字符串里的字母后接着冒号:“:”,则表示还有相关的参数,全域变量optarg即会指向此额外参数,如果在处理期间遇到了不符合optstring指定的其他选项,getopt()将会显示一个错误消息,并将全局域变量设置为“?”字符,将全局域变量opterr设置为0则将不会打印出错信息。

    extern char* optarg;

    extern int optind, opterr, optopt;

    参数optarg:指向当前选项参数的指针

    参数optind:再次调用getopt时的下一个argv指针索引

    参数optopt:表示最后一个未知选项

    参数optstring: 比如getopt(argc, argv, "td:ch:q::")

    1. 单个字符,表示选项,这里一共有t、d、c、h、q五个选项

    2. 单个字符后接一个冒号“:”表示该选项后必须跟一个参数,参数紧跟在选项后或者以空格隔开

    3. 单个字符后跟两个冒号,表示该选项后可以跟一个参数,也可以不跟,如果后边跟一个参数,参数必须紧跟在选项后不能以空格隔开。


    #include <stdio.h>
    #include<unistd.h>
    
    int main(int argc, char *argv[])
    {
    	int ch;
    	opterr = 0;//不打印错误信息
    	
    	while((ch = getopt(argc,argv,"tl:cm:q::"))!= -1)
    	{
    		switch(ch)
    		{
    			//第一个参数t后面不跟参数
    			case 't': printf("love IT\n");break;
    			
    			//第二个参数l后面要跟参数执行命令并打印参数
    			case 'l': printf("love life: %s\n",optarg); break;
    			
    			case 'c': printf("love Code\n"); break;
    			case 'm': printf("love myself %s\n", optarg); break;
    			
    			//第五个参数q后面可跟可不跟参数,一个参数的话必须紧跟q后面不能有空格 
    			case 'q': printf("love quite: %s\n",optarg); break;
    			
    			default: printf("other option :%c\n",ch);
    		}
    	
    	}
    	return 0;
    }

    笔记本测试效果截图:


    getopt_long函数

    函数功能:支持长选项的命令解析

    函数所在头文件:#include<getopt.h>

    函数原型定义:int getopt_long(int argc, char * const argv[],const char *optstring, const struct option *longopts,int *longindex)

    参数optstring: 为选项字符串,告知getopt_long可以处理那个选项以及哪个选项需要参数,如果选项字符串里的字母后接着冒号:“:”,则表示还有相关的参数,全域变量optarg即会指向此额外参数,如果在处理期间遇到了不符合optstring指定的其他选项,getopt_long()将会显示一个错误消息,并将全局域变量设置为“?”字符,将全局域变量opterr设置为0则将不会打印出错信息。

    参数longopts:

    struct option {
    const char *name; //name表示的是长参数名
    int has_arg; //has_arg有3个值,no_argument(或者是0),表示该参数后面不跟参数值
    // required_argument(或者是1),表示该参数后面一定要跟个参数值
    // optional_argument(或者是2),表示该参数后面可以跟,也可以不跟参数值
    int *flag;
    //用来决定,getopt_long()的返回值到底是什么。如果flag是null(通常情况),则函数会返回与该项option匹配的 val值;如果flag不是NULL,则将val值赋予flag所指向的内存,并且返回值设置为0。
    int val; //和flag联合决定返回值
    }

    举个例子:
    struct option long_options[] = {
    {"a123", required_argument, 0, 'a'},
    {"c123", no_argument, 0, 'c'},
    };
    现在,如果命令行的参数是-a 123,那么调用getopt_long()将返回字符'a',并且将字符串123由optarg返回(注意注意!字符串123由optarg带回!optarg不需要定义,在getopt.h中已经有定义),那么,如果命令行参数是-c,那么调用getopt_long()将返回字符'c',而此时,optarg是null。最后,当getopt_long()将命令行所有参数全部解析完成后,返回-1。

    required_argument(或者是1)时,参数输入格式为:--参数 值 或者 --参数=值。
    optional_argument(或者是2)时,参数输入格式只能为:--参数=值。

    参数longindex: 表示当前长参数在longopts中的索引值

    extern char* optarg;

    extern int optind, opterr, optopt;

    参数optarg:指向当前选项参数的指针

    参数optind:再次调用getopt_long时的下一个argv指针索引

    参数optopt:表示最后一个未知选项

    参数optstring: 同上


    具体用法可以详见开源源码研究:http://blog.csdn.net/coding__madman/article/details/51020459



    展开全文
  • getopt函数

    万次阅读 2012-05-09 15:23:14
    (一) 在Linux中,用命令行执行可...程序会根据读取的参数执行相应的操作,在C语言中,这个功能一般是靠getopt()这个函数,结合switch语句来完成的,首先来看下面的代码: #include #include int main(int

    (一)

    在Linux中,用命令行执行可执行文件时可能会涉及到给其加入不同的参数的问题,例如:

    ./a.out -a1234 -b432 -c -d

    程序会根据读取的参数执行相应的操作,在C语言中,这个功能一般是靠getopt()这个函数,结合switch语句来完成的,首先来看下面的代码:
    #include <stdio.h>
    #include <unistd.h>

    int main(int argc,char *argv[])
    {
      int ch;
      opterr=0;
      
      while((ch=getopt(argc,argv,"a:b::cde"))!=-1)
      {
        printf("optind:%d\n",optind);
        printf("optarg:%s\n",optarg);
        printf("ch:%c\n",ch);
        switch(ch)
        {
          case 'a':
            printf("option a:'%s'\n",optarg);
            break;
          case 'b':
            printf("option b:'%s'\n",optarg);
            break;
          case 'c':
            printf("option c\n");
            break;
          case 'd':
            printf("option d\n");
            break;
          case 'e':
            printf("option e\n");
            break;
          default:
            printf("other option:%c\n",ch);
        }
        printf("optopt+%c\n",optopt);
      }

    }    

    用gcc编译后,在终端行执行以上的命令:
    ./a.out -a1234 -b432 -c -d

    则会有如下的输出:
    optind:2
    optarg:1234
    ch:a
    option a:'1234'
    optopt+
    optind:3
    optarg:432
    ch:b
    option b:'432'
    optopt+
    optind:4
    optarg:(null)
    ch:c
    option c
    optopt+
    optind:5
    optarg:(null)
    ch:d
    option d
    optopt+

    要理解getopt()函数的作用,首先要清楚带参数的main()函数的使用:
    main(int argc,char *argv[])中的argc是一个整型,argv是一个指针数组,argc记录argv的大小。上面的例子中。
    argc=5;
    argv[0]=./a.out
    argv[1]=-a1234
    argv[2]=-b432
    argv[3]=-c
    argv[4]=-d
    getopt()函数的原型为getopt(int argc,char *const argv[],const char *optstring)。
    其中argc和argv一般就将main函数的那两个参数原样传入。
    optstring是一段自己规定的选项串,例如本例中的"a:b::cde",表示可以有,-a,-b,-c,-d,-e这几个参数。
    “:”表示必须该选项带有额外的参数,全域变量optarg会指向此额外参数,“::”标识该额外的参数可选(有些Uinx可能不支持“::”)。
    全域变量optind指示下一个要读取的参数在argv中的位置。
    如果getopt()找不到符合的参数则会印出错信息,并将全域变量optopt设为“?”字符。
    如果不希望getopt()印出错信息,则只要将全域变量opterr设为0即可。

     

     

     

    (二)

    #include <unistd.h>
           extern char *optarg;  //选项的参数指针
           extern int optind,   //下一次调用getopt的时,从optind存储的位置处重新开始检查选项。
           extern int opterr,  //当opterr=0时,getopt不向stderr输出错误信息。
           extern int optopt;  //当命令行选项字符不包括在optstring中或者选项缺少必要的参数时,该选项存储在optopt中,getopt返回'?’、
           int getopt(int argc, char * const argv[], const char *optstring);
     调用一次,返回一个选项。 在命令行选项参数再也检查不到optstring中包含的选项时,返回-1,同时optind储存第一个不包含选项的命令行参数。

    首先说一下什么是选项,什么是参数。

    字符串optstring可以下列元素,
    1.单个字符,表示选项,
    2.单个字符后接一个冒号:表示该选项后必须跟一个参数。参数紧跟在选项后或者以空格隔开。该参数的指针赋给optarg。
    3 单个字符后跟两个冒号,表示该选项后必须跟一个参数。参数必须紧跟在选项后不能以空格隔开。该参数的指针赋给optarg。(这个特性是GNU的扩张)。

    getopt处理以'-’开头的命令行参数,如optstring="ab:c::d::",命令行为getopt.exe -a -b host -ckeke -d haha
    在这个命令行参数中,-a和-h就是选项元素,去掉'-',a,b,c就是选项。host是b的参数,keke是c的参数。但haha并不是d的参数,因为它们中间有空格隔开。

    还要注意的是默认情况下getopt会重新排列命令行参数的顺序,所以到最后所有不包含选项的命令行参数都排到最后。
    如getopt.exe -a ima -b host -ckeke -d haha, 都最后命令行参数的顺序是: -a -b host -ckeke -d ima haha
    如果optstring中的字符串以'+'加号开头或者环境变量POSIXLY_CORRE被设置。那么一遇到不包含选项的命令行参数,getopt就会停止,返回-1。

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

    int main(int argc, char **argv)
    {
        int result;

        opterr = 0;  //使getopt不行stderr输出错误信息

        while( (result = getopt(argc, argv, "ab:c::")) != -1 )
        {
               switch(result)
              {
                   case 'a':
                       printf("option=a, optopt=%c, optarg=%s\n", optopt, optarg);
                       break;
                  case 'b':
                       printf("option=b, optopt=%c, optarg=%s\n", optopt, optarg);
                       break;
                  case 'c':
                       printf("option=c, optopt=%c, optarg=%s\n", optopt, optarg);
                       break;
                  case '?':
                        printf("result=?, optopt=%c, optarg=%s\n", optopt, optarg);
                        break;
                  default:
                       printf("default, result=%c\n",result);
                       break;
               }
            printf("argv[%d]=%s\n", optind, argv[optind]);
        }
        printf("result=-1, optind=%d\n", optind);   //看看最后optind的位置

        for(result = optind; result < argc; result++)
             printf("-----argv[%d]=%s\n", result, argv[result]);

     //看看最后的命令行参数,看顺序是否改变了哈。
        for(result = 1; result < argc; result++)
              printf("\nat the end-----argv[%d]=%s\n", result, argv[result]);
        return 0;
    }

    unistd里有个 optind 变量,每次getopt后,这个索引指向argv里当前分析的字符串的下一个索引,因此
    argv[optind]就能得到下个字符串,通过判断是否以 '-'开头就可。下面是个测试程序
    #include <stdio.h>
    #include <unistd.h>
    int main(int argc, char* argv[])
    {
        int tmp = 4;
       
        while( (tmp = getopt(argc, argv, "abck")) != -1  )
        {
              
               printf("-%c\t", tmp);
               int opt = optind ;
               while( opt < argc )
               {
                      if ( argv[opt][0] != '-' )
                      {
                           printf("%s\t", argv[opt]);
                           opt ++;
                      }
                      else
                          break;
               }
               printf("\n");
        }
        getchar();
    }
    函数说明  getopt()用来分析命令行参数。参数argc和argv是由main()传递的参数个数和内容。参数optstring 则代表欲处理的选项字符串。此函数会返回在argv 中下一个的选项字母,此字母会对应参数optstring 中的字母。如果选项字符串里的字母后接着冒号“:”,则表示还有相关的参数,全域变量optarg 即会指向此额外参数。如果getopt()找不到符合的参数则会印出错信息,并将全域变量optopt设为“?”字符,如果不希望getopt()印出错信息,则只要将全域变量opterr设为0即可。

    返回值  如果找到符合的参数则返回此参数字母,如果参数不包含在参数optstring 的选项字母则返回“?”字符,分析结束则返回-1。

    范例  #include<stdio.h>
    #include<unistd.h>
    int main(int argc,char **argv)
    {
    int ch;
    opterr = 0;
    while((ch = getopt(argc,argv,”a:bcde”))!= -1)
    switch(ch)
    {
    case ‘a’:
    printf(“option a:’%s’\n”,optarg);
    break;
    case ‘b’:
    printf(“option b :b\n”);
    break;
    default:
    printf(“other option :%c\n”,ch);
    }
    printf(“optopt +%c\n”,optopt);
    }

    执行  $./getopt –b
    option b:b
    $./getopt –c
    other option:c
    $./getopt –a
    other option :?
    $./getopt –a12345
    option a:’12345’


    getopt 函数
    函数定义:
    #include
    int getopt(int argc, char * const argv[],
            const char *optstring);

    extern char *optarg;
    extern int optind, opterr, optopt;


    #define _GNU_SOURCE
    #include

    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()函数是用来解析命令行参数的。这里,主要解释getopt_long()。

        getopt_long()的头两参数,argc和argv分别是传递给main()的参数的个数和参数数组(和main()的argc和argv是一个概念)。

        getopt_long()中,optstring是一个字符串,表示可以接受的参数。例如,"a:b:cd",表示可以接受的参数是a,b,c,d,其中,a和b参数后面

    跟有更多的参数值。(例如:-a host --b name)

        getopt_long()中,参数longopts,其实是一个结构的实例:
    struct option {
      const char *name;
        //name表示的是长参数名
      int has_arg;
        //has_arg有3个值,no_argument(或者是0),表示该参数后面不跟参数值
        //   required_argument(或者是1),表示该参数后面一定要跟个参数值
        //   optional_argument(或者是2),表示该参数后面可以跟,也可以不跟参数值
      int *flag;
        //用来决定,getopt_long()的返回值到底是什么。如果flag是null,则函数会返回与该项option匹配的val值
      int val;
        //和flag联合决定返回值
    }

    给个例子:

    struct option long_options[] = {
      {"a123",       required_argument,      0, 'a'},
      {"c123",       no_argument,            0, 'c'},
    }

    现在,如果命令行的参数是-a 123,那么调用getopt_long()将返回字符'a',并且将字符串123由optarg返回(注意注意!字符串123由optarg带

    回!optarg不需要定义,在getopt.h中已经有定义)
    那么,如果命令行参数是-c,那么调用getopt_long()将返回字符'c',而此时,optarg是null。

    最后,当getopt_long()将命令行所有参数全部解析完成后,返回-1。

    看来,我说的有点混乱,那么,看个例子,我相信,代码最能说明问题:

    #include
    #include
    #include
    #include

    int main( int argc, char **argv )
    {

     struct option long_options[] = {
       {"a123",       required_argument,      0, 'a'},
       {"c123",       no_argument,            0, 'c'},
     }
     int opt;
     
     printf("starting... ");
     
     while((opt = getopt_long(argc, argv, "a:c", long_options, NULL)) != -1)
     {
      switch (opt)
      {
      case 'a':
        printf("It's a! ");
        printf("string of a:%s ",optarg);
      break;
       
      case 'c':
        printf("It's c! ");
      break;
       
      default:
        printf("You should look for help! ");
        exit(1);
      break;           
      }
     }
     printf("end... ");
     return 0;
    }

    编译后,假设生成a.out,可以试验一下。
    ./a.out -a hello -c
    输出:
    starting...
    It's a!
    string of a:hello
    It's c!
    end...


     


     

    展开全文
  • getopt 函数

    2017-11-12 16:14:21
    程序借助getopt函数实现多变的启动选项、参数。该函数的声明:#include <unistd.h>int getopt(int argc, char * const argv[], const char *optstring);应用选项:-n —— 显示“我的名字”。 -g —— 显示“我女...

空空如也

1 2 3 4 5 ... 20
收藏数 3,856
精华内容 1,542
关键字:

getopt