Clang 宏定义初探（二）

superlong — Thu, 10 Mar 2016 17:20:00 GMT

Clang 宏定义初探（二）

本篇总结下这几天看的宏的一些看到的用法。

1、参数粘结

这是一个类似 shell 之类的脚本语言的特性，可以利用这个特性完成一些重复度比较高的编码的简化。
例如，对proc文件系统进行绑定的时候，需要在/proc/test/目录下，简历3个文件接口，test1、test2、test3.
可以这样写

#define BIND(x) test##x->read_proc=test##x##_read

在使用的时候，就可以

BIND(1); //展开为test1->read_proc=test1_read;
BIND(2); //展开为test2->read_proc=test2_read;

不管是从语义还是编码复杂度，都降低了。

2、参数字符化

在使用单个 # 号，作为函数式宏的参数前缀时，可以让宏的内容变成字符串，比如说：

#define print(x) do{\
printf(#x);\
printf("=%d\n",x);\
}while(0)

使用的时候，直接写：

int t = 1;
print(t);

结果会是 t=1，这个在做日志的时候还是非常好用的。

3、do{...}while(0) 和 ({...})

可以认为是前者是 void 函数，后者是有 return 值的函数。
入2中所示，do{...}while(0) 是为了产生一个程序块，当宏里有多条需要语句需要执行时，如果不适用这种do{...}while(0)的形式，可能导致一些隐形的错误,例如：

#define print(x) {printf(#x);printf("=%d\n",x);

正常的：
print(t); 是没有问题的，但是如果放在程序段里：

if( flag )
print(t);
else
print(a);

展开之后，会发现为

if( flag )
{printf("t");printf("=%d\n",t);};
else

这个语法就错了。因此，当代码段比较多，且不需要返回值时就用 do{...}while(0)吧。
另外一种方式属于 GNU 的扩展，后续在看。

4、多重展开

还是基于打印的例子，我需要打印一些列举的参数值：

#define P(x) arg##x
#define print(x) do{printf(#P(x));printf("=%d\n",P(x));}while(0)

这个编译通不过，换成以下方式即可：

#define P(x) arg##x
#define __print(x) do{printf(#x);printf("=%d\n",x);}while(0)
#define _print(x) __print(x)
#define print(x) _print(P(x))

修改成这样，解决了想要的解决的问题：

int arg1 = 1;
print(1);

输出结果为：arg1=1
主要涉及的问题在于宏的多次展开，宏每次展开只会对当前的输入参数进行一次展开，当你的输入值也是个宏的时候，就需要使用过度宏，让你的输入接着展开。
对于多次展开没有从最根本的原理解释，只是从实验感官上对这个特性做了分析，实际上，自己也不会写出那么复杂的宏（怕中间调用出漏洞）。

宏的基本常见用法，都差不多枚举了一番，往后在见到更高级的玩法和比较精髓的写法往后再慢慢补充上来吧，另外GNU的扩展也会在后篇继续学习了解。

superlong 2016-03-11 01:20 发表评论

clang 宏定义初探（一）

superlong — Tue, 08 Mar 2016 00:44:00 GMT

Clang 宏定义初探（一）

宏的定义方法是#define
那么在什么场景下需要用到宏呢？遇到一些重复的东西，简单的有 for(i = 0; i < n; i ++) 之类的，为了减少繁琐的编码，可能使用

#define FO(i,N) for(i=0;i 为了增强可读性，比如说设置一个数组常亮大小，可以使用

#define N 1001

宏看起来感觉很好用，但是潜藏了很多问题，在实际使用中需要小心谨慎（当然带来大部分问题的，还是编码者自己或者合作方）。
例如，现在要求两个数的最小值，最初会写出如下宏：

#define MIN(A,B) A 正常情况下也是可以使用无误的：

1 #include
2 #define MIN(A,B) A 3 int main()
4 {
5 int a =5, b =6;
6 printf("%d", MIN(a, b));
7 }

然而，当你发布你的代码或者很久以后自己再去调用时，可能写成：

MIN(a<4?a:5, b)

看起来也没啥问题，实际执行一下发现，结果是5，偏离预期！事实上，宏即使单纯的代码展开，当你展开上面的式子之后会发现，实际执行的代码是

a<4?a:5 对于一直用括号来解决优先级问题的我来说，这种展开完全无法理解，于是参看了内核代码，发现更安全的写法为：

#define MIN(A,B) (A)<(B)?(A):(B)

这种写法规避了令人厌恶的优先级问题！本以为这样就完成了一个安全的宏定义，但是事实上还有其他问题！

float a = 1.0f;
float b = MIN(a++, 1.5f);
printf("a=%f, b=%f",a,b);

神秘的a++，同样按照刚才的思路展开，因为宏里面会有两次A的展开，所以a++将被执行两次，再次偏离预期。对于这种情况，我们需要用到一个GNU C的赋值扩展，即使用({...})的形式。这种形式的语句可以类似shell，在顺次执行之后，会将最后一次的表达式的赋值作为返回。举个简单的例子，下面的代码执行完毕后a的值为3，而且b和c只存在于大括号限定的代码域中：

int a = ({
    int b = 1;
    int c = 2;
    b + c;
});

结果是// => a is 3
基于这种特性，我们可以在宏里面为每个传入的参数进行一个拷贝，然后再对拷贝后的参数进行实际的比较运算，那么最终实现了一个比较安全的最小值比较的宏定义：

#define  min(x,y)  ({                   \
    typeof(x)  __min1 = (x);        \
    typeof(y) __min2 = (y);             \
    (void)  (& __min1 == & __min2);     \
    __min1 < __min2  ? __min1 :min2})

最后这一步跳跃有点大了，首先是 typeof 作用是得到参数的类型，其次是(void) (& __min1 == & __min2); 这个神秘的写法是为了验证二者的类型是否一致，当然外侧我们确实用了GNU的扩展({...})。
写到这里，涉及到了另外两个问题，GNU扩展是啥？另外我们用宏是为了节省代码，同时为了省去一些小函数的多次重复调用的参数入栈降低性能的问题，那么内联函数也有这样的效果，什么是内联函数呢？

superlong 2016-03-08 08:44 发表评论

C++博客-学习心得（code）-随笔分类-C

Clang 宏定义初探（二）

Clang 宏定义初探（二）

1、参数粘结

2、参数字符化

3、do{...}while(0) 和 ({...})

4、多重展开

clang 宏定义初探（一）

Clang 宏定义初探（一）