本文主要是介绍奇怪的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)?__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)?__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)?__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特有的写法。
这篇关于奇怪的C语言写法的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
