14、宏实现最小/最大值：经典MAX/MIN宏的实现，类型安全版本，GCC的typeof扩展

说到宏，我估计每个C程序员最早接触的经典案例就是MAX和MIN。这东西看起来简单，不就是比个大小吗？但说实话，我在项目里见过太多因为这两个宏翻车的案例了。今天咱们就把这个看似简单、实则暗藏玄机的话题彻底讲透。

14.1 经典MAX/MIN宏——先跑起来再说

最朴素的写法，大家肯定都见过：

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

嗯，这里要注意：每个参数都加了括号。为什么？因为宏是文本替换，不加括号的话，传个表达式进去就全乱套了。比如 MAX(x & 1, y)，如果不加括号，展开后变成 x & 1 > y ? x & 1 : y，优先级直接爆炸。

但就算加了括号，这个版本也有个大坑——参数副作用。我当年刚入行时就吃过这个亏：

int arr[] = {1, 2, 3, 4, 5};
int *p = arr;
int max = MAX(*p++, *p++);  // 你猜p被加了几次？

展开后变成 ((*p++) > (*p++) ? (*p++) : (*p++))，p被加了两次甚至三次，结果完全不可预测。这就是宏的经典问题：参数被多次求值。

14.2 类型安全版本——用内联函数来救场

那怎么解决副作用问题？C语言里最靠谱的办法就是内联函数。C99引入了inline关键字，我们可以这样写：

static inline int max_int(int a, int b) {
    return a > b ? a : b;
}

static inline double max_double(double a, double b) {
    return a > b ? a : b;
}

这样参数只求值一次，副作用问题自然消失。但问题来了——你得为每种类型写一个版本。int、long、float、double……想想就头大。

我个人的习惯是，在项目里定义一个通用的类型安全宏，配合GCC的扩展来实现。不过在那之前，咱们先看看C11的_Generic方案：

#define MAX(a, b) _Generic((a), \
    int: max_int, \
    long: max_long, \
    float: max_float, \
    double: max_double \
)(a, b)

这个写法虽然类型安全了，但维护成本高——每加一种类型就得改宏定义。说实话，我在实际项目中很少这么用，太啰嗦了。

14.3 GCC的typeof扩展——真正的优雅方案

如果你用的是GCC（或者兼容GCC的编译器，比如Clang），那就有个好东西——typeof。它能获取表达式的类型，然后我们可以用它来声明临时变量，既保证类型安全，又避免多次求值。

看这个版本：

#define MAX(a, b) ({                \
    __typeof__(a) _a = (a);         \
    __typeof__(b) _b = (b);         \
    _a > _b ? _a : _b;              \
})

#define MIN(a, b) ({                \
    __typeof__(a) _a = (a);         \
    __typeof__(b) _b = (b);         \
    _a < _b ? _a : _b;              \
})

这里用了GCC的语句表达式（花括号加括号），里面可以写多条语句，最后一条表达式的值就是整个语句表达式的值。每个参数只求值一次，赋值给临时变量，然后比较临时变量。

举个例子，刚才那个坑：

int arr[] = {1, 2, 3, 4, 5};
int *p = arr;
int max = MAX(*p++, *p++);  // 现在安全了！

展开后，*p++只执行一次，赋值给_a，然后p再自增一次。第二个参数同理。总共只自增两次，行为完全可预测。

14.4 更完善的版本——加个类型检查

有时候你希望两个参数类型一致，避免隐式转换带来的精度损失。可以加个编译时断言：

#define MAX(a, b) ({                                \
    __typeof__(a) _a = (a);                         \
    __typeof__(b) _b = (b);                         \
    (void)(&_a == &_b);                             \
    _a > _b ? _a : _b;                              \
})

注意中间那行 (void)(&_a == &_b);。这行代码本身没有实际作用，但编译器会检查&_a和&_b的类型是否一致——如果a和b类型不同，编译器会报warning或error。这是一种编译时类型检查的技巧。

我曾经在一个嵌入式项目里，因为MAX宏没做类型检查，导致一个int和一个unsigned int比较，结果负数被转成了很大的正数，bug查了两天才找到。从那以后，我写的每个MAX/MIN宏都带上了这个类型检查。

14.5 各平台兼容性一览

方案	类型安全	无副作用	单次求值	可移植性
经典宏（无括号）	❌	❌	❌	✅ 所有C编译器
经典宏（加括号）	❌	❌	❌	✅ 所有C编译器
内联函数	✅	✅	✅	✅ C99+
_Generic	✅	✅	✅	⚠ C11+
typeof + 语句表达式	✅	✅	✅	⚠ GCC/Clang

你看，没有完美的方案。如果你追求可移植性，就用内联函数，为常用类型写几个版本。如果你确定目标平台是GCC/Clang，那typeof方案就是最优解。

14.6 知识体系总览

下面这张图帮你理清本章的核心脉络：

14.7 避坑指南与个人经验

最后，分享几个我踩过的坑：

• 不要用MAX/MIN比较浮点数——浮点数的精度问题会导致意外结果。我曾经用MIN宏找两个float的最小值，结果因为一个数是NaN，整个逻辑全乱了。浮点数比较请用专门的函数。
• 注意临时变量命名冲突——typeof版本里用了_a和_b，如果宏嵌套调用，内层和外层的变量名会冲突。解决办法是用__LINE__生成唯一变量名，或者用__COUNTER__（GCC扩展）。
• 语句表达式不是标准C——如果你写的是跨平台库，千万别用。我见过一个库在ARMCC上编译直接报错，就是因为用了GCC扩展。

嗯，关于MAX/MIN宏，核心要点就这些了。记住一句话：宏是文本替换，不是函数调用。理解了这句话，你就能避开90%的宏陷阱。

---

公众号:蓝海资料掘金营，微信deep3321