一:posix约定:
下面是POSIX标准中关于程序名、参数的约定:
程序名不宜少于2个字符且不多于9个字符;
程序名应只包含小写字母和阿拉伯数字;
选项名应该是单字符或单数字,且以短横 ‘-’ 为前綴;
多个不需要选项参数的选项,可以合并。(譬如:foo -a -b -c ----> foo -abc)
选项与其参数之间用空白符隔开;
选项参数不可选。
若选项参数有多值,要将其并为一个字串传进来。譬如:myprog -u "arnold,joe,jane"。这种情况下,需要自己解决这些参数的分离问题。
选项应该在操作数出现之前出现。
特殊参数 ‘--’ 指明所有参数都结束了,其后任何参数都认为是操作数。
选项如何排列没有什么关系,但对互相排斥的选项,如果一个选项的操作结果覆盖其他选项的操作结果时,最后一个选项起作用;如果选项重复,则顺序处理。
允许操作数的顺序影响程序行为,但需要作文档说明。
读写指定文件的程序应该将单个参数 ‘-’ 作为有意义的标准输入或输出来对待。
二:getopt
#include <unistd.h> int getopt(int argc, char *const argv[], const char *optstring); extern char *optarg;</span></span> extern int opterr, optind, optopt;
argc和argv分别是调用main函数时传递的参数。在argv中,以 ‘-’ 开头的元素就是选项。该参数中除了开头的 ‘-’ 以外的字母就是选项字符。如果重复调用getopt函数,则该函数会持续的返回每个选项中的选项字符。
optstring是包含合法选项字符的字符串。该字符串中,每一个字符都可以是合法的选项字符。
如果字符后面跟了一个冒号’:’ ,则说明这个选项字符需要一个参数,这个参数要么紧跟在选项字符的后面(同一个命令行参数),要么就是下一个命令行参数。通过指针optarg指向这个参数。
如果字符后面跟了两个冒号’::’ ,则说明该选项字符后面跟可选参数,而且这个可选参数必须紧跟在选项字符的后面(同一个命令行参数,比如-oarg)。如果有参数的话,通过指针optarg指向这个参数,否则,optarg置为NULL。
在GNU的扩展中,如果optstring字符串中包含“W;”(’W’加上一个分号),则 -W foo会被当做长参数 --foo来处理。
变量optind是搜索选项的索引。初始值为1,每次调用getopt函数,optind就会置为下次要开始搜索的参数索引。
getopt函数返回每次找到的选项字符,如果没有选项了,则返回-1。并且,optind置为指向第一个非选项参数的索引。默认情况下,getopt函数在扫描的过程中会重新排序argv,这样,最终所有非选项参数都会排在argv参数表的后面。
示例代码如下:
int main(int argc, char * argv[]) { int aflag=0, bflag=0, cflag=0; int i = 0; int ch; printf("begin: optind:%d,opterr:%d ", optind, opterr); for(i = 0; i < argc; i++) { printf("argc[%d]: %s ", i,argv[i]); } printf(" -------------------------- "); while ((ch = getopt(argc, argv,"ab::c:de::")) != -1) { switch (ch) { case 'a': { printf("HAVE option:-a "); break; } case 'b': { printf("HAVE option:-b "); printf("The argument of -bis %s ", optarg); break; } case 'c': { printf("HAVE option:-c "); printf("The argument of -cis %s ", optarg); break; } case 'd': { printf("HAVE option:-d "); break; } case 'e': { printf("HAVE option:-e "); printf("The argument of -eis %s ", optarg); break; } case ':': { printf("option %c missingarguments ", (char)optopt); break; } case '?': { printf("Unknown option:%c ",(char)optopt); break; } default: { printf("the option is%c--->%d, the argu is %s ", ch, ch, optarg); break; } } printf("optind: %d ",optind); } printf("---------------------------- "); printf("end:optind=%d,argv[%d]=%s ",optind,optind,argv[optind]); for(i = 0; i < argc; i++) { printf("argc[%d]: %s ", i,argv[i]); } printf(" "); }
上面的程序,optstring为“ab::c:de::”,说明选项a,d不需要参数,选项c必须有参数,选项b,e有可选参数。如果输入:
./1 -a f1 -b f2 -c f3 -d f4 -e f5
则输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c argc[6]: f3 argc[7]: -d argc[8]: f4 argc[9]: -e argc[10]: f5
--------------------------
HAVE option: -a
optind: 2
HAVE option: -b
The argument of -b is (null)
optind: 4
HAVE option: -c
The argument of -c is f3
optind: 7
HAVE option: -d
optind: 8
HAVE option: -e
The argument of -e is (null)
optind: 10
----------------------------
end:optind=7, argv[7]=f1
argc[0]: ./1 argc[1]:-a argc[2]: -b argc[3]: -c argc[4]: f3 argc[5]: -d argc[6]: -e argc[7]: f1 argc[8]: f2 argc[9]: f4 argc[10]: f5
如果optstring的第一个字符是’+’(或者设置了环境变量POSIXLY_CORRECT),则在扫描命令行参数的过程中,一旦碰到非选项参数就会停止。
比如上面的程序,如果optstring为” +ab::c:de::”,如果输入:
./1 -a f1 -b f2 -c f3 -d f4 -e f5
输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c argc[6]: f3 argc[7]: -d argc[8]: f4 argc[9]: -e argc[10]: f5
--------------------------
HAVE option: -a
optind: 2
----------------------------
end: optind=2, argv[2]=f1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c argc[6]: f3 argc[7]: -d argc[8]: f4 argc[9]: -e argc[10]: f5
如果optstring的第一个字符是’-’,则所有的非选项参数都会被当做数字1的选项的参数。 比如上面的程序,如果optstring为” -ab::c:de::”,如果输入:
./1 -a f1 -b f2 -c f3 -d f4 -e f5
输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c argc[6]: f3 argc[7]: -d argc[8]: f4 argc[9]: -e argc[10]: f5
--------------------------
HAVE option: -a
optind: 2
the option is --->1, the argu is f1
optind: 3
HAVE option: -b
The argument of -b is (null)
optind: 4
the option is --->1, the argu is f2
optind: 5
HAVE option: -c
The argument of -c is f3
optind: 7
HAVE option: -d
optind: 8
the option is --->1, the argu is f4
optind: 9
HAVE option: -e
The argument of -e is (null)
optind: 10
the option is --->1, the argu is f5
optind: 11
----------------------------
end: optind=11,argv[11]=(null)
argc[0]: ./1 argc[1]: -a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c argc[6]: f3 argc[7]: -d argc[8]: f4 argc[9]: -e argc[10]: f5
如果在命令行参数中有’--’,不管optstring是什么,扫描都会停止。
比如上面的程序,如果optstring为” ab::c:de::”如果输入:
./getopt -a f1 -b f2 -- -c f3 -d f4 -e f5
输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -- argc[6]: -c argc[7]: f3 argc[8]: -d argc[9]: f4 argc[10]: -e argc[11]: f5
--------------------------
HAVE option: -a
optind: 2
HAVE option: -b
The argument of -b is (null)
optind: 4
----------------------------
end: optind=4,argv[4]=f1
argc[0]: ./1 argc[1]:-a argc[2]: -b argc[3]: -- argc[4]: f1 argc[5]: f2 argc[6]: -c argc[7]: f3 argc[8]: -d argc[9]: f4 argc[10]: -e argc[11]: f5
如果命令行参数中,有optstring中没有的字符,则将会打印错误信息,并且将这个字符存储到optopt中,返回 ’?’。如果不想打印错误信息,则可以设置变量opterr为0.
比如上面的程序,如果optstring为"ab::c:de::”,
如果输入:./getopt -a f1 -b f2 -t -c f3
则输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -t argc[6]: -c argc[7]: f3
--------------------------
HAVE option: -a
optind: 2
HAVE option: -b
The argument of -b is (null)
optind: 4
./1: invalid option -- t
Unknown option: t
optind: 6
HAVE option: -c
The argument of -c is f3
optind: 8
----------------------------
end: optind=6,argv[6]=f1
argc[0]: ./1 argc[1]: -a argc[2]: -b argc[3]: -t argc[4]: -c argc[5]: f3 argc[6]: f1 argc[7]: f2
如果某个选项字符后应该跟参数,但是命令行参数中没有,则根据optstring中的首字符的不同返回不同的值,如果optstring首字符不是’:’ ,则返回 ’?’ ,打印错误信息,并且设置optopt为该选项字符。如果optstring首字符是’:’ (或者首字符是’+’ 、’-’ ,且第二个字符是’:’ ),则返回’:’ ,并且设置optopt为该选项字符,但是不在打印错误信息。
比如上面的程序,如果optstring为“ab::c:de::”,如果输入:
./getopt -a f1 -b f2 -c
则输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c
--------------------------
HAVE option: -a
optind: 2
HAVE option: -b
The argument of -b is (null)
optind: 4
./1: option requires an argument -- c
Unknown option: c
optind: 6
----------------------------
end: optind=4,argv[4]=f1
argc[0]: ./1 argc[1]:-a argc[2]: -b argc[3]: -c argc[4]: f1 argc[5]: f2
如果optstring为“:ab::c:de::”,如果输入:
./getopt -a f1 -b f2 -c
则输出:
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:-a argc[2]: f1 argc[3]: -b argc[4]: f2 argc[5]: -c
--------------------------
HAVE option: -a
optind: 2
HAVE option: -b
The argument of -b is (null)
optind: 4
option c missing arguments
optind: 6
----------------------------
end: optind=4,argv[4]=f1
argc[0]: ./1 argc[1]:-a argc[2]: -b argc[3]: -c argc[4]: f1 argc[5]: f2
三:getopt_long和 getopt_long_only
#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不能处理长选项,也就是’-- ‘开头的选项,处理长选项需要用getopt_long或者getopt_long_only.
getopt_long具有getopt函数的功能,而且还可以处理’--’开头的长选项,一般来说,长选项都有对应的短选项。optstring的意义仅限于短选项,这与getopt中是一致的。如果仅需要该函数处理长选项,则可以将optstring置为空字符串””(不是NULL)。
长选项也可以带参数,比如:--arg=param或 --arg param。
函数参数longopts指向一个数组,该数组元素为structoption,如下:
struct option {
const char*name;
int has_arg;
int *flag;
int val;
};
其中:
name是长参数的名字。
has_arg指明了该长参数是否需要参数,有三种取值,no_argument (or 0)表明不需要参数,required_argument (or 1)表明需要参数,optional_argument(or 2)表明有可选参数。
flag指明了函数返回值,如果flag为NULL,则函数返回val(一般将val设置为长参数对应的短参数)。如果flag不是NULL,则返回0,而且如果相应的长参数找到了,则flag指向的整数被置为val。
该数组的最后一个元素的结构体,成员都要设置为0。
如果longindex不是NULL, 则长参数找到时,它指向的整数被置为相应的longopts数组索引。
上面的getopt程序,如果换成相应的getopt_long调用的话,函数依然工作正常,而且返回打印与getopt一样。说明getopt_long既可以处理短选项,也能处理长选项。
例子如下:
#include <unistd.h> #include <stdio.h> #include <getopt.h> int main(int argc, char * argv[]) { int aflag=0, bflag=0,cflag=0; int i = 0; int ch; int optionindex = -1; struct option long_options[] ={ {"add", required_argument, NULL, 'a' }, {"delete", required_argument, NULL, 'd' }, {"verbose",no_argument, NULL, 'v' }, {"create", required_argument, NULL, 'c'}, {"file", required_argument, NULL, 'f' }, {0, 0, 0, 0 } }; printf("begin: optind:%d,opterr:%d ",optind,opterr); for(i = 0; i <argc; i++) { printf("argc[%d]:%s ", i, argv[i]); } printf(" -------------------------- "); while ((ch =getopt_long(argc, argv, "a:d:vc:f:",long_options, &optionindex)) != -1) { printf("return value is %c ", ch); printf("optionindex is %d ", optionindex); if(optarg) { printf("%c option arguis %s ", ch, optarg); } if(optionindex != -1) { printf("long arg nameis %s ", long_options[optionindex].name); } printf("optind:%d ", optind); } printf("---------------------------- "); printf("end:optind=%d,argv[%d]=%s ",optind,optind,argv[optind]); for(i = 0; i <argc; i++) { printf("argc[%d]:%s ", i, argv[i]); } printf(" "); }
如果输入:
./1 --add
输出:
begin: optind:1,opterr:1
argc[0]: ./ getoptlong argc[1]: --add
--------------------------
./1: option '--add' requires an argument
return value is ?
optionindex is -1
optind: 2
----------------------------
end: optind=2,argv[2]=(null)
argc[0]: ./1 argc[1]:--add
如果输入:
./1 --add=a1 f0 --file f1 -a a2 -f f2
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:--add=a1 argc[2]: f0 argc[3]: --file argc[4]:f1 argc[5]: -a argc[6]: a2 argc[7]: -f argc[8]:f2
--------------------------
return value is a
optionindex is 0
a option argu is a1
long arg name is add
optind: 2
return value is f
optionindex is 4
f option argu is f1
long arg name is file
optind: 5
return value is a
optionindex is 4
a option argu is a2
long arg name is file
optind: 7
return value is f
optionindex is 4
f option argu is f2
long arg name is file
optind: 9
----------------------------
end: optind=8,argv[8]=f0
argc[0]: ./1 argc[1]:--add=a1 argc[2]: --file argc[3]: f1 argc[4]:-a argc[5]: a2 argc[6]: -f argc[7]: f2 argc[8]: f0
可见,在处理既有短选项,又有长选项的情况下,最好每次都把optionindex置为无效值,比如-1,这样就可以区分长短选项了。
如果输入:./1 --add a1 --cao f0 --file f1 -a a2 -f f2
begin: optind:1,opterr:1
argc[0]: ./1 argc[1]:--add argc[2]: a1 argc[3]: --cao argc[4]:f0 argc[5]: --file argc[6]: f1 argc[7]: -a argc[8]: a2 argc[9]: -f argc[10]: f2
--------------------------
return value is a
optionindex is 0
a option argu is a1
long arg name is add
optind: 3
./1: unrecognized option '--cao'
return value is ?
optionindex is 0
long arg name is add
optind: 4
return value is f
optionindex is 4
f option argu is f1
long arg name is file
optind: 7
return value is a
optionindex is 4
a option argu is a2
long arg name is file
optind: 9
return value is f
optionindex is 4
f option argu is f2
long arg name is file
optind: 11
----------------------------
end: optind=10,argv[10]=f0
argc[0]: ./1 argc[1]:--add argc[2]: a1 argc[3]: --cao argc[4]:--file argc[5]:f1 argc[6]: -a argc[7]: a2 argc[8]: -f argc[9]: f2 argc[10]:f0
getopt_long_only函数与getopt_long函数类似,只不过把’-’后的选项依然当做长选项,如果一个以’-’开头的选项没有在option数组中找到匹配的选项,但是在optstring中有匹配的短选项,则当成短选项处理。
四:实例
下面的例子来自于开源软件WebBench,一个网站压力测试工具,代码如下:
/* globals */ int http10=1; /* 0 - http/0.9, 1 - http/1.0, 2 - http/1.1 */ #define METHOD_GET 0 #define METHOD_HEAD 1 #define METHOD_OPTIONS 2 #define METHOD_TRACE 3 #define PROGRAM_VERSION "1.5" int method=METHOD_GET; int clients=1; int force=0; int force_reload=0; int proxyport=80; char *proxyhost=NULL; int benchtime=30; static const struct option long_options[]= { {"force",no_argument,&force,1}, {"reload",no_argument,&force_reload,1}, {"time",required_argument,NULL,'t'}, {"help",no_argument,NULL,'?'}, {"http09",no_argument,NULL,'9'}, {"http10",no_argument,NULL,'1'}, {"http11",no_argument,NULL,'2'}, {"get",no_argument,&method,METHOD_GET}, {"head",no_argument,&method,METHOD_HEAD}, {"options",no_argument,&method,METHOD_OPTIONS}, {"trace",no_argument,&method,METHOD_TRACE}, {"version",no_argument,NULL,'V'}, {"proxy",required_argument,NULL,'p'}, {"clients",required_argument,NULL,'c'}, {NULL,0,NULL,0} }; static void usage(void) { fprintf(stderr, "webbench [option]... URL " " -f|--force Don't wait for reply from server. " " -r|--reload Send reload request - Pragma: no-cache. " " -t|--time <sec> Run benchmark for <sec> seconds. Default 30. "</span> " -p|--proxy <server:port> Use proxy server for request. " " -c|--clients <n> Run <n> HTTP clients at once. Default one. " " -9|--http09 Use HTTP/0.9 style requests. " " -1|--http10 Use HTTP/1.0 protocol. " " -2|--http11 Use HTTP/1.1 protocol. " " --get Use GET request method. " " --head Use HEAD request method. " " --options Use OPTIONS request method. " " --trace Use TRACE request method. " " -?|-h|--help This information. " " -V|--version Display program version. " ); }; void printval() { printf("force is %d ", force); printf("force_reload is %d ", force_reload); printf("benchtime is %d ", benchtime); printf("proxyhost:proxyport is %s:%d ", proxyhost, proxyport); printf("clients is %d ", clients); printf("http10 is %d ", http10); printf("method is %d ", method); } int main(int argc, char *argv[]) { int opt=0; int options_index=0; char *tmp=NULL; if(argc==1) { usage(); return 2; } while((opt=getopt_long(argc,argv,"912Vfrt:p:c:?h",long_options, &options_index))!=EOF) { printf("opt is %d(%c) ", opt, opt); switch(opt) { case 0 : break; case 'f': force=1;break; case 'r': force_reload=1;break; case '9': http10=0;break; case '1': http10=1;break; case '2': http10=2;break; case 'V': printf(PROGRAM_VERSION" ");exit(0); case 't': benchtime=atoi(optarg);break; case 'p': /* proxy server parsing server:port */ tmp=strrchr(optarg,':'); proxyhost=optarg; if(tmp==NULL) { break; } if(tmp==optarg) { fprintf(stderr,"Error in option --proxy %s: Missing hostname. ",optarg); return 2; } if(tmp==optarg+strlen(optarg)-1) { fprintf(stderr,"Error in option --proxy %s Port number is missing. ",optarg); return 2; } *tmp=' '; proxyport=atoi(tmp+1);break; case ':': case 'h': case '?': usage();return 2;break; case 'c': clients=atoi(optarg);break; } } if(optind==argc) { fprintf(stderr,"webbench: Missing URL! "); usage(); return 2; } printval(); printf("argv[optind] is %s ", argv[optind]); }