我编写的这个版本适用于MSVC、GCC、C和c++。

#if defined(__cplusplus) && !defined(__GNUC__)
#   include <algorithm>
#   define MIN std::min
#   define MAX std::max
//#   define TMIN(T, a, b) std::min<T>(a, b)
//#   define TMAX(T, a, b) std::max<T>(a, b)
#else
#       define _CHOOSE2(binoper, lexpr, lvar, rexpr, rvar) \
                ({ \
                        decltype(lexpr) lvar = (lexpr); \
                        decltype(rexpr) rvar = (rexpr); \
                        lvar binoper rvar ? lvar : rvar; \
                })
#       define _CHOOSE_VAR2(prefix, unique) prefix##unique
#       define _CHOOSE_VAR(prefix, unique) _CHOOSE_VAR2(prefix, unique)
#       define _CHOOSE(binoper, lexpr, rexpr) \
                _CHOOSE2( \
                        binoper, \
                        lexpr, _CHOOSE_VAR(_left, __COUNTER__), \
                        rexpr, _CHOOSE_VAR(_right, __COUNTER__) \
                )
#       define MIN(a, b) _CHOOSE(<, a, b)
#       define MAX(a, b) _CHOOSE(>, a, b)
#endif

它也在GNU libc (Linux)和FreeBSD版本的sys/param.h中提供，并具有dreamlax提供的定义。

在Debian上:

$ uname -sr
Linux 2.6.11

$ cat /etc/debian_version
5.0.2

$ egrep 'MIN\(|MAX\(' /usr/include/sys/param.h
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

$ head -n 2 /usr/include/sys/param.h | grep GNU
This file is part of the GNU C Library.

在FreeBSD上:

$ uname -sr
FreeBSD 5.5-STABLE

$ egrep 'MIN\(|MAX\(' /usr/include/sys/param.h
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

源存储库在这里:

GNU C库 FreeBSD

旧的GCC扩展:操作符<?, > ?, < ?=, > ?＝

在非常旧的GCC版本中，有操作符<?, > ?(看这里，它是在c++中，但我认为它当时也适用于C扩展) 我还见过操作符<?=, > ?=对应于赋值语句。

操作数只计算一次，甚至允许使用非常短的赋值语句。与常见的最小/最大赋值相比，它非常短。没有什么比这更好的了。

这些是以下内容的简写:

min(a, b)   ===   a < b ? a : b   ===   a <? b;
max(a, b)   ===   a > b ? a : b   ===   a >? b;
a = min(a, b);   ===   if(b < a) a = b;   ===   a <?= b;
a = max(a, b);   ===   if(b > a) a = b;   ===   a >?= b;

求最小值非常简洁:

int find_min(const int* ints, int num_ints)
{
    assert(num_ints > 0);
    int min = ints[0];
    for(int i = 1; i < num_ints; ++i)
        min <?= ints[i];
    return min;
}

我希望有一天GCC会用到这些运算符，因为我认为这些运算符很有天赋。

最简单的方法是将它定义为.h文件中的一个全局函数，如果您的程序是包含大量文件的模块化程序，则可以随时调用它。如果不是，double MIN(a,b){return (a<b?a:b)}是最简单的方法。

C语言中的MIN和MAX定义在哪里?

他们不是。

实现这些的最好方法是什么，尽可能的泛型和类型安全(主流编译器的编译器扩展/内置首选)。

作为功能。我不会使用像#define MIN(X, Y) (((X) < (Y))这样的宏?(X):(Y))，特别是如果您计划部署您的代码。要么写你自己的，使用标准的fmax或fmin，或者在GCC语句表达式中使用GCC的typeof(你也会得到类型安全奖励)修复宏:

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

每个人都说“哦，我知道双重求值，这没问题”，几个月后，你会连续几个小时调试最愚蠢的问题。

注意使用__typeof__而不是typeof:

如果你正在写一个头文件 必须工作时，包括在ISO C 程序，写__typeof__而不是 typeof。

避免使用非标准编译器扩展，在纯标准C语言中实现完全类型安全的宏(ISO 9899:2011)。

解决方案

#define GENERIC_MAX(x, y) ((x) > (y) ? (x) : (y))

#define ENSURE_int(i)   _Generic((i), int:   (i))
#define ENSURE_float(f) _Generic((f), float: (f))


#define MAX(type, x, y) \
  (type)GENERIC_MAX(ENSURE_##type(x), ENSURE_##type(y))

使用

MAX(int, 2, 3)

解释

宏MAX基于类型参数创建另一个宏。如果为给定类型实现了此控制宏，则用于检查两个参数的类型是否正确。如果不支持该类型，则会出现编译器错误。

如果x或y的类型不正确，则ENSURE_宏中将出现编译器错误。如果支持更多类型，可以添加更多这样的宏。我假设只有算术类型(整数，浮点数，指针等)将被使用，而不是结构体或数组等。

如果所有类型都正确，将调用GENERIC_MAX宏。每个宏参数周围都需要额外的括号，这是编写C宏时通常的标准预防措施。

然后是c语言中隐式类型提升的常见问题。?:操作符平衡了第2和第3个操作数。例如，GENERIC_MAX(my_char1, my_char2)的结果将是一个int型。为了防止宏执行这种潜在危险的类型提升，使用了最终类型转换为预期类型。

基本原理

我们希望宏的两个参数具有相同的类型。如果其中一个是不同类型的，则宏不再是类型安全的，因为像?:这样的操作符将产生隐式类型提升。正因为如此，我们还总是需要将最终结果转换回上面解释的预期类型。

只有一个参数的宏可以用更简单的方式编写。但是对于2个或更多的参数，就需要包含一个额外的类型参数。因为不幸的是，这样的事情是不可能的:

// this won't work
#define MAX(x, y)                                  \
  _Generic((x),                                    \
           int: GENERIC_MAX(x, ENSURE_int(y))      \
           float: GENERIC_MAX(x, ENSURE_float(y))  \
          )

问题是，如果上面的宏被调用为带有两个int的MAX(1,2)，它仍然会尝试宏展开_Generic关联列表的所有可能场景。因此ENSURE_float宏也会被展开，尽管它与int无关。由于该宏有意只包含float类型，因此代码无法编译。

为了解决这个问题，我在预处理器阶段使用##操作符创建了宏名，这样就不会意外地展开宏。

例子

#include <stdio.h>

#define GENERIC_MAX(x, y) ((x) > (y) ? (x) : (y))

#define ENSURE_int(i)   _Generic((i), int:   (i))
#define ENSURE_float(f) _Generic((f), float: (f))


#define MAX(type, x, y) \
  (type)GENERIC_MAX(ENSURE_##type(x), ENSURE_##type(y))

int main (void)
{
  int    ia = 1,    ib = 2;
  float  fa = 3.0f, fb = 4.0f;
  double da = 5.0,  db = 6.0;

  printf("%d\n", MAX(int,   ia, ib)); // ok
  printf("%f\n", MAX(float, fa, fb)); // ok

//printf("%d\n", MAX(int,   ia, fa));  compiler error, one of the types is wrong
//printf("%f\n", MAX(float, fa, ib));  compiler error, one of the types is wrong
//printf("%f\n", MAX(double, fa, fb)); compiler error, the specified type is wrong
//printf("%f\n", MAX(float, da, db));  compiler error, one of the types is wrong

//printf("%d\n", MAX(unsigned int, ia, ib)); // wont get away with this either
//printf("%d\n", MAX(int32_t, ia, ib)); // wont get away with this either
  return 0;
}