对min(a,b)这个宏的讨论

missjiang

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

#define min(X,Y)  \
(__extension__  \
({  \
   typeof(X) __x=(X), __y=(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通常被定义成这样的宏：

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

复制代码

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

1. 
   
2. int x = 1, y = 2;
   
3. int main()
   
4. {
   
5.    printf("min=%d\n", min(x++, y++));
   
6.    printf("x = %d, y = %d\n", x, y);
   
7. }
   

复制代码

执行完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中最后一条语句的值，举例：

1. 
   
2. int main()
   
3. {
   
4.     int result = ({
   
5.      int i, sum = 0;
   
6.      for (i = 1; i <= 100; i++)
   
7.           sum+= i;
   
8.      sum;
   
9.     })
   
10.     printf("result=%d\n", result);
    
11. }
    
12. 运行结果：
    
13. result=5050

复制代码

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

1. 
   
2. int main()
   
3. {
   
4.    int integer;
   
5.    typeof(100) i;  /* 表达式100的类型是int，定义了int型变量i */
   
6.    typeof(integer) j; /* 表达式integer的类型是int，定义了int型变量j */
   
7.    
   
8.    i = 1;
   
9.    j = 2;
   
10. }
    

复制代码

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

1. 
   
2. int main()
   
3. {
   
4.     int result = ({
   
5.      int i, sum = 0;
   
6.      for (i = 1; i <= 100; i++)
   
7.           sum+= i;
   
8.      sum;
   
9.     })
   
10.     printf("result=%d\n", result);
    
11. }
    

复制代码

编译器发出警告：

1. 
   
2. $ cc -pedantic test.c
   
3. test.c: 在函数 ‘main’ 中：
   
4. test.c:9: 警告：ISO C 不允许在表达式中使用花括号组
   

复制代码

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

1. 
   
2. int main()
   
3. {
   
4.     int result = __extension__({
   
5.     int i, sum = 0;
   
6.      for (i = 1; i <= 100; i++)
   
7.           sum+= i;
   
8.      sum;
   
9.     })
   
10.     printf("result=%d\n", result);
    
11. }
    
12. $ cc -pedantic test.c
    
13. $ 编译成功！
    

复制代码

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

1. 
   
2. #define min(X,Y) \
   
3. ({  \
   
4. typeof(X) __x=(X), __y=(Y);  \
   
5. (__x<__y)?__x:__y;  \
   
6. })
   

复制代码

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

1. 
   
2. int x = 1, y = 2;;
   
3. int main()
   
4. {
   
5.    printf("min=%d\n", min(x++, y++));
   
6.    printf("x = %d, y = %d\n", x, y);
   
7. }
   

复制代码

它被扩展为

int x = 1, y = 2;;
int main()
{
   printf("min=%d\n",
   ({
       typeof(x) __x = (x++), __y = (y++);  /* 定义了两个整形变量 */
       (__x<__y)?__x:__y;
   })
   );
   printf("x = %d, y = %d\n", x, y);
}

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

附录1、旧版本的的GCC中的的解决方法
旧版本的GCC提供了两个内置的运算操作符：<?和>?， <?返回两个操作数中较小的一个，>?返回两个操作数中较大的一个，使用这两个操作符定义的min如下:

1. 
   
2. #define min(x, y) ((x) <? (y))
   
3. #define max(x, y) ((x) >? (y))
   

复制代码

但是新版本的GCC文档中宣称：现在这两个运算操作符已经过时了，建议大家不要使用。

附录2、C++中使用template的解决方法
template <class type>
type min(type a, type b)
{
     return a < b ? a : b;
}

mik

顶~ 很好很清楚

白天晒太阳

missjiang

像这样的写法：func(i++, i++)带来的问题，可以被看作是由i++、++i的副作用引起的。

使用传统的min导致上述程序出现问题的原因在于：x++被错误的执行了两次，这应该归结于宏的副作用，而与i++、++i的副作用无关。即使不使用i++、++i，宏min(a,b)执行时a、b之间的较小者被执行两次的副作用也是存在的，比如说：

1. 
   
2. int funcX()
   
3. {
   
4.    printf("This is func X\n");
   
5.    return 1;
   
6. }
   
7. 
   
8. int funcY()
   
9. {
   
10.    printf("This is func Y\n");
    
11.    return 2;
    
12. }
    
13. 
    
14. int main()
    
15. {
    
16.    min(funcX(), funcY());
    
17. }
    

复制代码

程序执行时，"This is func X"被打印了两次，显然不是我们期望的。

当然，我们可以保守的使用：

1. 
   
2. int main()
   
3. {
   
4.    int x = funcX();
   
5.    int y = funcY();
   
6.    min(x, y);
   
7. }
   
8. 
   

复制代码

显然，使用gcc文档中建议的min，可以使代码比较简洁。

emacsnw

原帖由 missjiang 于 2007-5-12 01:15 发表
像这样的写法：func(i++, i++)带来的问题，可以被看作是由i++、++i的副作用引起的。

使用传统的min导致上述程序出现问题的原因在于：x++被错误的执行了两次，这应该归结于宏的副作用，而与i++、++i的副作用 ...

这贴不错，顶一个。
为了可移植性，一般还要定义一个非GNUC版本的MIN/MAX，不知道怎样才能比较好的避免这个side effect？

mingyanguo

能不用gcc的扩展还是不要用的好，至于说副作用，这是宏本身的原因，程序员应该意识到这个问题。

delimy

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

nully

简单的问题复杂化，写成 inline的函数都比这个好。

langue

.

我的个人信仰是，简单的事情简单解决，复杂的事情简化以后一样解决。

由此，inline 是较好的解决方案之一。

个人信仰，仅供参考。

.