Linux 程式設計學習筆記----命令列引數處理
問題引入----命令列引數及解析
在使用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獲取並解析命令列引數
getopt()
函式位於
unistd.h 系統標頭檔案中,其原型如示:
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.
這個命令列引數中,去掉短引數的-,其中a,b,c就是選項,host是b的引數,hello是c的引數,但是world不是d的引數,因為有空格隔開.
可以重複呼叫 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 )
{
/* ... */
}
最後,下面的程式碼段中所示,在
main()
函式中使用此結構。和優秀的開發人員一樣,需要首先初始化 globalArgs
結構,然後才開始處理命令列引數。在程式中,可以藉此設定在一定情況下合理的預設值,以便在以後有更合適的預設值時更方便地對其進行調整
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;
下面的程式碼段中的 while
迴圈和 switch
語句是用於本程式的命令列處理的程式碼部分。只要 getopt()
發現選項,switch
語句將確定找到的是哪個選項,將能在 globalArgs
結構中看到具體情況。當 getopt()
最終返回 -1
時,就完成了選項處理過程,剩下的都是輸入檔案了。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;
}
當然上面的使用optget是簡單的命令列處理,如果你要進行長引數的或者稍微複雜的處理,那就繼續往下看吧.getopt_long()
是同時支援長選項和短選項的getopt()
版本。複雜的命令列處理getopt獲取並解析命令列引數
getlongopt的原型是:int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *indexptr)
第一個引數是當前傳遞進來的引數個數,第二個引數是當前傳遞進來的引數列表,第三個引數是當前程序所有可支援的短引數的字串,第四個引數是struct option,表示所有的長引數的對應關係.
結構體宣告如下:
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
The Next:
1. ANSI C檔案I/O管理
2. POSIX檔案以及目錄管理
3. Linux下的一些編碼特性和規範
4. Python 兩大網路框架 5. network programming.相關推薦
Linux 程式設計學習筆記----命令列引數處理
問題引入----命令列引數及解析 在使用linux時,與windows最大的不同應該就是經常使用命令列來解決大多數問題.比如下面這樣的: 而顯然我們知道C語言程式的入口是mian函式,即是從main函式開始執行,而main函式的原型是: int main( int a
Linux下C程式命令列引數處理
Linux下開發C程式,甚至是GUI程式,都可能需要處理複雜的命令列引數。健全、可靠的複雜命令列引數處理機制,可使程式方便使用,也更顯專業。Linux下幾乎所有的命令都提供了引數處理機制,包括短選項和長選項。 POSIX標準中對程式名、引數作了如下相關約定:
Shell指令碼學習-命令列引數處理
在Linux的Shell中怎樣處理tail -n 10 access.log這樣的命令列選項呢?這是被別人問起的一個問題,好好學習了一下,進行總結如下: 在bash中,可以用以下三種方式來處理命令列引數,每種方式都有自己的應用場景。 1.直接處理,依次
boost之program_option-命令列引數處理(霜之小刀)
歡迎轉載和引用,若有問題請聯絡 若有疑問,請聯絡 Email : [email protected] QQ:2279557541 命令列的引數處理什麼xxx –xxx -x=xx -x 這種東西如果我們自己從argc,argv裡面提取,我相信大家
Go基礎程式設計:獲取命令列引數
package main import ( "fmt" "os" //os.Args所需的包 ) func main() { args := os.Args //獲取使用者輸入的所有引數 //如果使用者沒有輸入
[Python小筆記]命令列引數:sys.argv和getopt模組
一、sys.argv sys.argv 是命令列引數列表。 #test_sys_argv.py import sys print(sys.argv)#命令列引數列表 print(sys.argv[0]) print(len(sys.argv))#命令列引數列表個數 二、g
Linux程式設計學習筆記----System V程序間通訊(訊號量)
關於System V Unix System V,是Unix作業系統眾多版本中的一支。它最初由AT&T開發,在1983年第一次釋出,因此也被稱為AT&T System V。一共發行了4個System V的主要版本:版本1、2、3和4。System V Rel
python命令列引數處理:argparse、optparse和getopt
一 命令列引數: (1)在python中: *sys.argv:命令列引數的列表。 *len(sys.argv):命令列引數的個數(argc)。 *python中提供了三個模組來輔助處理命令列引數:getopt,optparse和argparse。 (2)術語: *arg
ffmpeg 原始碼學習 -- 之命令列引數解析
ffmpeg 原始碼學習 -- 之ffmpeg命令列引數解析 大家通過git在安裝好cygwin之後,下載原始碼到(cygwin)home目錄,通過./configure ...... ,可以新增一堆引數選項,執行可以生成config.mk等編譯使用的檔案,通過命令對工
linux 程式設計學習筆記--編譯多個檔案
把學的東西記下來,複習 假設有三個檔案: main.c su.c su.h 內容分別為 #include <stdio.h> int sum(int a,int b);
Linux程式設計學習筆記----程序間通訊——管道
程序通訊概述 在Linux系統中,程序是一個獨立的資源管理單元,但是獨立而不孤立,他們需要之間的通訊,因此便需要一個程序間資料傳遞、非同步、同步的機制,這個機制顯然需要由OS來完成管理和維護。如下: 1、同一主機程序間資料互動機制:無名管道(PIPE),有名管道(FIF
linux中getopt_long解析命令列引數(附上windows上的getopt_long原始碼)
getopt_long支援長選項的命令列解析,使用man getopt_long,得到其宣告如下: #include <getopt.h> int getopt_long(int argc, char * const argv[
Linux程式設計學習筆記----多執行緒程式設計執行緒同步機制之互斥量(鎖)與讀寫鎖
互斥鎖通訊機制 基本原理 互斥鎖以排他方式防止共享資料被併發訪問,互斥鎖是一個二元變數,狀態為開(0)和關(1),將某個共享資源與某個互斥鎖邏輯上繫結之後,對該資源的訪問操作如下: (1)在訪問該資源之前需要首先申請互斥鎖,如果鎖處於開狀態,則申請得到鎖並立即上鎖(關),防
Linux程式設計學習筆記----多執行緒程式設計之執行緒同步條件變數
轉載請註明出處:http://blog.csdn.net/suool/article/details/38582521. 基本概念與原理 互斥鎖能夠解決資源的互斥訪問,但是在某些情況下,互斥並不能解決問題,比如兩個執行緒需 要互斥的處理各自的操作,但是一個執行緒的操作僅僅存
GO學習筆記 - 命令列解析
本文主題:基於os.Args與flag實現Golang命令列解析。 小慢哥的原創文章,歡迎轉載 目錄 ▪ 一. os.Args ▪ 二. flag ▪ 三. 結合os.Args與flag實現子命令 ▪ 附. 參考文件 一. os.Args os.Args用於獲取通過命令列傳入的引數 ▷ os.Args
Go語言學習筆記(十七)之命令列引數
24.1命令列引數 os.Args命令列引數的切片 1: func main() { 2: name := "Alice" 3: fmt.Println("Good Morning", name) 4: // 說明使用者傳入了引數 5: if len(os.Args) >
tensorflow學習筆記(一):命令列引數
全域性環境下編寫程式碼 import tensorflow as tf flags = tf.flags #flags是一個檔案:flags.py,用於處理命令列引數的解析工作 logging =
linux命令列引數解析學習心得
轉載出處:blog.csdn.net/bailyzheng/article/details/8048733 最近用到一個命令列工具,之前也一直說想把命令列引數解析看一下,今天算是做一個小的總結。 命令列引數解析分類:單個字元的引數(-a -b),還有字串引數(--vide
Linux環境下C程式設計指南---gcc 編譯器常用的命令列引數一覽
1. gcc -E source_file.c-E,只執行到預編譯。直接輸出預編譯結果。2. gcc -S source_file.c -S,只執行到原始碼到彙編程式碼的轉換,輸出彙編程式碼。3. gcc -c source_file.c-c,只執行到編譯,輸出目標檔案。4. gcc (-E/S/c/) so
Linux系統命令及Shell指令碼學習筆記五:字元處理
管道 管道可以把一個命令的輸出內容當作下一個命令的輸入內容,兩個命令之間只需要使用管道符號連線即可,由管道連線起來的程序可以自動執行。 ls -l /etc/init.d | more 檢視目錄下檔案的詳細資訊,但會因為輸出內容過多而造成翻屏,先輸出的內容就會看不到了,利用