如何寫好 C main 函式

Linux中國發表於2019-06-08
AI函式

學習如何構造一個 C 檔案並編寫一個 C main 函式來成功地處理命令列引數。

Hand drawing out the word

我知道，現在孩子們用 Python 和 JavaScript 編寫他們的瘋狂“應用程式”。但是不要這麼快就否定 C 語言 —— 它能夠提供很多東西，並且簡潔。如果你需要速度，用 C 語言編寫可能就是你的答案。如果你正在尋找穩定的職業或者想學習如何捕獲空指標解引用，C 語言也可能是你的答案！在本文中，我將解釋如何構造一個 C 檔案並編寫一個 C main 函式來成功地處理命令列引數。

我：一個頑固的 Unix 系統程式設計師。

你：一個有編輯器、C 編譯器，並有時間打發的人。

讓我們開工吧。

一個無聊但正確的 C 程式

Parody O'Reilly book cover,
Parody O'Reilly book cover, "Hating Other People's Code"

C 程式以 main() 函式開頭，通常儲存在名為 main.c 的檔案中。

/* main.c */
int main(int argc, char *argv[]) {

}
複製程式碼

這個程式可以編譯但不幹任何事。

$ gcc main.c
$ ./a.out -o foo -vv
$
複製程式碼

正確但無聊。

main 函式是唯一的。

main() 函式是開始執行時所執行的程式的第一個函式，但不是第一個執行的函式。第一個函式是 _start()，它通常由 C 執行庫提供，在編譯程式時自動鏈入。此細節高度依賴於作業系統和編譯器工具鏈，所以我假裝沒有提到它。

main() 函式有兩個引數，通常稱為 argc 和 argv，並返回一個有符號整數。大多數 Unix 環境都希望程式在成功時返回 0（零），失敗時返回 -1（負一）。

引數 名稱 描述
argc 引數個數 引數向量的個數
argv 引數向量 字元指標陣列

引數向量 argv 是呼叫你的程式的命令列的標記化表示形式。在上面的例子中，argv 將是以下字串的列表：

argv = [ "/path/to/a.out", "-o", "foo", "-vv" ];
複製程式碼

引數向量在其第一個索引 argv[0] 中確保至少會有一個字串，這是執行程式的完整路徑。

main.c 檔案的剖析

當我從頭開始編寫 main.c 時，它的結構通常如下：

/* main.c */
/* 0 版權/許可證 */
/* 1 包含 */
/* 2 定義 */
/* 3 外部宣告 */
/* 4 型別定義 */
/* 5 全域性變數宣告 */
/* 6 函式原型 */

int main(int argc, char *argv[]) {
/* 7 命令列解析 */
}

/* 8 函式宣告 */
複製程式碼

下面我將討論這些編號的各個部分，除了編號為 0 的那部分。如果你必須把版權或許可文字放在原始碼中，那就放在那裡。

另一件我不想討論的事情是註釋。

“評論謊言。”
- 一個憤世嫉俗但聰明又好看的程式設計師。
複製程式碼

與其使用註釋，不如使用有意義的函式名和變數名。

鑑於程式設計師固有的惰性，一旦新增了註釋，維護負擔就會增加一倍。如果更改或重構程式碼，則需要更新或擴充註釋。隨著時間的推移，程式碼會變得面目全非，與註釋所描述的內容完全不同。

如果你必須寫註釋，不要寫關於程式碼正在做什麼，相反，寫下程式碼為什麼要這樣寫。寫一些你將要在五年後讀到的註釋，那時你已經將這段程式碼忘得一乾二淨。世界的命運取決於你。不要有壓力。

1、包含

我新增到 main.c 檔案的第一個東西是包含檔案，它們為程式提供大量標準 C 標準庫函式和變數。C 標準庫做了很多事情。瀏覽 /usr/include 中的標頭檔案，你可以瞭解到它們可以做些什麼。

#include 字串是 C 預處理程式（cpp）指令，它會將引用的檔案完整地包含在當前檔案中。C 中的標頭檔案通常以 .h 副檔名命名，且不應包含任何可執行程式碼。它只有巨集、定義、型別定義、外部變數和函式原型。字串 <header.h> 告訴 cpp 在系統定義的標頭檔案路徑中查詢名為 header.h 的檔案，它通常在 /usr/include 目錄中。

/* main.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libgen.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <sys/types.h>
複製程式碼

這是我預設會全域性包含的最小包含集合，它將引入：

#include 檔案 提供的東西
stdio 提供 FILE、stdin、stdout、stderr 和 fprint() 函式系列
stdlib 提供 malloc()、calloc() 和 realloc()
unistd 提供 EXIT_FAILURE、EXIT_SUCCESS
libgen 提供 basename() 函式
errno 定義外部 errno 變數及其可以接受的所有值
string 提供 memcpy()、memset() 和 strlen() 函式系列
getopt 提供外部 optarg、opterr、optind 和 getopt() 函式
sys/types 型別定義快捷方式，如 uint32_t 和 uint64_t

2、定義

/* main.c */
<...>

#define OPTSTR "vi:o:f:h"
#define USAGE_FMT  "%s [-v] [-f hexflag] [-i inputfile] [-o outputfile] [-h]"
#define ERR_FOPEN_INPUT  "fopen(input, r)"
#define ERR_FOPEN_OUTPUT "fopen(output, w)"
#define ERR_DO_THE_NEEDFUL "do_the_needful blew up"
#define DEFAULT_PROGNAME "george"
複製程式碼

這在現在沒有多大意義，但 OPTSTR 定義我這裡會說明一下，它是程式推薦的命令列開關。參考 getopt(3) man 頁面，瞭解 OPTSTR 將如何影響 getopt() 的行為。

USAGE_FMT 定義了一個 printf() 風格的格式字串，它用在 usage() 函式中。

我還喜歡將字串常量放在檔案的 #define 這一部分。如果需要，把它們收集在一起可以更容易地修正拼寫、重用訊息和國際化訊息。

最後，在命名 #define 時全部使用大寫字母，以區別變數和函式名。如果需要，可以將單詞放連在一起或使用下劃線分隔，只要確保它們都是大寫的就行。

3、外部宣告

/* main.c */
<...>

extern int errno;
extern char *optarg;
extern int opterr, optind;
複製程式碼

extern 宣告將該名稱帶入當前編譯單元的名稱空間（即 “檔案”），並允許程式訪問該變數。這裡我們引入了三個整數變數和一個字元指標的定義。opt 字首的幾個變數是由 getopt() 函式使用的，C 標準庫使用 errno 作為帶外通訊通道來傳達函式可能的失敗原因。

4、型別定義

/* main.c */
<...>

typedef struct {
  int           verbose;
  uint32_t      flags;
  FILE         *input;
  FILE         *output;
} options_t;
複製程式碼

在外部宣告之後，我喜歡為結構、聯合和列舉宣告 typedef。命名一個 typedef 是一種傳統習慣。我非常喜歡使用 _t 字尾來表示該名稱是一種型別。在這個例子中，我將 options_t 宣告為一個包含 4 個成員的 struct。C 是一種空格無關的程式語言，因此我使用空格將欄位名排列在同一列中。我只是喜歡它看起來的樣子。對於指標宣告，我在名稱前面加上星號，以明確它是一個指標。

5、全域性變數宣告

/* main.c */
<...>

int dumb_global_variable = -11;
複製程式碼

全域性變數是一個壞主意，你永遠不應該使用它們。但如果你必須使用全域性變數，請在這裡宣告，並確保給它們一個預設值。說真的，不要使用全域性變數。

6、函式原型

/* main.c */
<...>

void usage(char *progname, int opt);
int do_the_needful(options_t *options);
複製程式碼

在編寫函式時，將它們新增到 main() 函式之後而不是之前，在這裡放函式原型。早期的 C 編譯器使用單遍策略，這意味著你在程式中使用的每個符號（變數或函式名稱）必須在使用之前宣告。現代編譯器幾乎都是多遍編譯器，它們在生成程式碼之前構建一個完整的符號表，因此並不嚴格要求使用函式原型。但是，有時你無法選擇程式碼要使用的編譯器，所以請編寫函式原型並繼續這樣做下去。

當然，我總是包含一個 usage() 函式，當 main() 函式不理解你從命令列傳入的內容時，它會呼叫這個函式。

7、命令列解析

/* main.c */
<...>

int main(int argc, char *argv[]) {
    int opt;
    options_t options = { 0, 0x0, stdin, stdout };

    opterr = 0;

    while ((opt = getopt(argc, argv, OPTSTR)) != EOF) 
       switch(opt) {
           case 'i':
              if (!(options.input = fopen(optarg, "r")) ){
                 perror(ERR_FOPEN_INPUT);
                 exit(EXIT_FAILURE);
                 /* NOTREACHED */
              }
              break;

           case 'o':
              if (!(options.output = fopen(optarg, "w")) ){
                 perror(ERR_FOPEN_OUTPUT);
                 exit(EXIT_FAILURE);
                 /* NOTREACHED */
              }    
              break;
              
           case 'f':
              options.flags = (uint32_t )strtoul(optarg, NULL, 16);
              break;

           case 'v':
              options.verbose += 1;
              break;

           case 'h':
           default:
              usage(basename(argv[0]), opt);
              /* NOTREACHED */
              break;
       }

    if (do_the_needful(&options) != EXIT_SUCCESS) {
       perror(ERR_DO_THE_NEEDFUL);
       exit(EXIT_FAILURE);
       /* NOTREACHED */
    }

    return EXIT_SUCCESS;
}
複製程式碼

好吧，程式碼有點多。這個 main() 函式的目的是收集使用者提供的引數，執行最基本的輸入驗證，然後將收集到的引數傳遞給使用它們的函式。這個示例宣告一個使用預設值初始化的 options 變數，並解析命令列，根據需要更新 options。

main() 函式的核心是一個 while 迴圈，它使用 getopt() 來遍歷 argv，尋找命令列選項及其引數（如果有的話）。檔案前面定義的 OPTSTR 是驅動 getopt() 行為的模板。opt 變數接受 getopt() 找到的任何命令列選項的字元值，程式對檢測命令列選項的響應發生在 switch 語句中。

如果你注意到了可能會問，為什麼 opt 被宣告為 32 位 int，但是預期是 8 位 char？事實上 getopt() 返回一個 int，當它到達 argv 末尾時取負值，我會使用 EOF（檔案末尾標記）匹配。char 是有符號的，但我喜歡將變數匹配到它們的函式返回值。

當檢測到一個已知的命令列選項時，會發生特定的行為。在 OPTSTR 中指定一個以冒號結尾的引數，這些選項可以有一個引數。當一個選項有一個引數時，argv 中的下一個字串可以通過外部定義的變數 optarg 提供給程式。我使用 optarg 來開啟檔案進行讀寫，或者將命令列引數從字串轉換為整數值。

這裡有幾個關於程式碼風格的要點：

  • 將 opterr 初始化為 0，禁止 getopt 觸發 ?。
  • 在 main() 的中間使用 exit(EXIT_FAILURE); 或 exit(EXIT_SUCCESS);。
  • /* NOTREACHED */ 是我喜歡的一個 lint 指令。
  • 在返回 int 型別的函式末尾使用 return EXIT_SUCCESS;。
  • 顯示強制轉換隱式型別。

這個程式的命令列格式，經過編譯如下所示：

$ ./a.out -h
a.out [-v] [-f hexflag] [-i inputfile] [-o outputfile] [-h]
複製程式碼

事實上，在編譯後 usage() 就會向 stderr 發出這樣的內容。

8、函式宣告

/* main.c */
<...>

void usage(char *progname, int opt) {
   fprintf(stderr, USAGE_FMT, progname?progname:DEFAULT_PROGNAME);
   exit(EXIT_FAILURE);
   /* NOTREACHED */
}

int do_the_needful(options_t *options) {

   if (!options) {
     errno = EINVAL;
     return EXIT_FAILURE;
   }

   if (!options->input || !options->output) {
     errno = ENOENT;
     return EXIT_FAILURE;
   }

   /* XXX do needful stuff */

   return EXIT_SUCCESS;
}
複製程式碼

我最後編寫的函式不是個樣板函式。在本例中，函式 do_the_needful() 接受一個指向 options_t 結構的指標。我驗證 options 指標不為 NULL，然後繼續驗證 input 和 output 結構成員。如果其中一個測試失敗，返回 EXIT_FAILURE，並且通過將外部全域性變數 errno 設定為常規錯誤程式碼，我可以告知呼叫者常規的錯誤原因。呼叫者可以使用便捷函式 perror() 來根據 errno 的值發出便於閱讀的錯誤訊息。

函式幾乎總是以某種方式驗證它們的輸入。如果完全驗證代價很大，那麼嘗試執行一次並將驗證後的資料視為不可變。usage() 函式使用 fprintf() 呼叫中的條件賦值驗證 progname 引數。接下來 usage() 函式就退出了，所以我不會費心設定 errno，也不用操心是否使用正確的程式名。

在這裡，我要避免的最大錯誤是解引用 NULL 指標。這將導致作業系統向我的程式傳送一個名為 SYSSEGV 的特殊訊號，導致不可避免的死亡。使用者最不希望看到的是由 SYSSEGV 而導致的崩潰。最好是捕獲 NULL 指標以發出更合適的錯誤訊息並優雅地關閉程式。

有些人抱怨在函式體中有多個 return 語句，他們喋喋不休地說些“控制流的連續性”之類的東西。老實說，如果函式中間出現錯誤，那就應該返回這個錯誤條件。寫一大堆巢狀的 if 語句只有一個 return 絕不是一個“好主意”™。

最後，如果你編寫的函式接受四個以上的引數，請考慮將它們繫結到一個結構中，並傳遞一個指向該結構的指標。這使得函式簽名更簡單，更容易記住，並且在以後呼叫時不會出錯。它還可以使呼叫函式速度稍微快一些，因為需要複製到函式堆疊中的東西更少。在實踐中，只有在函式被呼叫數百萬或數十億次時，才會考慮這個問題。如果認為這沒有意義，那也無所謂。

等等，你不是說沒有註釋嗎！？！！

在 do_the_needful() 函式中，我寫了一種特殊型別的註釋，它被是作為佔位符設計的，而不是為了說明程式碼：

/* XXX do needful stuff */
複製程式碼

當你寫到這裡時，有時你不想停下來編寫一些特別複雜的程式碼，你會之後再寫，而不是現在。那就是我留給自己再次回來的地方。我插入一個帶有 XXX 字首的註釋和一個描述需要做什麼的簡短註釋。之後，當我有更多時間的時候，我會在原始碼中尋找 XXX。使用什麼字首並不重要，只要確保它不太可能在另一個上下文環境（如函式名或變數）中出現在你程式碼庫裡。

把它們組合在一起

好吧，當你編譯這個程式後，它仍然幾乎沒有任何作用。但是現在你有了一個堅實的骨架來構建你自己的命令列解析 C 程式。

/* main.c - the complete listing */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libgen.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>

#define OPTSTR "vi:o:f:h"
#define USAGE_FMT  "%s [-v] [-f hexflag] [-i inputfile] [-o outputfile] [-h]"
#define ERR_FOPEN_INPUT  "fopen(input, r)"
#define ERR_FOPEN_OUTPUT "fopen(output, w)"
#define ERR_DO_THE_NEEDFUL "do_the_needful blew up"
#define DEFAULT_PROGNAME "george"

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

typedef struct {
  int           verbose;
  uint32_t      flags;
  FILE         *input;
  FILE         *output;
} options_t;

int dumb_global_variable = -11;

void usage(char *progname, int opt);
int  do_the_needful(options_t *options);

int main(int argc, char *argv[]) {
    int opt;
    options_t options = { 0, 0x0, stdin, stdout };

    opterr = 0;

    while ((opt = getopt(argc, argv, OPTSTR)) != EOF) 
       switch(opt) {
           case 'i':
              if (!(options.input = fopen(optarg, "r")) ){
                 perror(ERR_FOPEN_INPUT);
                 exit(EXIT_FAILURE);
                 /* NOTREACHED */
              }
              break;

           case 'o':
              if (!(options.output = fopen(optarg, "w")) ){
                 perror(ERR_FOPEN_OUTPUT);
                 exit(EXIT_FAILURE);
                 /* NOTREACHED */
              }    
              break;
              
           case 'f':
              options.flags = (uint32_t )strtoul(optarg, NULL, 16);
              break;

           case 'v':
              options.verbose += 1;
              break;

           case 'h':
           default:
              usage(basename(argv[0]), opt);
              /* NOTREACHED */
              break;
       }

    if (do_the_needful(&options) != EXIT_SUCCESS) {
       perror(ERR_DO_THE_NEEDFUL);
       exit(EXIT_FAILURE);
       /* NOTREACHED */
    }

    return EXIT_SUCCESS;
}

void usage(char *progname, int opt) {
   fprintf(stderr, USAGE_FMT, progname?progname:DEFAULT_PROGNAME);
   exit(EXIT_FAILURE);
   /* NOTREACHED */
}

int do_the_needful(options_t *options) {

   if (!options) {
     errno = EINVAL;
     return EXIT_FAILURE;
   }

   if (!options->input || !options->output) {
     errno = ENOENT;
     return EXIT_FAILURE;
   }

   /* XXX do needful stuff */

   return EXIT_SUCCESS;
}
複製程式碼

現在，你已經準備好編寫更易於維護的 C 語言。如果你有任何問題或反饋，請在評論中分享。

via: opensource.com/article/19/…

作者：Erik O'Shaughnessy 選題：lujun9972 譯者：MjSeven 校對：wxy

本文由 LCTT 原創編譯，Linux中國 榮譽推出

相關文章