奇怪的方式c语言,奇怪的C语言写法

C语言是一门博大精深的语言，有些高手灵活应用写出的代码使得我们有些菜鸟很难看得明白，这是对一些C语言的奇怪写法进行收录介绍：

一、do{}while(0)

linux内核和其他一些开源的代码中，经常会遇到这样的代码：

do{

...

}while(0)

这样的代码一看就不是一个循环，do..while表面上在这里一点意义都没有，那么为什么要这么用呢？

实际上，do{...}while(0)的作用远大于美化你的代码。查了些资料，总结起来这样写主要有以下几点好处：

1、辅助定义复杂的宏，避免引用的时候出错：

举例来说，假设你需要定义这样一个宏：

#define DOSOMETHING()\

foo1();\

foo2();

这个宏的本意是，当调用DOSOMETHING()时，函数foo1()和foo2()都会被调用。但是如果你在调用的时候这么写：

if(a>0)

DOSOMETHING();

因为宏在预处理的时候会直接被展开，你实际上写的代码是这个样子的：

if(a>0)

foo1();

foo2();

这就出现了问题，因为无论a是否大于0，foo2()都会被执行，导致程序出错。

那么仅仅使用{}将foo1()和foo2()包起来行么？

我们在写代码的时候都习惯在语句右面加上分号，如果在宏中使用{}，代码里就相当于这样写了：“{...};”，展开后就是这个样子：

if(a>0)

{

foo1();

foo2();

};

这样甚至不会编译通过。所以，很多人才采用了do{...}while(0);

#define DOSOMETHING() \

do{ \

foo1();\

foo2();\

}while(0)\

...

if(a>0)

DOSOMETHING();

...

这样，宏被展开后，才会保留初始的语义。GCC提供了Statement-Expressions用以替代do{...}while(0); 所以你也可以这样定义宏：

#define DOSOMETHING() ({\

foo1(); \

foo2(); \

})

http://www.spongeliu.com/

2、避免使用goto对程序流进行统一的控制：

有些函数中，在函数return之前我们经常会进行一些收尾的工作，比如free掉一块函数开始malloc的内存，goto一直都是一个比较简便的方法：

int foo()

{

somestruct* ptr = malloc(...);

dosomething...;

if(error)

{

goto END;

}

dosomething...;

if(error)

{

goto END;

}

dosomething...;

END:

free(ptr);

return 0;

}

由于goto不符合软件工程的结构化，而且有可能使得代码难懂，所以很多人都不倡导使用，那这个时候就可以用do{}while(0)来进行统一的管理：

int foo()

{

somestruct* ptr = malloc(...);

do{

dosomething...;

if(error)

{

break;

}

dosomething...;

if(error)

{

break;

}

dosomething...;

}while(0);

free(ptr);

return 0;

}

这里将函数主体使用do()while(0)包含起来，使用break来代替goto，后续的处理工作在while之后，就能够达到同样的效果。

3、避免空宏引起的warning

内核中由于不同架构的限制，很多时候会用到空宏，在编译的时候，空宏会给出warning，为了避免这样的warning，就可以使用do{}while(0)来定义空宏：

#define EMPTYMICRO do{}while(0)

4、定义一个单独的函数块来实现复杂的操作：

当你的功能很复杂，变量很多你又不愿意增加一个函数的时候，使用do{}while(0);，将你的代码写在里面，里面可以定义变量而不用考虑变量名会同函数之前或者之后的重复。

二、(void)(&__x == &__y);

在GCC的文档中建议使用如下的min宏定义：

#define min(X,Y)  \

(__extension__  \

({  \

typeof(X) __x=(X), __y=(Y);   \

(void)(&__x == &__y);\

(__x<__y>

}) \

)

本文讨论了这样作法的意义。

1、传统的min带来的副作用

2、GCC中的({statement list})的扩展

3、typeof(expression)

4、__extension__的含义

5、使用typeof和({})实现min，避免了副作用

附录1、旧版本的的GCC中的的解决方法

附录2、C++中使用template的解决方法

1、传统的min带来的副作用

min通常被定义成这样的宏：

#define min(X,Y) ((X) < (Y) ? (X) : (Y))

复制代码

这种定义会带来一些副作用，看下面的例子：

int x = 1, y = 2;

int main()

{

printf("min=%d\n", min(x++, y++));

printf("x = %d, y = %d\n", x, y);

}

复制代码

执行完min(x++、y++)，我们期望x的值为2，y的值为3。

但是，实际的结果是，执行完mini(x++、y++)后，x的值为3，y的值为3，原因在于宏展开后x++被执行了两次：

int x = 1, y = 2;;

int main()

{

printf("min=%d\n", x++ < y++ ? x++ : y++);

printf("x = %d, y = %d\n", x, y);

}

2、GCC中的({statement list})的扩展

({statement list})是一个表达式，逗号表达式类似，但是功能更强，({与})中可以包含有多条语句(可以是变量定义、复杂的控制语句)，该表达式的值为statement list中最后一条语句的值，举例：

int main()

{

int result = ({

int i, sum = 0;

for (i = 1; i <= 100; i++)

sum+= i;

sum;

})

printf("result=%d\n", result);

}

运行结果：

result=5050

复制代码

3、typeof(expression)

typeof(expression)用来获取expression的类型，举例：

int main()

{

int integer;

typeof(100) i;  /* 表达式100的类型是int，定义了int型变量i */

typeof(integer) j; /* 表达式integer的类型是int，定义了int型变量j */

i = 1;

j = 2;

}

复制代码

4、__extension__的含义

GCC引入了很多标准C中的没有的扩展，如({和)}，GCC提供了pednatic选项用于检测程序是否使用了GCC的扩展，当使用pedantic选项编译如下程序时

int main()

{

int result = ({

int i, sum = 0;

for (i = 1; i <= 100; i++)

sum+= i;

sum;

})

printf("result=%d\n", result);

}

复制代码

编译器发出警告：

$ cc -pedantic test.c

test.c: 在函数 ‘main’ 中：

test.c:9: 警告：ISO C 不允许在表达式中使用花括号组

复制代码

编译器提醒程序员，这段C程序使用了不符合ISO C标准的语法，如果使用其他的编译器(非GCC)编译这段代码有能会出错。在所有使用GNU 扩展关键字的表达式之前加__extension__ 关键字后，使用pedantic选项编译时，编译器就不再发出警告信息:

int main()

{

int result = __extension__({

int i, sum = 0;

for (i = 1; i <= 100; i++)

sum+= i;

sum;

})

printf("result=%d\n", result);

}

$ cc -pedantic test.c

$ 编译成功！

复制代码

5、使用typeof和({})实现min，避免了副作用

#define min(X,Y) \

({  \

typeof(X) __x=(X), __y=(Y);  \

(__x<__y>

})

复制代码

使用传统的min会出现问题的例子：

int x = 1, y = 2;;

int main()

{

printf("min=%d\n", min(x++, y++));

printf("x = %d, y = %d\n", x, y);

}

复制代码

它被扩展为

int x = 1, y = 2;;

int main()

{

printf("min=%d\n",

({

typeof(x) __x = (x++), __y = (y++);  /* 定义了两个整形变量 */

(void)(&__x == &__y);/*这样当类型不兼容时会有警告。尤其有符号和无符号的比较，这很重要。*/

(__x<__y>

})

);

printf("x = %d, y = %d\n", x, y);

}

在执行min(x++, y++)期间，x++和y++只执行了一次，因而结果是正确的。

三 、#define pr_debug(fmt,arg...) \

标准C只支持可变参数的函数，意味着函数的参数是不固定的，例如printf()函数

的原型为：

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

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

#define pr_debug(fmt,arg...) \

printk(fmt,##arg)

这里arg 表示其余的参数可以是零个或多个，这些参数以及参数之间的逗号构成

arg 的值，在宏扩展时替换arg，例如下列代码：

pr_debug("%s:%d",filename,line)

会被扩展为：

printk("%s:%d", filename, line)四、GCC下 特殊的数组声明

struct ast_app_option {

unsigned int flag;

unsigned int arg_index;

};

static const struct ast_app_option read_app_options[128] = {

['s'] = { .flag = OPT_SKIP },

['i'] = { .flag = OPT_INDICATION },

['n'] = { .flag = OPT_NOANSWER },

}

这段代码目的很灵巧，就是建立一个用字母做数组index的128位数数组,而且结构体的赋值直接用了{.flag=xxxxx}的简单方法，这是linux c特有的写法。