本节书摘来华章计算机出版社《Linux设备驱动开发详解 A》一书中的第3章，第3.5节，作者：宋宝华 更多章节内容可以访问云栖社区“华章计算机”公众号查看。1

3.5　Linux下的C编程特点

3.5.1　Linux编码风格
Linux有独特的编码风格，在内核源代码下存在一个文件Documentation/CodingStyle，进行了比较详细的描述。
Linux程序的命名习惯和Windows程序的命名习惯及著名的匈牙利命名法有很大的
不同。
在Windows程序中，习惯以如下方式命名宏、变量和函数：

#def?ine PI 3.1415926    /* 用大写字母代表宏 */
int minValue, maxValue;    /* 变量：第一个单词全小写，其后单词的第一个字母大写 */
void SendData(void);    /* 函数：所有单词第一个字母都大写 */

这种命名方式在程序员中非常盛行，意思表达清晰且避免了匈牙利法的臃肿，单词之间通过首字母大写来区分。通过第1个单词的首字母是否大写可以区分名称属于变量还是属于函数，而看到整串的大写字母可以断定为宏。实际上，Windows的命名习惯并非仅限于Windows编程，许多领域的程序开发都遵照此习惯。
但是Linux不以这种习惯命名，对于上面的一段程序，在Linux中它会被命名为：

#def?ine PI 3.1415926 
int min_value, max_value;
void send_data(void);

在上述命名方式中，下划线大行其道，不按照Windows所采用的用首字母大写来区分单词的方式。Linux的命名习惯与Windows命名习惯各有千秋，但是既然本书和本书的读者立足于编写Linux程序，代码风格理应与Linux开发社区保持一致。
Linux的代码缩进使用“TAB”。
Linux中代码括号“{”和“}”的使用原则如下。
1）对于结构体、if/for/while/switch语句，“{”不另起一行，例如：

struct var_data {
   int len;
   char data[0];
};

if (a == b) {
     a = c;
     d = a;
}

for (i = 0; i < 10; i++) {
     a = c;
     d = a;
}

2）如果if、for循环后只有1行，不要加“{”和“}”，例如：

for (i = 0; i < 10; i++) {
      a = c;
}
应该改为：
for (i = 0; i < 10; i++) 
      a = c;

3）if和else混用的情况下，else语句不另起一行，例如：

if (x == y) {
    ...
} else if (x > y) {
    ...
} else {
  ...
}

4）对于函数，“{”另起一行，譬如：

int add(int a, int b)
{
     return a + b;
}

在switch/case语句方面，Linux建议switch和case对齐，例如：

switch (suff?ix) {
case 'G':
case 'g':
      mem <<= 30;
      break;
case 'M':
case 'm':
      mem <<= 20;
      break;
case 'K':
case 'k':
      mem <<= 10;
      /* fall through */
default:
      break;
}

内核下的Documentation/CodingStyle描述了Linux内核对编码风格的要求，内核下的scripts/checkpatch.pl提供了1个检查代码风格的脚本。如果使用scripts/checkpatch.pl检查包含如下代码块的源程序：

for (i = 0; i < 10; i++) {
      a = c;
}

就会产生“WARNING: braces {} are not necessary for single statement blocks”的警告。
另外，请注意代码中空格的应用，譬如“for?(i?=?0; ?i?<?10; ?i++)?{”语句中的“?”都是空格。
在工程阶段，一般可以在SCM软件的服务器端使能pre-commit hook，自动检查工程师提交的代码是否符合Linux的编码风格，如果不符合，则自动拦截。git的pre-commit hook可以运行在本地代码仓库中，如Ben Dooks完成的一个版本：

#!/bin/sh
#
# pre-commit hook to run check-patch on the output and stop any commits
# that do not pass. Note, only for git-commit, and not for any of the
# other scenarios
#
# Copyright 2010 Ben Dooks, <ben-linux@fluff.org>

if git rev-parse --verify HEAD 2>/dev/null >/dev/null
then
    against=HEAD
else
    # Initial commit: diff against an empty tree object
    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
f?i

git diff --cached $against -- | ./scripts/checkpatch.pl --no-signoff -

3.5.2　GNU C与ANSI C
Linux上可用的C编译器是GNU C编译器，它建立在*软件基金会的编程许可证的基础上，因此可以*发布。GNU C对标准C进行一系列扩展，以增强标准C的功能。
1.?零长度和变量长度数组
GNU C允许使用零长度数组，在定义变长对象的头结构时，这个特性非常有用。例如：

struct var_data {
   int len;
   char data[0];
};

char data[0]仅仅意味着程序中通过var_data结构体实例的data[index]成员可以访问len之后的第index个地址，它并没有为data[]数组分配内存，因此sizeof(struct var_data)=sizeof(int)。
假设struct var_data的数据域就保存在struct var_data紧接着的内存区域中，则通过如下代码可以遍历这些数据：

struct var_data s;
...
for (i = 0; i < s.len; i++)
    printf("%02x", s.data[i]);

GNU C中也可以使用1个变量定义数组，例如如下代码中定义的“double x[n]”：

int main (int argc, char *argv[])
{
    int i, n = argc;
    double x[n];

    for (i = 0; i < n; i++)
       x[i] = i;

    return 0;
}

2.?case范围
GNU C支持case x…y这样的语法，区间[x,y]中的数都会满足这个case的条件，请看下面的代码：

switch (ch) {
case '0'... '9': c -= '0';
   break;
case 'a'... 'f': c -= 'a' - 10;
   break;
case 'A'... 'F': c -= 'A' - 10;
   break;
}

代码中的case '0'... '9'等价于标准C中的：

case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':

3.?语句表达式
GNU C把包含在括号中的复合语句看成是一个表达式，称为语句表达式，它可以出现在任何允许表达式的地方。我们可以在语句表达式中使用原本只能在复合语句中使用的循环、局部变量等，例如：

#def?ine min_t(type,x,y) \
(｛type _ _x =(x);type _ _y = (y); _ _x<_ _y? _ _x: _ _y; })

int ia, ib, mini;
float fa, fb, minf;

mini = min_t(int, ia, ib);
minf = min_t(float, fa, fb);

因为重新定义了_ xx和 _y这两个局部变量，所以用上述方式定义的宏将不会有副作用。在标准C中，对应的如下宏则会产生副作用：

def?ine min(x,y) ((x) < (y) ? (x) : (y))

代码min(++ia,++ib)会展开为((++ia) < (++ib) ? (++ia): (++ib))，传入宏的“参数”增加
两次。
4.?typeof关键字
typeof(x)语句可以获得x的类型，因此，可以借助typeof重新定义min这个宏：

#def?ine min(x,y) ({        \
 const typeof(x) _x = (x);    \
 const typeof(y) _y = (y);    \
 (void) (&_x == &_y);        \
 _x < _y ? _x : _y; })

我们不需要像min_t(type,x,y)那个宏那样把type传入，因为通过typeof(x)、typeof(y)可以获得type。代码行(void) (&_x == &_y)的作用是检查_x和_y的类型是否一致。
5.?可变参数宏
标准C就支持可变参数函数，意味着函数的参数是不固定的，例如printf()函数的原
型为：

int printf( const char *format [, argument]... );

而在 GNU C中，宏也可以接受可变数目的参数，例如：

#def?ine pr_debug(fmt,arg...) \
             printk(fmt,##arg)

这里arg表示其余的参数，可以有零个或多个参数，这些参数以及参数之间的逗号构成arg的值，在宏扩展时替换arg，如下列代码：

pr_debug("%s:%d",f?ilename,line)

会被扩展为：

printk("%s:%d", f?ilename, line)

6.?标号元素
标准C要求数组或结构体的初始化值必须以固定的顺序出现，在GNU C中，通过指定索引或结构体成员名，允许初始化值以任意顺序出现。
指定数组索引的方法是在初始化值前添加“[INDEX] =”，当然也可以用“[FIRST ... LAST] =”的形式指定一个范围。例如，下面的代码定义了一个数组，并把其中的所有元素赋值为0：

unsigned char data[MAX] = { [0 ... MAX-1] = 0 };

下面的代码借助结构体成员名初始化结构体：

struct f?ile_operations ext2_f?ile_operations = {
   llseek: generic_f?ile_llseek,
   read: generic_f?ile_read,
   write: generic_f?ile_write,
   ioctl: ext2_ioctl,
   mmap: generic_f?ile_mmap,
   open: generic_f?ile_open,
   release: ext2_release_f?ile,
   fsync: ext2_sync_f?ile,
};

但是，Linux 2.6推荐类似的代码应该尽量采用标准C的方式：
s`javascript
truct f?ile_operations ext2_f?ile_operations = {

 .llseek        = generic_f?ile_llseek,
 .read        = generic_f?ile_read,
 .write    = generic_f?ile_write,
 .aio_read    = generic_f?ile_aio_read,
 .aio_write    = generic_f?ile_aio_write,
 .ioct        = ext2_ioctl,
 .mmap        = generic_f?ile_mmap,
 .open        = generic_f?ile_open,
 .release = ext2_release_f?ile,
 .fsync    = ext2_sync_f?ile,
 .readv    = generic_f?ile_readv,
 .writev    = generic_f?ile_writev,
 .sendf?ile    = generic_f?ile_sendf?ile,

};

7.?当前函数名
GNU C预定义了两个标识符保存当前函数的名字，_ _FUNCTION_ _保存函数在源码中的名字，_ _PRETTY_FUNCTION_ _保存带语言特色的名字。在C函数中，这两个名字是相同的。

void example()
{
printf("This is function:%s", _?_FUNCTION_?_);
}

代码中的_ _FUNCTION_ _意味着字符串“example”。C99已经支持_ _func_ _宏，因此建议在Linux编程中不再使用_ _FUNCTION_ _，而转而使用_ _func_ _：

void example(void)
{
printf("This is function:%s", _?_func_?_);
}

8.?特殊属性声明
GNU C允许声明函数、变量和类型的特殊属性，以便手动优化代码和定制代码检查的方法。要指定一个声明的属性，只需要在声明后添加_?_attribute_?_ (( ATTRIBUTE ))。其中ATTRIBUTE为属性说明，如果存在多个属性，则以逗号分隔。GNU C支持noreturn、format、section、aligned、packed等十多个属性。
noreturn属性作用于函数，表示该函数从不返回。这会让编译器优化代码，并消除不必要的警告信息。例如：
# def?ine ATTRIB_NORET  _?_attribute_?_((noreturn)) ....
asmlinkage NORET_TYPE void do_exit(long error_code) ATTRIB_NORET;
format属性也用于函数，表示该函数使用printf、scanf或strftime风格的参数，指定format属性可以让编译器根据格式串检查参数类型。例如：
asmlinkage int printk(const char * fmt, ...) _?_attribute_?_ ((format (printf, 1, 2)));
上述代码中的第1个参数是格式串，从第2个参数开始都会根据printf()函数的格式串规则检查参数。
unused属性作用于函数和变量，表示该函数或变量可能不会用到，这个属性可以避免编译器产生警告信息。
aligned属性用于变量、结构体或联合体，指定变量、结构体或联合体的对齐方式，以字节为单位，例如：

struct example_struct {

char a;
int b;
long c;

} _?_attribute_?_((aligned(4)));

表示该结构类型的变量以4字节对齐。
packed属性作用于变量和类型，用于变量或结构体成员时表示使用最小可能的对齐，用于枚举、结构体或联合体类型时表示该类型使用最小的内存。例如：

struct example_struct {

char a;
int b;
long c  _?_attribute_?_((packed));

};

编译器对结构体成员及变量对齐的目的是为了更快地访问结构体成员及变量占据的内存。例如，对于一个32位的整型变量，若以4字节方式存放（即低两位地址为00），则CPU在一个总线周期内就可以读取32位；否则，CPU需要两个总线周期才能读取32位。
9.?内建函数
GNU C提供了大量内建函数，其中大部分是标准C库函数的GNU C编译器内建版本，例如memcpy()等，它们与对应的标准C库函数功能相同。
不属于库函数的其他内建函数的命名通常以_ _builtin开始，如下所示。
内建函数_ _builtin_return_address (LEVEL)返回当前函数或其调用者的返回地址，参数LEVEL 指定调用栈的级数，如0表示当前函数的返回地址，1表示当前函数的调用者的返回地址。
内建函数_ _builtin_constant_p(EXP)用于判断一个值是否为编译时常数，如果参数EXP 的值是常数，函数返回1，否则返回0。
例如，下面的代码可检测第1个参数是否为编译时常数以确定采用参数版本还是非参数版本：

def?ine test_bit(nr,addr) \

(_?_builtin_constant_p(nr) ? \
constant_test_bit((nr),(addr)) : \
variable_test_bit((nr),(addr)))

内建函数_ _builtin_expect(EXP, C)用于为编译器提供分支预测信息，其返回值是整数表达式EXP的值，C的值必须是编译时常数。
Linux内核编程时常用的likely()和unlikely()底层调用的likely_notrace()、unlikely_notrace() 就是基于_ _builtin_expect(EXP, C)实现的。
#def?ine likely_notrace(x)       __builtin_expect(!!(x), 1)
#def?ine unlikely_notrace(x)     __builtin_expect(!!(x), 0)
若代码中出现分支，则即可能中断流水线，我们可以通过likely()和unlikely()暗示分支容易成立还是不容易成立，例如：

if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))

if (ipv4_is_loopback(saddr))
    goto e_inval;

在使用gcc编译C程序的时候，如果使用“-ansi –pedantic”编译选项，则会告诉编译器不使用GNU扩展语法。例如对于如下C程序test.c：

struct var_data {
int len;
char data[0];
};

struct var_data a;

直接编译可以通过：

gcc -c test.c

如果使用“-ansi –pedantic”编译选项，编译会报警：

gcc -ansi -pedantic -c test.c

test.c:3: warning: ISO C forbids zero-size array 'data'
**3.5.3　do { } while(0) 语句**
在Linux内核中，经常会看到do {} while(0)这样的语句，许多人开始都会疑惑，认为do {} while(0)毫无意义，因为它只会执行一次，加不加do {} while(0)效果是完全一样的，其实do {} while(0)的用法主要用于宏定义中。
这里用一个简单的宏来演示：
#def?ine SAFE_FREE(p) do{ free(p); p = NULL;} while(0)
假设这里去掉do...while(0)，即定义SAFE_DELETE为：
#def?ine SAFE_FREE(p) free(p); p = NULL;
那么以下代码：

if(NULL != p)
SAFE_DELETE(p)
else
.../ do something /

会被展开为：

if(NULL != p)
free(p); p = NULL;
else
.../ do something /

展开的代码中存在两个问题：
1）因为if分支后有两个语句，导致else分支没有对应的if，编译失败。
2）假设没有else分支，则SAFE_FREE中的第二个语句无论if测试是否通过，都会执行。
的确，将SAFE_FREE的定义加上{}就可以解决上述问题了，即：
#def?ine SAFE_FREE(p) { free(p); p = NULL;}
这样，代码：

if(NULL != p)

SAFE_DELETE(p)

else

... /* do something */

会被展开为：

if(NULL != p)
{ free(p); p = NULL; }
else

... /* do something */

但是，在C程序中，在每个语句后面加分号是一种约定俗成的习惯，那么，如下代码：

if(NULL != p)

SAFE_DELETE(p);

else

... /* do something */

将被扩展为：
if(NULL != p)
{ free(p); p = NULL; };
else
... / do something /

这样，else分支就又没有对应的if了，编译将无法通过。假设用了do {} while(0)语句，情况就不一样了，同样的代码会被展开为：

if(NULL != p)

do{ free(p); p = NULL;} while(0);

else

... /* do something */

而不会再出现编译问题。do{} while(0)的使用完全是为了保证宏定义的使用者能无编译错误地使用宏，它不对其使用者做任何假设。
**3.5.4　goto语句**
用不用goto一直是一个著名的争议话题，Linux内核源代码中对goto的应用非常广泛，但是一般只限于错误处理中，其结构如：

if(register_a()!=0)

 goto err;

if(register_b()!=0)

 goto err1;

if(register_c()!=0)

 goto err2;

if(register_d()!=0)

 goto err3;

...

err3:

unregister_c();

err2:

unregister_b();

err1:

unregister_a(); 

err:

return ret;

这种将goto用于错误处理的用法实在是简单而高效，只需保证在错误处理时注销、资源释放等，与正常的注册、资源申请顺序相反。