c语言宏swap,【C语言】Linux内核源码--min,swap宏定义

Linux3.5的部分宏定义在linux-3.5/include/linux/kernel.h的头文件中有定义

一： 最大值和最小值相关的宏

/*

* min()/max()/clamp() macros that also do

* strict type-checking.. See the

* "unnecessary" pointer comparison.

*/

#define min(x, y) ({

typeof(x) _min1 = (x);

typeof(y) _min2 = (y);

(void) (&_min1 == &_min2);

_min1 < _min2 ? _min1 : _min2; })

#define max(x, y) ({

typeof(x) _max1 = (x);

typeof(y) _max2 = (y);

(void) (&_max1 == &_max2);

_max1 > _max2 ? _max1 : _max2; })

#define min3(x, y, z) ({

typeof(x) _min1 = (x);

typeof(y) _min2 = (y);

typeof(z) _min3 = (z);

(void) (&_min1 == &_min2);

(void) (&_min1 == &_min3);

_min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) :

(_min2 < _min3 ? _min2 : _min3); })

#define max3(x, y, z) ({

typeof(x) _max1 = (x);

typeof(y) _max2 = (y);

typeof(z) _max3 = (z);

(void) (&_max1 == &_max2);

(void) (&_max1 == &_max3);

_max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) :

(_max2 > _max3 ? _max2 : _max3); })

以上几个宏会做严格的类型检查

(void) (&_min1 == &_min2);

表面看起来，这句话，好像不起作用，算是一句废话，其实作用还是比较大的。首先，我们此处想要实现的目的是，在计算两个数的最小值之前，希望去判断一下两个值的类型是否一致，而由于C语言本身不支持我们去做类似于这样的操作typeof(_x)==typeof(_y)，所以在此，通过故意判断他们2个的地址指针是否相等，而显然&_x，即x的地址，是不可能等于&_y的，但是这句话(void) (&_x == &_y);使得，如果_x和_y的类型不一样，其指针类型也会不一样，2个不一样的指针类型进行比较操作，则会引起编译器产生一个编译警告，提示你这两个值的类型不同。通过void显式丢弃一个表达式的值，否则有些编译器会就此给出警告信息。

比如看看如下代码：

编译的时候，经过预处理后，就会有这样的判断操作：

int * == char *;

因此编译器就会提示你：

warning: comparison of distinct pointer types lacks a cast(警告：比较不相关的指针时缺少类型转换)

所以，这个宏的巧妙之处就在于此。

所以，总结起来就是：

【提示】

1。其实关于min的宏，更好的做法是再加个const，即：

#define min(x, y) ({

const typeof(x) _min1 = (x);

const typeof(y) _min2 = (y);

(void) (&_min1 == &_min2);

_min1 < _min2 ? _min1 : _min2; })

2。(void) (&_x == &_y); 中的void，表示将表达式(&_x == &_y); 所得到的结果(此处肯定是逻辑上的假，值为0)忽略掉。如果不加void，则会提示你这行代码是无意义的，没人用到，有些编译器会产生警告信息。

3。关于min的宏定义，为何这么复杂，而不是用简单的#define min(x,y) ((x) < (y) ? x : y)

因为，如果如此定义，那么对于一些特殊的值传入此宏之后，就会产生一些副作用，产生的结果，就不是我们想要的了，比如：

min(++a,++b) ==> ((++a)

就使得，a++和b++分别执行了2次，而且min的结果，也不对了。而用上面那个复杂的定义，多加了局部变量_x和_y,就可以避免此类问题了。

二、 其它相关宏的分析

/**

* min_not_zero - return the minimum that is _not_ zero, unless both are zero

* @x: value1

* @y: value2

*/

#define min_not_zero(x, y) ({

typeof(x) __x = (x);

typeof(y) __y = (y);

__x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })

/*

* ..and if you can't take the strict

* types, you can specify one yourself.

*

* Or not use min/max/clamp at all, of course.

*/

#define min_t(type, x, y) ({

type __min1 = (x);

type __min2 = (y);

__min1 < __min2 ? __min1: __min2; })

#define max_t(type, x, y) ({

type __max1 = (x);

type __max2 = (y);

__max1 > __max2 ? __max1: __max2; })

/*

* swap - swap value of @a and @b

*/

#define swap(a, b)

do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) swap是交换两个变量的值的宏，可以支持所有的基本类型。