AddTableEntry() // OK  DeleteUser() // OK GetUserInfo() // OK

判断型函数，可以用形容词，或加 is：

DataReady() // OK IsRunning() // OK JobDone() // OK

数据型函数：

TotalCount() // OK GetTotalCount() // OK

变量命名

变量命名使用小驼峰风格，包括全局变量，局部变量，函数声明或定义中的参数，带括号宏中的参数。

规则1.2 全局变量应增加 'g_' 前缀，函数内静态变量命名不需要加特殊前缀

全局变量应当尽量少使用，使用时应特别注意，所以加上前缀用于视觉上的突出，促使开发人员对这些变量的使用更加小心。
全局静态变量命名与全局变量相同，函数内的静态变量命名与普通局部变量相同。

int g_activeConnectCount; void Func(void) { static int pktCount = 0; ... }

注意：常量本质也是全局变量，但如果命名风格是全大写，下划线连接的格式，则不适用当前规则。

建议1.4 局部变量应该简短，且能够表达相关含义

函数局部变量的命名，在能够表达相关含义的前提下，应该简短。

如下：

int Func(...) { enum PowerBoardStatus powerBoardStatusOfSlot; // Not good: 局部变量有点长 powerBoardStatusOfSlot = GetPowerBoardStatus(slot); if (powerBoardStatusOfSlot == POWER_OFF) { ... } ... }

更好的写法：

int Func(...) { enum PowerBoardStatus status; // Good: 结合上下文，status 已经能明确表达意思 status = GetPowerBoardStatus(slot); if (status == POWER_OFF) { ... } ... }

类似的， tmp 可以用来称呼任意类型的临时变量。
过短的变量命名应慎用，但有时候，单字符变量也是允许的，如用于循环语句中的计数器变量：

int i; ... for (i = 0; i < COUNTER_RANGE; i++) { ... }

或一些简单的数学计算函数中的变量：

int Mul(int a, int b) { return a * b; }

类型命名

类型命名采用大驼峰命名风格。
类型包括结构体、联合体、枚举类型名。

例:

struct MsgHead { enum MsgType type; int msgLen; char *msgBuf; }; union Packet { struct SendPacket send; struct RecvPacket recv; }; enum BaseColor { RED, // 注意，枚举类型是大驼峰，枚举值应使用宏风格 GREEN, BLUE }; typedef int (*NodeCmpFunc)(struct Node *a, struct Node *b);

通过 typedef 对结构体、联合体、枚举起别名时，尽量使用匿名类型。
若需要指针自嵌套，可以增加 'tag' 前缀或下划线后缀。

typedef struct { // Good: 无须自嵌套，使用匿名结构体 int a; int b; } MyType; // 结构体别名用大驼峰风格

typedef struct tagNode { // Good: 使用 tag 前缀。这里也可以使用 'Node_'代替也可以。 struct tagNode *prev; struct tagNode *next; } Node; // 类型主体用大驼峰风格

宏、常量、枚举命名

宏、枚举值采用全大写，下划线连接的格式。
常量推荐采用全大写，下划线连接风格。作为全局变量，也可以保持与普通全局变量命名风格相同。
这里常量如前文定义，是指基本数据类型、枚举、字符串类型的全局 const 变量。

函数式宏，如果功能上可以替代函数，也可以与函数的命名方式相同，使用大驼峰命名风格。
这种做法会让宏与函数看起来一样，容易混淆，需要特别注意。

宏举例：

#define PI 3.14 #define MAX(a, b)   (((a) < (b)) ? (b) : (a))

#ifdef SOME_DEFINE void Bar(int); #define Foo(a) Bar(a)   // 特殊场景，用大驼峰风格命名函数式宏 #else void Foo(int); #endif

常量举例：

const int VERSION = 200; // OK. const enum Color DEFAULT_COLOR = BLUE; // OK. const char PATH_SEP = '/'; // OK. const char * const GREETINGS = "Hello, World!"; // OK.

非常量举例：

// 结构体类型，不符合常量定义 const struct MyType g_myData = { ... }; // OK: 用小驼峰 // 数组类型，不符合常量定义 const int g_xxxBaseValue[4] = { 1, 2, 4, 8 }; // OK: 用小驼峰 int Foo(...) { // 局部作用域，不符合常量定义 const int bufSize = 100; // OK: 用小驼峰 ... }

枚举举例：

// 注意，枚举类型名用大驼峰，其下面的取值是全大写，下划线相连 enum BaseColor { RED, GREEN, BLUE };

建议1.5 避免函数式宏中的临时变量命名污染外部作用域

首先，尽量少的使用函数式宏。

当函数式宏需要定义局部变量时，为了防止跟外部函数中的局部变量有命名冲突。

后置下划线，是一种解决方案。例：

#define SWAP_INT(a, b) do { \  int tmp_ = a; \  a = b; \  b = tmp_; \ } while (0)

2 排版格式

行宽

建议2.1 行宽不超过 120 个字符

代码行宽不宜过长，否则不利于阅读。
控制行宽长度可以间接的引导开发去缩短函数、变量的命名，减少嵌套的层数，提升代码可读性。
强烈建议和要求每行字符数不要超过 120 个；除非超过 120 能显著增加可读性，并且不会隐藏信息。
虽然现代显示器分辨率已经很高，但是行宽过长，反而提高了阅读理解的难度；跟本规范提倡的“清晰”、“简洁”原则相背。

如下场景不宜换行，可以例外：

• 换行会导致内容截断，无法被方便查找(grep)的字符串，如命令行或 URL 等等。包含这些内容的代码或注释，可以适当例外。

• #include / #error 语句可以超出行宽要求，但是也需要尽量避免。

例：

#ifndef XXX_YYY_ZZZ #error Header aaaa/bbbb/cccc/abc.h must only be included after xxxx/yyyy/zzzz/xyz.h #endif

缩进

规则2.1 使用空格进行缩进，每次缩进4个空格

只允许使用空格(space)进行缩进，每次缩进为 4 个空格。不允许使用Tab键进行缩进。
当前几乎所有的集成开发环境（IDE）和代码编辑器都支持配置将Tab键自动扩展为4空格输入，请配置你的代码编辑器支持使用空格进行缩进。

大括号

规则2.2 使用 K&R 缩进风格

K&R风格
换行时，函数左大括号另起一行放行首，并独占一行；其他左大括号跟随语句放行末。
右大括号独占一行，除非后面跟着同一语句的剩余部分，如 do 语句中的 while，或者 if 语句的 else/else if，或者逗号、分号。

如：

struct MyType { // Good: 跟随语句放行末，前置1空格 ... }; // Good: 右大括号后面紧跟分号 int Foo(int a) { // Good: 函数左大括号独占一行，放行首 if (...) { ... } else { // Good: 右大括号与 else 语句在同一行 ... } // Good: 右大括号独占一行 }

函数声明和定义

规则2.3 函数声明、定义的返回类型和函数名在同一行；函数参数列表换行时应合理对齐

在声明和定义函数的时候，函数的返回值类型应该和函数名在同一行。

函数参数列表换行时，应合理对齐。
参数列表的左圆括号总是和函数名在同一行，不要单独一行；右圆括号总是跟随最后一个参数。

换行举例：

ReturnType FunctionName(ArgType paramName1, ArgType paramName2) // Good：全在同一行 { ... } ReturnType VeryVeryVeryLongFunctionName(ArgType paramName1, // 行宽不满足所有参数，进行换行 ArgType paramName2, // Good：和上一行参数对齐 ArgType paramName3) { ... } ReturnType LongFunctionName(ArgType paramName1, ArgType paramName2, // 行宽限制，进行换行 ArgType paramName3, ArgType paramName4, ArgType paramName5) // Good: 换行后 4 空格缩进 { ... } ReturnType ReallyReallyReallyReallyLongFunctionName( // 行宽不满足第1个参数，直接换行 ArgType paramName1, ArgType paramName2, ArgType paramName3) // Good: 换行后 4 空格缩进 { ... }

函数调用

规则2.4 函数调用参数列表换行时保持参数进行合理对齐

函数调用时，函数参数列表如果换行，应该进行合理的参数对齐。
左圆括号总是跟函数名，右圆括号总是跟最后一个参数。

换行举例：

ReturnType result = FunctionName(paramName1, paramName2); // Good：函数参数放在一行 ReturnType result = FunctionName(paramName1, paramName2, // Good：保持与上方参数对齐 paramName3); ReturnType result = FunctionName(paramName1, paramName2, paramName3, paramName4, paramName5); // Good：参数换行，4 空格缩进 ReturnType result = VeryVeryVeryLongFunctionName( // 行宽不满足第1个参数，直接换行 paramName1, paramName2, paramName3); // 换行后，4 空格缩进

如果函数调用的参数存在内在关联性，按照可理解性优先于格式排版要求，对参数进行合理分组换行。

// Good：每行的参数代表一组相关性较强的数据结构，放在一行便于理解 int result = DealWithStructureLikeParams(left.x, left.y, // 表示一组相关参数 right.x, right.y); // 表示另外一组相关参数

条件语句

规则2.5 条件语句必须要使用大括号

我们要求条件语句都需要使用大括号，即便只有一条语句。
理由：

• 代码逻辑直观，易读；

• 在已有条件语句代码上增加新代码时不容易出错；

• 对于在条件语句中使用函数式宏时，没有大括号保护容易出错（如果宏定义时遗漏了大括号）。

if (objectIsNotExist) { // Good：单行条件语句也加大括号 return CreateNewObject(); }

规则2.6 禁止 if/else/else if 写在同一行

条件语句中，若有多个分支，应该写在不同行。

如下是正确的写法：

if (someConditions) { ... } else { // Good: else 与 if 在不同行 ... }

下面是不符合规范的案例：

if (someConditions) { ... } else { ... } // Bad: else 与 if 在同一行

循环

规则2.7 循环语句必须使用大括号

和条件表达式类似，我们要求for/while循环语句必须加上大括号，即便循环体是空的，或循环语句只有一条。

for (int i = 0; i < someRange; i++) { // Good: 使用了大括号 DoSomething(); }

while (condition) { } // Good：循环体是空，使用大括号

while (condition) { continue; // Good：continue 表示空逻辑，使用大括号 }

坏的例子：

for (int i = 0; i < someRange; i++) DoSomething(); // Bad: 应该加上括号

while (condition); // Bad：使用分号容易让人误解是while语句中的一部分

switch语句

规则2.8 switch 语句的 case/default 要缩进一层

switch 语句的缩进风格如下：

switch (var) { case 0: // Good: 缩进 DoSomething1(); // Good: 缩进 break; case 1: { // Good: 带大括号格式 DoSomething2(); break; } default: break; }

switch (var) { case 0: // Bad: case 未缩进 DoSomething(); break; default: // Bad: default 未缩进 break; }

表达式

建议2.2 表达式换行要保持换行的一致性，操作符放行末

较长的表达式，不满足行宽要求的时候，需要在适当的地方换行。一般在较低优先级操作符或连接符后面截断，操作符或连接符放在行末。
操作符、连接符放在行末，表示“未结束，后续还有”。

例：

// 假设下面第一行已经不满足行宽要求 if ((currentValue > MIN) && // Good：换行后，布尔操作符放在行末 (currentValue < MAX)) { DoSomething(); ... } int result = reallyReallyLongVariableName1 + // Good: 加号留在行末 reallyReallyLongVariableName2;

表达式换行后，注意保持合理对齐，或者4空格缩进。参考下面例子

int sum = longVaribleName1 + longVaribleName2 + longVaribleName3 + longVaribleName4 + longVaribleName5 + longVaribleName6; // OK: 4空格缩进 int sum = longVaribleName1 + longVaribleName2 + longVaribleName3 + longVaribleName4 + longVaribleName5 + longVaribleName6; // OK: 保持对齐

变量赋值

规则2.9 多个变量定义和赋值语句不允许写在一行

每行最好只有一个变量初始化的语句，更容易阅读和理解。

int maxCount = 10; bool isCompleted = false;

下面是不符合规范的示例：

int maxCount = 10; bool isCompleted = false; // Bad：多个初始化放在了同一行 int x, y = 0; // Bad：多个变量定义需要分行，每行一个 int pointX; int pointY; ... pointX = 1; pointY = 2; // Bad：多个变量赋值语句放同一行

例外情况：
对于多个相关性强的变量定义，且无需初始化时，可以定义在一行，减少重复信息，以便代码更加紧凑。

int i, j; // Good：多变量定义，未初始化，可以写在一行 for (i = 0; i < row; i++) { for (j = 0; j < col; j++) { ... } }

初始化

初始化包括结构体、联合体及数组的初始化

规则2.10 初始化换行时要有缩进，或进行合理对齐

结构体或数组初始化时，如果换行应保持4空格缩进。
从可读性角度出发，选择换行点和对齐位置。

// Good: 满足行宽要求时不换行 int arr[4] = { 1, 2, 3, 4 }; // Good: 行宽较长时，换行让可读性更好 const int rank[] = { 16, 16, 16, 16, 32, 32, 32, 32, 64, 64, 64, 64, 32, 32, 32, 32 };

对于复杂结构数据的初始化，尽量清晰、紧凑。
参考如下格式：

int a[][4] = { { 1, 2, 3, 4 }, { 2, 2, 3, 4 }, // OK. { 3, 2, 3, 4 }, { 4, 2, 3, 4 } }; int b[][8] = { { 1, 2, 3, 4, 5, 6, 7, 8 }, // OK. { 2, 2, 3, 4, 5, 6, 7, 8 } };

int c[][8] = { { 1, 2, 3, 4, 5, 6, 7, 8 // OK. }, { 2, 2, 3, 4, 5, 6, 7, 8 } };

注意：

• 左大括号放行末时，对应的右大括号需另起一行

• 左大括号被内容跟随时，对应的右大括号也应跟随内容

规则2.11 结构体和联合体在按成员初始化时，每个成员初始化单独一行

C99标准支持结构体和联合体按照成员进行初始化，标准中叫"指定初始化"（designated initializer）。如果按照这种方式进行初始化，每个成员的初始化单独一行。

struct Date { int year; int month; int day; }; struct Date date = { // Good：使用指定初始化方式时，每行初始化一个 .year = 2000, .month = 1, .day = 1 };

指针

建议2.3 指针类型"*"跟随变量名或者类型，不要两边都留有空格或都没有空格

声明或定义指针变量或者返回指针类型函数时，"*" 靠左靠右都可以，但是不要两边都有或者都没有空格。

int *p1; // OK. int* p2; // OK. int*p3; // Bad: 两边都没空格 int * p4; // Bad: 两边都有空格

选择一种风格，并保持一致性。

选择"*"跟随类型风格时，避免一行同时声明带指针的多个变量。

int* a, b; // Bad: 很容易将 b 误理解成指针

选择"*"跟随变量风格时，可能会存在无法紧跟的情况。
无法跟随时就不跟随，不要破坏风格一致性。

char * const VERSION = "V100"; // OK. int Foo(const char * restrict p); // OK.

注意，任何时候 "*" 不要紧跟 const 或 restrict 关键字。

编译预处理

规则2.12 编译预处理的"#"默认放在行首，嵌套编译预处理语句时，"#"可以进行缩进

编译预处理的"#"统一放在行首；即便编译预处理的代码是嵌入在函数体中的，"#"也应该放在行首。

空格和空行

规则2.13 水平空格应该突出关键字和重要信息，避免不必要的留白

水平空格应该突出关键字和重要信息，每行代码尾部不要加空格。总体规则如下：

• if, switch, case, do, while, for 等关键字之后加空格；

• 小括号内部的两侧，不要加空格

• 二元操作符（= + ‐ < > * / % | & ^ <= >= == !=）左右两侧加空格

• 一元操作符（& * + ‐ ~ !）之后不要加空格

• 三目操作符（? :）符号两侧均需要空格

• 结构体中表示位域的冒号，两侧均需要空格

• 前置和后置的自增、自减（++ --）和变量之间不加空格

• 结构体成员操作符（. ->）前后不加空格

• 大括号内部两侧有无空格，左右必须保持一致

• 逗号、分号、冒号（不含三目操作符和表示位域的冒号）紧跟前面内容无空格，其后需要空格

• 函数参数列表的小括号与函数名之间无空格

• 类型强制转换的小括号与被转换对象之间无空格

• 数组的中括号与数组名之间无空格

• 涉及到换行时，行末的空格可以省去

对于大括号内部两侧的空格，建议如下：

• 一般的，大括号内部两侧建议加空格

• 对于空的，或单个标识符，或单个字面常量，空格不是必须 如：'{}', '{0}', '{NULL}', '{"hi"}' 等

• 连续嵌套的多重括号之间，空格不是必须 如：'{{0}}', '{{ 1, 2 }}' 等 错误示例：'{ 0, {1}}'，不属于连续嵌套场景，而且最外侧大括号左右不一致

常规情况：

int i = 0; // Good：变量初始化时，= 前后应该有空格，分号前面不要留空格 int buf[BUF_SIZE] = {0}; // Good：数组初始化时，大括号内空格可选 int arr[] = { 10, 20 }; // Good: 正常大括号内部两侧建议加空格

函数定义和函数调用：

int result = Foo(arg1,arg2); ^ // Bad: 逗号后面应该有空格 int result = Foo( arg1, arg2 ); ^ ^ // Bad: 小括号内部两侧不应该有空格

指针和取地址

x = *p; // Good：*操作符和指针p之间不加空格 p = &x; // Good：&操作符和变量x之间不加空格 x = r.y; // Good：通过.访问成员变量时不加空格 x = r->y; // Good：通过->访问成员变量时不加空格

操作符：

x = 0; // Good：赋值操作的=前后都要加空格 x = -5; // Good：负数的符号和数值之前不要加空格 ++x; // Good：前置和后置的++/--和变量之间不要加空格 x--; if (x && !y) // Good：布尔操作符前后要加上空格，！操作和变量之间不要空格 v = w * x + y / z; // Good：二元操作符前后要加空格 v = w * (x + z); // Good：括号内的表达式前后不需要加空格

循环和条件语句：

if (condition) { // Good：if关键字和括号之间加空格，括号内条件语句前后不加空格 ... } else { // Good：else关键字和大括号之间加空格 ... } while (condition) {} // Good：while关键字和括号之间加空格，括号内条件语句前后不加空格 for (int i = 0; i < someRange; ++i) { // Good：for关键字和括号之间加空格，分号之后加空格 ... } switch (var) { // Good: switch 关键字后面有1空格 case 0: // Good：case语句条件和冒号之间不加空格 ... break; ... default: ... break; }

注意：当前的集成开发环境（IDE）和代码编辑器都可以设置删除行尾的空格，请正确配置你的编辑器。

建议2.4 合理安排空行，保持代码紧凑

减少不必要的空行，可以显示更多的代码，方便代码阅读。下面有一些建议遵守的规则：

• 根据上下内容的相关程度，合理安排空行；

• 函数内部、类型定义内部、宏内部、初始化表达式内部，不使用连续空行

• 不使用连续 3 个空行，或更多

• 大括号内的代码块首行之前和末行之后不要加空行。

ret = DoSomething(); if (ret != OK) { // Bad: 返回值判断应该紧跟函数调用 return -1; }

int Foo(void) { ... } int Bar(void) // Bad：最多使用连续2个空行。 { ... }

int Foo(void) { DoSomething(); // Bad：大括号内部首尾，不需要空行 ... }

3 注释

一般的，尽量通过清晰的架构逻辑，好的符号命名来提高代码可读性；需要的时候，才辅以注释说明。
注释是为了帮助阅读者快速读懂代码，所以要从读者的角度出发，按需注释。

注释内容要简洁、明了、无二义性，信息全面且不冗余。

注释跟代码一样重要。
写注释时要换位思考，用注释去表达此时读者真正需要的信息。在代码的功能、意图层次上进行注释，即注释解释代码难以表达的意图，不要重复代码信息。
修改代码时，也要保证其相关注释的一致性。只改代码，不改注释是一种不文明行为，破坏了代码与注释的一致性，让阅读者迷惑、费解，甚至误解。

使用英文进行注释。

注释风格

在 C 代码中，使用 /**/和 //都是可以的。
按注释的目的和位置，注释可分为不同的类型，如文件头注释、函数头注释、代码注释等等；
同一类型的注释应该保持统一的风格。

// 单行函数头 int Func1(void); // 多行函数头 // 第二行 int Func2(void);

/* 单行函数头 */ int Func1(void); /*  * 单行或多行函数头  * 第二行  */ int Func2(void);

/*  * 返回实际写入的字节数，-1表示写入失败  * 注意，内存 buf 由调用者负责释放  */ int WriteString(char *buf, int len);

/*  * 函数名：WriteString  * 功能：写入字符串  * 参数：  * 返回值：  */ int WriteString(char *buf, int len);

// 这是单行注释 DoSomething(); // 这是多行注释 // 第二行 DoSomething();

/* 这是单行注释 */ DoSomething(); /*  * 这是单/多行注释  * 第二行  */ DoSomething();

int foo = 100; // 放右边的注释 int bar = 200; /* 放右边的注释 */

#define A_CONST 100 /* 相关的同类注释，可以考虑上下对齐 */ #define ANOTHER_CONST 200 /* 上下对齐时，与左侧代码保持间隔 */

switch (var) { case 0: DoSomething(); /* fall-through */ case 1: DoSomeOtherThing(); ... break; default: DoNothing(); break; }

switch (var) { case 0: case 1: DoSomething(); break; default: DoNothing(); break; }

#ifndef FOO_H #define FOO_H int Foo(void); // Good：头文件中声明对外接口 #endif

static void Bar(void); // Good: 对内函数的声明放在.c文件的头部，并声明为static限制其作用域 void Foo(void) { Bar(); } static void Bar(void) { // Do something; }

#ifndef TIMER_INCLUDE_TIMER_H #define TIMER_INCLUDE_TIMER_H ... #endif

extern int Foo(void); // Bad: 通过 extern 的方式引用外部函数 void Bar(void) { int i = Foo(); // 这里使用了外部接口 Foo ... }

#include "b.h"      // Good: 通过包含头文件的方式使用其他.c提供的接口 void Bar(void) { int i = Foo(); ... }

int Foo(void);

int Foo(void) { // Do something }

... #ifdef __cplusplus void Foo(int); #define A(value) Foo(value) #else void A(int) #endif

... #ifdef __cplusplus extern "C" { #endif #include "a.h" void B(void); #ifdef __cplusplus } #endif

extern "C" { void Foo(int); void B(void); }

int Foo(...) { if (received) { type = GetMsgType(msg); if (type != UNKNOWN) { return DealMsg(...); } } return -1; }

int Foo(...) { if (!received) { // Good: 使用'卫语句' return -1; } type = GetMsgType(msg); if (type == UNKNOWN) { return -1; } return DealMsg(..); }

char fileHead[128]; ReadFileHead(fileName, fileHead, sizeof(fileHead)); // Bad: 未检查返回值 DealWithFileHead(fileHead, sizeof(fileHead)); // fileHead 可能无效

char fileHead[128]; ret = ReadFileHead(fileName, fileHead, sizeof(fileHead)); if (ret != OK) { // Good: 确保 fileHead 被有效写入 return ERROR; } DealWithFileHead(fileHead, sizeof(fileHead)); // 处理文件头

struct FooNode { struct List link; int foo; }; struct BarNode { struct List link; int bar; } void FooListAddNode(void *node) // Bad: 这里用 void * 类型传递参数 { FooNode *foo = (FooNode *)node; ListAppend(&g_fooList, &foo->link); } void MakeTheList(...) { FooNode *foo; BarNode *bar; ... FooListAddNode(bar); // Wrong: 这里本意是想传递参数 foo，但错传了 bar，却没有报错 } 

void FooListAddNode(FooNode *foo) { ListAppend(&g_fooList, &foo->link); }

int SomeProc(...) { int data; bool dataOK = GetData(&data); // 获取数据 if (!dataOK) { // 检查上一步结果，其实也就保证了数据合法 return -1; } DealWithData(data); // 调用数据处理函数 ... } void DealWithData(int data) { if (data < MIN || data > MAX) { // Bad: 调用者已经保证了数据合法性 return; } ... }

int strncmp(const char *s1, const char *s2, size_t n); // Good：不变参数声明为const

inline int SomeInlineFunc(void);

inline int SomeInlineFunc(void) { // 实现代码 }

#include "inline.h" int OtherFunc(void) { int ret = SomeInlineFunc(); }

#define ASSERT(x) do { \  if (!(x)) { \  printk(KERN_EMERG "assertion failed %s: %d: %s\n", \  __FILE__, __LINE__, #x); \  BUG(); \  } \ } while (0)

#define MAX(a, b)   (((a) < (b)) ? (b) : (a)) int Max(int a, int b) { return (a < b) ? b : a; } int TestMacro(void) { unsigned int a = 1; int b = -1; (void)printf("MACRO: max of a(%u) and b(%d) is %d\n", a, b, MAX(a, b)); (void)printf("FUNC : max of a(%u) and b(%d) is %d\n", a, b, Max(a, b)); return 0; }

MACRO: max of a(1) and b(-1) is -1
FUNC : max of a(1) and b(-1) is 1

int ErrLog(const char *file, unsigned long line, const char *fmt, ...); #define ERR_LOG(fmt, ...) ErrLog(__FILE__, __LINE__, fmt, ##__VA_ARGS__)

#define SUM(a, b) a + b         // Bad.

#define SUM(a, b) (a + b)       // Bad.

#define SUM(a, b) (a) + (b)     // Bad.

#define SUM(a, b) ((a) + (b))   // Good.

#define SOME_CONST      100     // Good: 单独的数字无需括号 #define ANOTHER_CONST   (-1)    // Good: 负数需要使用括号 #define THE_CONST SOME_CONST    // Good: 单独的标识符无需括号

#define MAKE_STR(x) #x                  // x 不要加括号 #define HELLO_STR(obj) "Hello, " obj    // obj 不要加括号 #define ADD_3(sum, a, b, c) (sum = (a) + (b) + (c)) // a, b, c 需要括号；而 sum 无需括号 #define FOO(a, b) Bar((a) + 1, b)       // a 需要括号；而 b 无需括号

// Not Good. #define FOO(x) \  (void)printf("arg is %d\n", (x)); \  DoSomething((x));

for (i = 1; i < 10; i++) FOO(i);

#define FOO(x) { \  (void)printf("arg is %d\n", (x)); \  DoSomething((x)); \ }

if (condition) FOO(10); else FOO(20);

// Good. #define FOO(x) do { \  (void)printf("arg is %d\n", (x)); \  DoSomething((x)); \ } while (0)

#define SQUARE(a) ((a) * (a)) int a = 5; int b; b = SQUARE(a++); // Bad: 实际 a 自增加了 2 次

b = SQUARE(a); a++; // 结果：a = 6，只自增了一次。

#define LOG_AND_RETURN_IF_FAIL(ret, fmt, ...) do { \  if ((ret) != OK) {                             \  (void)ErrLog(fmt, ##__VA_ARGS__);          \  return (ret);                              \  }                                              \ } while (0) #define RETURN_IF(cond, ret) do {                  \  if (cond) {                                    \  return (ret);                              \  }                                              \ } while (0) ret = InitModuleA(a, b, &status); LOG_AND_RETURN_IF_FAIL(ret, "Init module A failed!"); // OK. RETURN_IF(status != READY, ERR_NOT_READY); // Bad: 重要逻辑不明显 ret = InitModuleB(c); LOG_AND_RETURN_IF_FAIL(ret, "Init module B failed!"); // OK.

#define CHECK_PTR(ptr, ret) do { \  if ((ptr) == NULL) { \  return (ret); \  } \ } while (0) ... mem1 = MemAlloc(...); CHECK_PTR(mem1, ERR_CODE_XXX); mem2 = MemAlloc(...); CHECK_PTR(mem2, ERR_CODE_XXX); // Wrong: 内存泄漏

void Foo(...) { int data; Bar(data); // Bad: 未初始化就使用 ... }

void Foo(...) { int data; if (...) { data = 100; } Bar(data); // Bad: 部分分支该值未初始化 ... }

int cnt = 0; // Bad: 冗余初始化，将会被后面直接覆盖 ... cnt = GetXxxCnt(); ...

char *buf = NULL; // Good: 这里用 NULL 代表默认值 if (condition) { buf = malloc(MEM_SIZE); } ... if (buf != NULL) { // 判断是否申请过内存 free(buf); }

char buf[VERY_BIG_SIZE] = {0}; memset(buf, 0, sizeof(buf)); // Bad: 冗余清零

void Foo(...) { int data = 0; // Bad: 习惯性的进行初始化 UseData(data); // 使用数据，本应该写在获取数据后面 data = GetData(...); // 获取数据 ... }

if (v == MAX) ... if (v < MAX) ...

x = b[i] + i++; // Bad: b[i]运算跟 i++，先后顺序并不明确。

x = b[i] + i; i++; // Good: 单独一行

Func(i++, i); // Bad: 传递第2个参数时，不确定自增运算有没有发生

i++; // Good: 单独一行 x = Func(i, i);

c = (a & 0xFF) + b; /* 涉及位操作符，需要括号 */

enum Color { RED, BLUE }; // 因为switch条件变量是枚举值，这里可以不用加default处理分支 switch (color) { case RED: DoRedThing(); break; case BLUE: DoBlueThing(); ... break; }

// Good: 使用 goto 实现单点返回 int SomeInitFunc(void) { void *p1; void *p2 = NULL; void *p3 = NULL; p1 = malloc(MEM_LEN); if (p1 == NULL) { goto EXIT; } p2 = malloc(MEM_LEN); if (p2 == NULL) { goto EXIT; } p3 = malloc(MEM_LEN); if (p3 == NULL) { goto EXIT; } DoSomething(p1, p2, p3); return 0; // OK. EXIT: if (p3 != NULL) { free(p3); } if (p2 != NULL) { free(p2); } if (p1 != NULL) { free(p1); } return -1; // Failed! }

char ch; unsigned short int exam; ch = -1; 
																																																																																																																																													

																																																																																																																																														exam = ch; // Bad: 编译器不产生告警，此时exam为0xFFFF。