問題引入----命令列引數及解析

在使用linux時,與windows最大的不同應該就是經常使用命令列來解決大多數問題.比如下面這樣的:

而顯然我們知道C語言程式的入口是mian函式,即是從main函式開始執行,而main函式的原型是:

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

程式的 main 函式可以通過引數 argc 和 argv 來訪問程式的引數列表(如果你不需要訪問引數列表,你可以直接忽略它們)。第一個引數 argc 指示了命令列中引數的數量(這個值包含命令本身,如果後面沒有引數,則值為1)。

第二個引數 argv 是一個字串陣列。其各個成員分別指向各個引數,即argv[0]指向命令本身,具體見下圖.陣列的大小由 argc 指定,而陣列的元素則為各個命令列引數
的元素,表示以 NULL 結束的字串形式。
使用命令列引數的過程因此被簡化為檢查 argc 和 argv 的內容。如果你對程式自己的名
字沒有興趣,記得跳過第一個引數.

下面的程式演示使用 argc 和 argv 的方法:

/*************************************************************************
	> File Name: arglist.c
	> Author: suool
	> Mail: 
 
[email protected] 
	> Created Time: 2014年07月24日 星期四 16時35分40秒
 ************************************************************************/   
#include <stdio.h>
int main (int argc, char* argv[])
{
    printf ("The name of this program is '%s'.\n", argv[0]);
    printf ("This program was invoked with %d arguments.\n", argc - 1);
    /* 指定了命令列引數麼?*/
    if (argc > 1) 
    {
        /* 有,那麼輸出這些引數。*/
        int i;
        printf ("The arguments are:\n");
        for (i = 1; i < argc; ++i)
        printf (" %s\n", argv[i]);
    }
    return 0;
}
 

幾乎所有 GNU/Linux 程式都遵循一些處理命令列引數的習慣。程式期望得到的引數可以被分為兩種: 選項( options ,又作 flags ) 和其它(非選項)引數。選項用於調整程式的
行為方式,而其它引數提供了程式的輸入(例如,輸入檔案的名字)。

選項通常有兩種格式:
· 短選項( short options ) 由一個短槓(hyphen)和一個字元(通常為一個大寫或小寫字母)組成。短選項可以方便使用者的輸入。
· 長選項( long options ) 由兩個短槓開始,之後跟隨一個由大小寫字母和短槓組成的名字。長選項方便記憶和閱讀(尤其在指令碼中使用的時候)
通常程式會為它支援的選項提供長短兩種形式,前者為便於使用者理解,而後者為簡化輸入。例如,多數程式都能理解 –h 和 –help 這兩個引數,並以相同方法進行處理。一般而
言,當從 shell 中呼叫一個程式的時候,程式名後緊跟的就是選項引數。如果一些選項需要一個引數,則引數緊跟在選項之後。例如,許多程式將選項 –output foo 解釋為“將輸出文
件設定為 foo”。

在選項之後可能出現其它命令列引數,通常用於指明輸入檔案或輸入資料。例如,命令列 ls –s / 列舉根目錄的內容。選項 –s 改變了 ls 的預設行為方式,通知它為每個條目顯示檔案大小(以 KB 為單位)。引數 / 向 ls 指明瞭被列舉的目錄。選項 –size 與–s 選項具有相同的含義,因此呼叫 ls –size / 會得到完全相同的結果。

這時候我們就會發現一個問題,那就是如果引數比較多,而且要有一定的順序怎麼辦?如何解析命令列的引數,判斷引數的位置和正確與否呢?

這就是這次要講的東西.

命令列引數識別

簡單命令列處理getopt獲取並解析命令列引數

int getopt( int argc, char *const argv[], const char *optstring );

給定了命令引數的數量 (argc)、指向這些引數的陣列 (argv) 和選項字串 (optstring) 後，getopt() 將返回第一個選項，並設定一些全域性變數。使用相同的引數再次呼叫該函式時，它將返回下一個選項，並設定相應的全域性變數。如果不再有識別到的選項，將返回 -1，此任務就完成了。

getopt() 所設定的全域性變數包括：

• optarg——指向當前選項引數（如果有）的指標。
• optind——再次呼叫 getopt() 時的下一個 argv 指標的索引。
• optopt——最後一個已知選項。

對於每個選項，選項字串 (optstring) 中都包含一個對應的字元。具有引數的選項後面跟有一個 : 字元。

其中optstrings 可以使下面的元素:

• 1.單個字元,表示選項
• 2.單個字元後面一個冒號:表示該選項後面必須跟一個引數.引數緊跟在選項後面或者以空格隔開,該引數的指標賦給optarg.
• 3.單個字元後面跟兩個冒號:: ,表示該選項後面可以跟一個引數.引數必須緊跟在選項後面不能以空格隔開.該引數一樣賦給optarg.

如,如果opstrings = "ab:c::d::",命令列引數如下:

./getopt -a -b host -chello -d world.

可以重複呼叫 getopt()，直到其返回 -1 為止；任何剩下的命令列引數通常視為檔名或程式相應的其他內容。

下面我們看兩個示例程式.

1.有一個程式有三個選項a,b,c,其中b必須帶引數,而c可以帶可以不帶.請寫一個程式使用getopt來解析這個程式的命令列引數.

下面是程式碼示例:

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

int main(int argc, char **argv)
{
    int result;
    opterr = 0;             // 不輸出錯誤資訊
    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);    // 列印最後有可能出錯的位置

    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;
}

第一次命令列引數為:

./getopt_exp -a host -b hello -cworld -d

其他的請自己嘗試吧,可以嘗試一下沒有錯誤的,或者更加錯誤的,

2.一個假想的 doc2html 程式的命令列處理。該 doc2html 程式將某種型別的文件轉換為 HTML，具體由使用者指定的命令列選項控制。它支援以下選項：

• -I——不建立關鍵字索引。
• -l lang——轉換為使用語言程式碼 lang 指定的語言。
• -o outfile.html——將經過轉換的文件寫入到 outfile.html，而不是列印到標準輸出。
• -v——進行轉換時提供詳細資訊；可以多次指定，以提高診斷級別。
• 將使用其他檔名稱來作為輸入文件。

還將支援 -h 和 -?，以列印幫助訊息來提示各個選項的用途。

/* getopt_demo - demonstrate getopt() usage
 *
 * This application shows you one way of using getopt() to
 * process your command-line options and store them in a
 * global structure for easy access.
 */

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

/* doc2html supports the following command-line arguments:
 * 
 * -I - don't produce a keyword index
 * -l lang - produce output in the specified language, lang
 * -o outfile - write output to outfile instead of stdout
 * -v - be verbose; more -v means more diagnostics
 * additional file names are used as input files
 * 
 * The optString global tells getopt() which options we
 * support, and which options have arguments.
 */
struct globalArgs_t {
	int noIndex;				/* -I option */
	char *langCode;				/* -l option */
	const char *outFileName;	/* -o option */
	FILE *outFile;
	int verbosity;				/* -v option */
	char **inputFiles;			/* input files */
	int numInputFiles;			/* # of input files */
} globalArgs;

static const char *optString = "Il:o:vh?";

/* Display program usage, and exit.
 */
void display_usage( void )
{
	puts( "doc2html - convert documents to HTML" );
	/* ... */
	exit( EXIT_FAILURE );
}

/* Convert the input files to HTML, governed by globalArgs.
 */
void convert_document( void )
{
	/* ... */
}

int main( int argc, char *argv[] )
{
	int opt = 0;
	
	/* Initialize globalArgs before we get to work. */
	globalArgs.noIndex = 0;		/* false */
	globalArgs.langCode = NULL;
	globalArgs.outFileName = NULL;
	globalArgs.outFile = NULL;
	globalArgs.verbosity = 0;
	globalArgs.inputFiles = NULL;
	globalArgs.numInputFiles = 0;
	
	/* Process the arguments with getopt(), then 
	 * populate globalArgs. 
	 */
	opt = getopt( argc, argv, optString );
	while( opt != -1 ) {
		switch( opt ) {
			case 'I':
				globalArgs.noIndex = 1;	/* true */
				break;
				
			case 'l':
				globalArgs.langCode = optarg;
				break;
				
			case 'o':
				/* This generates an "assignment from
				 * incompatible pointer type" warning that
				 * you can safely ignore.
				 */
				globalArgs.outFileName = optarg;
				break;
				
			case 'v':
				globalArgs.verbosity++;
				break;
				
			case 'h':	/* fall-through is intentional */
			case '?':
				display_usage();
				break;
				
			default:
				/* You won't actually get here. */
				break;
		}
		
		opt = getopt( argc, argv, optString );
	}
	
	globalArgs.inputFiles = argv + optind;
	globalArgs.numInputFiles = argc - optind;

	convert_document();
	
	return EXIT_SUCCESS;
}

標頭檔案:

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

建立的 globalArgs 結構，用於以合理的方式儲存命令列選項。由於這是個全域性變數，程式中任何位置的程式碼都可以訪問這些變數，以確定是否建立關鍵字索引、生成何種語言等等事項。最好讓 main() 函式外的程式碼將此結構視為一個常量、只讀儲存區，因為程式的任何部分都可以依賴於其內容。每個命令列選擇都有一個對應的選項，而其他變數用於儲存輸出檔名、指向輸入檔案列表的指標和輸入檔案數量。

struct globalArgs_t 
{
    int noIndex;                /* -I option */
    char *langCode;             /* -l option */
    const char *outFileName;    /* -o option */
    FILE *outFile;
    int verbosity;              /* -v option */
    char **inputFiles;          /* input files */
    int numInputFiles;          /* # of input files */
} globalArgs;

static const char *optString = "Il:o:vh?";

選項字串 optString 告知 getopt() 可以處理哪個選項以及哪個選項需要引數。如果在處期間遇到了其他選項，getopt() 將顯示一個錯誤訊息，程式將在顯示了使用方法訊息後退出。

下面的程式碼段包含一些從 main() 引用的用法訊息函式和文件轉換函式的小存根。可以對這些存根進行自由更改，以用於更為有用的目的。

void display_usage( void )
{
    puts( "doc2html - convert documents to HTML" );
    /* ... */
    exit( EXIT_FAILURE );
}

void convert_document( void )
{
    /* ... */
}

int main( int argc, char *argv[] )
{
    int opt = 0;
    
    /* Initialize globalArgs before we get to work. */
    globalArgs.noIndex = 0;     /* false */
    globalArgs.langCode = NULL;
    globalArgs.outFileName = NULL;
    globalArgs.outFile = NULL;
    globalArgs.verbosity = 0;
    globalArgs.inputFiles = NULL;
    globalArgs.numInputFiles = 0;

opt = getopt( argc, argv, optString );
    while( opt != -1 ) {
        switch( opt ) {
            case 'I':
                globalArgs.noIndex = 1; /* true */
                break;
                
            case 'l':
                globalArgs.langCode = optarg;
                break;
                
            case 'o':
                globalArgs.outFileName = optarg;
                break;
                
            case 'v':
                globalArgs.verbosity++;
                break;
                
            case 'h':   /* fall-through is intentional */
            case '?':
                display_usage();
                break;
                
            default:
                /* You won't actually get here. */
                break;
        }
        
        opt = getopt( argc, argv, optString );
    }
    
    globalArgs.inputFiles = argv + optind;
    globalArgs.numInputFiles = argc - optind;

既然已經完成了引數和選項的收集工作，接下來就可以執行程式所設計的任何功能（在本例中是進行文件轉換），然後退出

convert_document();
    return EXIT_SUCCESS;
}

複雜的命令列處理getopt獲取並解析命令列引數

int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *indexptr)

結構體宣告如下:

struct option 
{
   # if (defined __STDC__ && __STDC__) || defined __cplusplus
    const char *name;
   # else
    char * name;
   # endif
    int has_arg;   // 該引數是否需要帶引數
    int *flag;     // 標誌
    int val;       // 返回引數值
};

name 成員是指向長選項名稱（帶兩個短橫線）的指標。has_arg 成員設定為 no_argument、optional_argument, 或 required_argument（均在 getopt.h 中定義）之一，以指示選項是否具有引數。如果 flag 成員未設定為 NULL，在處理期間遇到此選項時，會使用 val 成員的值填充它所指向的 int 值。如果 flag 成員為 NULL，在 getopt_long() 遇到此選項時，將返回 val 中的值；通過將 val 設定為選項的 short 引數，可以在不新增任何其他程式碼的情況下使用 getopt_long()——處理 while loop 和 switch 的現有 getopt() 將自動處理此選項。
這已經變得更為靈活了，因為各個選項現在可以具有可選引數了。更重要的是，僅需要進行很少的工作，就可以方便地放入現有程式碼中。

1.在使用此函式處理一個引數時,全域性變數optarg指向下一個要處理的變數,並返回struct option的第四個成員.一般情況下,如果struct option的第三個引數位置設定null,第四個引數一般設定為該長選項對應的短選項的字元值,即返回相應的短選項字元.

2.如果解析完最後一個成員將返回1

3.如果getlongopt遇到一個錯誤的選項,他將列印一個錯誤訊息並返回'?'

4.當get_long解析一個長選項並且發現後面沒有引數則返回':',表示缺少引數.

應用舉例.

1.一個程式的所需的短選項和長選項如下:

短選項             長選項                         作用
-h                      --help                          輸出程式的命令列引數說明並退出
-o filename     --output filename     給定輸出檔名
-v                    --version                      顯示程式當前的版本後退出 

1,一個字串,包含所需要的短選項字元,如果選項後面有引數,字元後面加一個冒號:.本例中,這個字串應該是:"ho:v",因為-o後面有引數filename,所以要加冒號.

2,一個包含長選項的結構體陣列.每個結構體四個域.

第一個域為長選項字串.第二個域為表示相應的選項是否需要引數,只能為0,沒有引數,1,必須要,2,可以要.第三個域決定返回結果型別(即是flags,建議設null),如果為null,則此函式將返回後一個域(即val,一般設定為當前獲取的短引數值),否則,此函式將返回0.第四個域為函式的返回值,一般設定為對用的短選項的ascii值.

另外,結構體陣列的最後一個元素全部設定為null和0,表示結束.

結構體可以如下所示:

    // 描述了長選項的 struct option 陣列
    const struct option long_options[] = 
    {
        { "help", 0, NULL, 'h' },
        { "output", 1, NULL, 'o' },
        { "version", 0, NULL, 'v' },
        { NULL, 0, NULL, 0 }                   // 陣列末要求這樣一個元素。
    };

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

const char* program_name;			//the filename

void print_usage (FILE* stream, int exit_code)	//output message
{
    fprintf (stream, "Usage: %s options [ inputfile ... ]\n", program_name);
    fprintf (
        stream, " -h --help .\n"
        " -o --output filename.\n"
        " -v --version.\n"
            );
    exit (exit_code);
}

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

    const char* const short_options = "ho:v";    // list of short options
    const struct option long_options[] =         // structure of long options
    {
        { "help", 0, NULL, 'h' },		//no arg 	
        { "output",1, NULL, 'o' },		//must have a arg
        { "version",0, NULL, 'v' },
        { NULL, 0, NULL, 0}             // necessary ele
    };
    
    const char* output_filename = NULL;
    program_name = argv[0];
    
    do
    {
        next_option = getopt_long (argc, argv, short_options, long_options, NULL);
        switch (next_option)
        {
            case 'h':     		//-h or --help, print the info of help 
            print_usage (stdout, 0);
            break;
            case 'o':     		// -o or --output    print the content of the file
            output_filename = optarg;
            execl("/bin/cat","cat",output_filename,NULL);
            break;

            case 'v':   		//-v or    --version
            printf("the version is v1.0\n");
            break;
            case ':':   
            break;
            case '?':  
            print_usage (stderr, 1); // unknow
            break;
            default:                 // else
            print_usage (stderr, 1);
            break;
        }
    }while (next_option !=-1);
    return 0;
}

1.命令列:

./getopt_long_exp -help

./getopt_long_exp -v

./getopt_long_exp --version

./getopt_long_exp --output getopt_long_exp.c

2.對上面的轉換程式的修改:

getopt_long() 函式在 getopt.h 標頭檔案（而非 unistd.h）中，因此將需要將該標頭檔案包含進來。我還包含了 string.h，因為將稍後使用 strcmp() 來幫助確定處理的是哪個長引數。

其他標頭檔案

#include <getopt.h>
#include <string.h>

已經為 --randomize 選項在 globalArgs 中添加了一個標誌，並建立了 longOpts 陣列來儲存關於此程式支援的長選項的資訊。除了 --randomize 外，所有的引數都與現有短選項對應（例如，--no-index 等同於 -I）。通過在選項結構中包含其短選項等效項，可以在不向程式新增任何其他程式碼的情況下處理等效的長選項。

 擴充套件後的引數

opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
    while( opt != -1 ) {
        switch( opt ) {
            case 'I':
                globalArgs.noIndex = 1; /* true */
                break;
                
            case 'l':
                globalArgs.langCode = optarg;
                break;
                
            case 'o':
                globalArgs.outFileName = optarg;
                break;
                
            case 'v':
                globalArgs.verbosity++;
                break;
                
            case 'h':   /* fall-through is intentional */
            case '?':
                display_usage();
                break;

            case 0:     /* long option without a short arg */
                if( strcmp( "randomize", longOpts[longIndex].name ) == 0 ) {
                    globalArgs.randomized = 1;
                }
                break;
                
            default:
                /* You won't actually get here. */
                break;
        }
        
        opt = getopt_long( argc, argv, optString, longOpts, amp;longIndex );
    }

將 getopt() 呼叫更改為了 getopt_long()，除了 getopt() 的引數外，它還接受 longOpts 陣列和 int 指標 (longIndex)。當getopt_long() 返回 0 時，longIndex 所指向的整數將設定為當前找到的長選項的索引。

新的經改進的選項處理

opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
    while( opt != -1 ) {
        switch( opt ) {
            case 'I':
                globalArgs.noIndex = 1; /* true */
                break;
                
            case 'l':
                globalArgs.langCode = optarg;
                break;
                
            case 'o':
                globalArgs.outFileName = optarg;
                break;
                
            case 'v':
                globalArgs.verbosity++;
                break;
                
            case 'h':   /* fall-through is intentional */
            case '?':
                display_usage();
                break;

            case 0:     /* long option without a short arg */
                if( strcmp( "randomize", longOpts[longIndex].name ) == 0 ) {
                    globalArgs.randomized = 1;
                }
                break;
                
            default:
                /* You won't actually get here. */
                break;
        }
        
        opt = getopt_long( argc, argv, optString, longOpts, amp;longIndex );
    }

我還添加了 0 的 case，以便處理任何不與現有短選項匹配的長選項。在此例中，只有一個長選項，但程式碼仍然使用 strcmp() 來確保它是預期的那個選項。

這樣就全部搞定了；程式現在支援更為詳細（對臨時使用者更加友好）的長選項。

Summarize

UNIX 使用者始終依賴於命令列引數來修改程式的行為，特別是那些設計作為小工具集合 （UNIX 外殼環境）的一部分使用的實用工具更是如此。程式需要能夠快速處理各個選項和引數，且要求不會浪費開發人員的太多時間。畢竟，幾乎沒有程式設計為僅處理命令列引數，開發人員更應該將精力放在程式所實際進行的工作上。

getopt() 函式是一個標準庫呼叫，可允許使用直接的 while/switch 語句方便地逐個處理命令列引數和檢測選項（帶或不帶附加的引數）。與其類似的 getopt_long() 允許在幾乎不進行額外工作的情況下處理更具描述性的長選項，這非常受開發人員的歡迎。

既然已經知道了如何方便地處理命令列選項，現在就可以集中精力改程序序的命令列，可以新增長選項支援，或新增之前由於不想向程式新增額外的命令列選項處理而擱置的任何其他選項。

不要忘記在某處記錄所有的選項和引數，並提供某種型別的內建幫助函式來為健忘的使用者提供幫助。

reference:

linux高階程式設計 楊宗德

http://www.ibm.com/developerworks/cn/aix/library/au-unix-getopt.html

轉載請註明出處.http://blog.csdn.net/suool/article/details/38089001

1. ANSI C檔案I/O管理

2. POSIX檔案以及目錄管理

3. Linux下的一些編碼特性和規範