如何写好C main函数的几个注意事项

学习如何构造一个 C 文件并编写一个 C main 函数来成功地处理命令行参数。

我知道,现在孩子们用 Python 和 JavaScript 编写他们的疯狂“应用程序”。但是不要这么快就否定 C 语言 —— 它能够提供很多东西,并且简洁。如果你需要速度,用 C 语言编写可能就是你的答案。如果你正在寻找稳定的职业或者想学习如何捕获空指针解引用,C 语言也可能是你的答案!在本文中,我将解释如何构造一个 C 文件并编写一个 C main 函数来成功地处理命令行参数。

我:一个顽固的 Unix 系统程序员。

你:一个有编辑器、C 编译器,并有时间打发的人。

让我们开工吧。

一个无聊但正确的 C 程序

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 语言。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 深入Main函数中的参数argc,argv的使用详解

    C/C++语言中的main函数,经常带有参数argc,argv,如下: 复制代码 代码如下: int main(int argc, char** argv) 这两个参数的作用是什么呢?argc 是指命令行输入参数的个数,argv存储了所有的命令行参数.假如你的程序是hello.exe,如果在命令行运行该程序,(首先应该在命令行下用 cd 命令进入到 hello.exe 文件所在目录) 运行命令为: 复制代码 代码如下: hello.exe Shiqi Yu 下面的程序演示argc和argv的使用

  • C语言之没有main函数的helloworld示例

    几乎所有程序员的第一堂课都是学习helloworld程序,下面我们先来重温一下经典的C语言helloworl 复制代码 代码如下: /* hello.c */  #include <stdio.h>    int main()  {      printf("hello world!\n");      return 0;  } 这是一个简单得不能再单的程序,但它包含有一个程序最重要的部分,那就是我们在几乎所有代码中都能看到的main函数,我们编译成可执行文件并查看符号表,

  • c语言main函数使用及其参数介绍

    每一C程序都必须有一main()函数,可以根据自己的爱好把它放在程序的某个地方.有些程序员把它放在最前面,而另一些程序员把它放在最后面,无论放在哪个地方,以下几点说明都是适合的. 在Turbo C2.0启动过程中,传递main()函数三个参数:argc,argv和env.* argc:整数,为传给main()的命令行参数个数.* argv:字符串数组.char* argv[],我们可以看出,argv的类型是char* [],即是一个指向字符数组的指针,所以我们还可以写作:char** argv.

  • JavaScript学习笔记(三):JavaScript也有入口Main函数

    在C和Java中,都有一个程序的入口函数或方法,即main函数或main方法.而在JavaScript中,程序是从JS源文件的头部开始运行的.但是某种意义上,我们仍然可以虚构出一个main函数来作为程序的起点,这样一来不仅可以跟其他语言统一了,而且说不定你会对JS有更深的理解. 1. 实际的入口 当把一个JavaScript文件交给JS引擎执行时,JS引擎就是从上到下逐条执行每条语句的,直到执行完所有代码. 2. 作用域链.全局作用域和全局对象 我们知道,JS中的每个函数在执行时都会产生一个新的

  • C语言main函数的参数及其返回值详细解析

    返回值的作用 main函数的返回值用于说明程序的退出状态.如果返回0,则代表程序正常退出:返回其它数字的含义则由系统决定.通常,返回非零代表程序异常退出.下面我们在winxp环境下做一个小实验.首先编译下面的程序:int main( void ){    return 0;}然后打开附件里的"命令提示符",在命令行里运行刚才编译好的可执行文件,然后输入"echo%ERRORLEVEL%",回车,就可以看到程序的返回值为0.假设刚才编译好的文件是a.exe,如果输入&

  • C语言中怎么在main函数开始前执行函数

    在gcc中,可以使用attribute关键字,声明constructor和destructor,代码如下: 复制代码 代码如下: #include <stdio.h> __attribute((constructor)) void before_main(){ printf("%s/n",__FUNCTION__);} __attribute((destructor)) void after_main(){ printf("%s/n",__FUNCTIO

  • C++改变编程入口为main函数

    1, 你用vc建了一个控制台程序,它的入口函数应该是main, 而你使用了WinMain. 2.  你用vc打开了一个.c/.cpp 文件,然后直接编译这个文件,这个文件中使用了WinMian而不是main作为入口函数.vc这时的默认设置是针对控制台程序的.  解决方法 1.进入project->setting->c/c++, 在category中选择preprocessor,在processor definitions中删除_WINDOWS, 添加_CONSOLE 2.进入project-&

  • C语言main函数的三种形式实例详解

    在C语言中,main()函数有三种形式. 1.无参数 #include <stdio.h> int main(void) { printf("Hello World!\n"); return 0; } 2.有两个参数 习惯上第一个参数是整型argc,保存了外部调用命令的参数个数,第二个参数是指针数组或二级指针argv,以字符串形式保存了与argc对应的参数,如下例子: #include <stdio.h> int main(int argc, char* arg

  • 如何写好C main函数的几个注意事项

    学习如何构造一个 C 文件并编写一个 C main 函数来成功地处理命令行参数. 我知道,现在孩子们用 Python 和 JavaScript 编写他们的疯狂"应用程序".但是不要这么快就否定 C 语言 -- 它能够提供很多东西,并且简洁.如果你需要速度,用 C 语言编写可能就是你的答案.如果你正在寻找稳定的职业或者想学习如何捕获空指针解引用,C 语言也可能是你的答案!在本文中,我将解释如何构造一个 C 文件并编写一个 C main 函数来成功地处理命令行参数. 我:一个顽固的 Uni

  • Java中的main函数的详细介绍

    Java中的main函数的详细介绍 JAVA中的主函数是我们再熟悉不过的了,相信每个学习过JAVA语言的人都能够熟练地写出这个程序的入口函数,但对于主函数为什么这么写,其中的每个关键字分别是什么意思,可能就不是所有人都能轻松地答出来的了.我也是在学习中碰到了这个问题,通过在网上搜索资料,并加上自己的实践终于有了一点心得,不敢保留,写出来与大家分享. 主函数的一般写法如下: public static void main(String[] args){-} 下面分别解释这些关键字的作用: (1)p

  • 解析在main函数之前调用函数以及对设计的作用详解

    前几天为新员工写一个简单的测试框架,可让他们方便的写测试用例并且执行.期间遇到一个问题就是如何让他们增加测试用例而用不影响测试框架的代码?c++的单件模式可以解决这个问题,但是其中一个难点是要在main之前注册单件.c++可以通过构造函数来实现注册,c如何注册?最后查了下资料,原来可以定义在main之前调用的函数!有了这个特性可以改善c的模块化设计.特性介绍:如果想定义在main函数之前调用的函数,可以在函数的声明之后加上一句"__attribute__((constructor))"

  • C#难点逐个击破(4):main函数

    还记得读大学时初识计算机编程时的C语言,Main(){},那时还不明白入口函数是什么意思,只知道照抄书本上的示例,一行一行地跑printf看. 在C#中Main()属于主入口函数,我们知识C.C#属于编译语言,可以想象为一段程序最开始的头部部分,由Main()函数进入逐语句进行编译后执行.假如html页面也称作编程语言的话,那么它就属于从上到下一句一句(下载)执行:js也是由上到下执行,不过js相当诡异,变量作用域要特别对待:在asp.net中一般情况下是以Page_Load(object se

  • 详解Android应用main函数的调用

    启动App进程 Activity启动过程的一环是调用ActivityStackSupervisor.startSpecificActivityLocked,如果App所在进程还不存在,首先调用AMS的startProcessLocked: void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) { // Is this activity's application alr

  • Kotlin实现在类里面创建main函数

    1.创建在class块外面: class Test{ } /** 我是main入口函数 **/ fun main(args: Array<String>) { var test=Test(); } 这样是一种方式,但是细心的童鞋可能会发现一个问题,目录里面的文件图标是灰色的,而且这种写法看上去怪怪的,有强迫症的可能会接受不了: 2.创建在class里面: class Test{ companion object { /** 我是main入口函数 **/ @JvmStatic fun main(

  • Python 没有main函数的原因

    毫无疑问 Python 中没有所谓的 main 入口函数,但是网上经常看到一些文章提"Python 的 main 函数"."建议写 main 函数"-- 有些人是知情的,他的意图可能是模仿那些正宗的 main 函数,但还有不少人明显是被误导了(或自己误解了),就写出来很累赘的代码. 本期"Python 为什么"栏目来聊聊 Python 为什么没有 main 函数? 在开始正题之前,先要来回答这两个问题:所谓的 "main 函数"

  • 如何在 clion 运行多个 main 函数(方法详解)

    在写 C++ 的题目的时候经常会遇到这样的问题,写了多个 cpp 文件,在 clion 中编译报错不能同时存在多 main 函数 这里写了一个小程序优雅地解决这个问,非常简单,就是就是读字符串写文件 直接修改一下 CMake 自动遍历文件即可 多个 main 函数的报错 在 clion 中写完一题,想写下一题,结果发现 main 函数不能运行 正确的解决方法 在牛客用户AAnonymous的告知下,借鉴了他的 github 上的CMakeLists.txt,直接修改 CMakeLists.txt

随机推荐