C 中的 MIN 和 MAX

Question

C 中的 MIN 和 MAX 定义在哪里（如果有的话）？

实现这些的最佳方法是什么，尽可能通用并安全地输入？ （首选主流编译器的编译器扩展/内置函数。）

Answer 1

C 中的 MIN 和 MAX 定义在哪里（如果有的话）？

他们不是。

实现这些的最佳方法是什么，尽可能通用且类型安全（首选主流编译器的编译器扩展/内置函数）。

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

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

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

请注意使用 __typeof__ 而不是 typeof：

如果您正在编写一个头文件
包含在 ISO C 中时必须有效
程序，写 __typeof__ 而不是
类型。

Answer 2

它也在 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

Answer 3

C++ 中有 std::min 和 std::max，但据我所知，C 标准库中没有等效项。您可以使用类似这样的宏自行定义它们，

#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))

但是如果您编写类似 MAX(++a, ++b) 的内容，则会出现问题。

Answer 4

@David Titarenco 将其钉在此处，但至少让我稍微清理一下以使其看起来不错，并显示两者min() 和 max() 一起使用，可以更轻松地从此处进行复制和粘贴。 :)

2020 年 4 月 25 日更新：我还添加了第 3 节来展示如何使用 C++ 模板来完成此操作，对于同时学习 C 和 C++ 或从一种过渡到另一种的人来说，这是一个有价值的比较。我已尽力做到彻底、真实和正确，使这个答案成为我可以一次又一次回顾的规范参考，我希望你发现它和我一样有用。

1.旧的C宏方式：

这种技术很常用，受到那些知道如何正确使用它的人的尊重，“事实上”的做事方式，如果使用得当的话很好用，但是有bug （想想：双重计算副作用）如果你曾经传递包含变量赋值的表达式 进行比较：

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

2. 新的和改进的 gcc 和 clang "语句表达式”方式：

这种技术避免了上述“双重求值”的副作用和错误，因此被认为是更优越、更安全、“更现代”的GCC C方式做这个。期望它能够与 gcc 和 clang 编译器一起使用，因为 clang 在设计上是与 gcc 兼容的（请参阅本答案底部的 clang 注释）。

但是：请注意“变量遮蔽”仍然有效，因为语句表达式显然是内联的，因此没有自己的局部变量范围！

#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 语句表达式中，代码块中的最后一个表达式是从表达式“返回”，就像从函数返回一样。 GCC 文档是这样说的：

复合语句中的最后一个内容应该是一个表达式，后跟一个分号；该子表达式的值用作整个构造的值。 （如果您在大括号内最后使用某种其他类型的语句，则构造的类型为 void，因此实际上没有值。）

3. [仅限 C++] C++ 模板方式：

C++ 注意：如果使用 C++，模板为可能建议使用这种类型的构造，但我个人不喜欢模板，并且可能会在 C++ 中使用上述构造之一，因为我也经常在嵌入式 C++ 中使用并更喜欢 C 样式。

本节添加于 2020 年 4 月 25 日：

在过去的几个月里，我一直在做大量的 C++ 工作，在 C++ 社区中，在可能的情况下，选择模板而不是宏的压力非常大。因此，我越来越擅长使用模板，并希望在此处放入 C++ 模板版本以保持完整性，并使之成为更规范和彻底的答案。

以下是 max() 和 min() 的基本函数模板版本在 C++ 中的样子：

template <typename T>
T max(T a, T b)
{
    return a > b ? a : b;
}

template <typename T>
T min(T a, T b)
{
    return a < b ? a : b;
}

在此处进一步阅读有关 C++ 模板的内容：< a href="https://en.wikipedia.org/wiki/Template_(C%2B%2B)" rel="noreferrer">维基百科：模板 (C++)。

但是， max() 和 min() 已经是 C++ 标准库的一部分，位于 < code> 标头 (#include )。在 C++ 标准库中，它们的定义与上面的定义略有不同。例如，在 C++14 中，std::max<>() 和 std::min<>() 的默认原型，查看它们的上面 cplusplus.com 链接中的原型是：

template <class T> 
constexpr const T& max(const T& a, const T& b);

template <class T> 
constexpr const T& min(const T& a, const T& b);

请注意，关键字 typename 是 class 的别名（因此，无论您说 > 或 ），因为后来在 C++ 模板发明后才承认，模板类型可能是常规类型（ int、float 等），而不仅仅是类类型。

这里您可以看到，输入类型和返回类型都是const T&，意思是“对类型T的常量引用”。这意味着输入参数和返回值是通过引用传递，而不是通过值传递。这就像传递指针一样，对于大型类型（例如类对象）更有效。函数的 constexpr 部分 修改函数本身并指示函数必须能够在编译时进行计算（至少如果提供了constexpr输入参数），但如果无法在编译时求值，则它默认返回运行时求值，就像任何其他普通函数一样。

constexpr C++ 函数的编译时方面使其类似于 C 宏，因为如果 constexpr 函数可以进行编译时评估，则它将在编译时完成，与 MIN() 或 MAX() 宏替换相同，也可以在 C 或 C++ 中的编译时进行完全评估。有关此 C++ 模板信息的其他参考，请参阅下文。

4. [仅限 C++] C++ std::max()

如果使用 C++，我想添加内置的 std::max()函数有多种的形式。请参阅 cppreference.com 社区 wiki (https: //en.cppreference.com/w/cpp/algorithm/max），了解 4 种形式的 std::max() 的 4 种可能实现。

正常用法包括：

std::max(100, 200);

...但是如果您想一次比较多个数字，可以使用第四种形式，它接受 std::initializer_list，像这样：

函数声明：

template< class T, class Compare >
constexpr T max( std::initializer_list<T> ilist, Compare comp );

用法：

// Compare **3 or more numbers** by passing a curly-brace-initialized
// `std::initializer_list<>` to `std::max()`!:

std::max({100, 200, 300});                  // result is 300
std::max({100, 200, 300, 400});             // result is 400
std::max({100, 200, 300, 400, 500});        // result is 500
std::max({100, 200, 300, 400, 500, 600});   // result is 600
// etc.

引用：

1. https://gcc.gnu .org/onlinedocs/gcc/Typeof.html#Typeof
2. https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html#Statement-Exprs
3. C 中的 MIN 和 MAX
4. 2020 年 4 月添加的其他 C++ 模板参考：
5. *****维基百科：模板 (C++) <-- 有关 C++ 模板的更多附加信息！
6. （我自己的问题和答案）： 为什么 `constexpr` 是 `std::max()` 的 C++14 模板原型的一部分？
7. constexpr 和 const 有什么区别？

Clang 注释 来自维基百科：

[Clang] 旨在充当 GNU 编译器集合 (GCC) 的直接替代品，支持其大部分编译标志和非官方语言扩展。

相关：

1. [我的答案] 舍入整数除法（而不是截断） - 我在这里还使用宏、gcc/clang 语句表达式和 C++ 模板。

Answer 5

避免非标准编译器扩展，并将其实现为纯标准 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根据type参数创建另一个宏。如果针对给定类型实现了该控制宏，则该控制宏用于检查两个参数的类型是否正确。如果不支持type，则会出现编译器错误。

如果 x 或 y 的类型不正确，ENSURE_ 宏中将会出现编译器错误。如果支持更多类型，可以添加更多此类宏。我假设仅使用算术类型（整数、浮点数、指针等），而不使用结构或数组等。

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

然后是 C 中隐式类型提升的常见问题。?:运算符平衡第二个和第三个操作数。例如，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;
}

Answer 6

由于最近的发展，这是一个较晚的答案。由于OP接受了依赖于不可移植的GCC（和clang）扩展typeof - 或__typeof__“干净”ISO C的答案 - 有一个更好的解决方案可用gcc-4.9。

#define max(x,y) ( \
    { __auto_type __x = (x); __auto_type __y = (y); \
      __x > __y ? __x : __y; })

此扩展的明显好处是每个宏参数仅扩展一次，与 __typeof__ 解决方案不同。

__auto_type 是 C++11 auto 的有限形式。它不能（或不应该？）在 C++ 代码中使用，尽管在使用 C++11 时没有充分的理由不使用 auto 的高级类型推断功能。

也就是说，我假设当宏包含在 extern "C" { ... } 作用域中时，使用此语法不会出现任何问题；例如，来自 C 标头。 AFAIK，这个扩展还没有找到它的方式 info clang

Answer 7

我不认为它们是标准化的宏。浮点已经有了标准化函数，fmax 和 fmin（以及用于浮点的 fmaxf 和用于长整型的 fmaxl）双打）。

只要您意识到副作用/双重评估问题，您就可以将它们实现为宏。

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

在大多数情况下，您可以将其留给编译器来确定您要执行的操作并尽可能对其进行优化。虽然这在像 MAX(i++, j++) 这样使用时会导致问题，但我怀疑是否有必要一次性检查增量值的最大值。先递增，后检查。

Answer 8

我写了这个版本 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

Answer 9

如果您需要最小/最大以避免昂贵的分支，则不应使用三元运算符，因为它会编译为跳转。 Bit Twiddling Hacks 描述了一种无需使用即可实现最小/最大函数的有用方法分枝。

int x; // 我们想要找到 x 和 y 的最小值
整数y；   
整数 r; // 结果放在这里 

r = y ^ ((x ^ y) & -(x < y)); // 最小值（x，y）

要查找最大值，请使用：

r = x ^ ((x ^ y) & -(x < y)); // 最大值（x，y）

快速而肮脏的版本：

如果您知道 INT_MIN <= x - y <= INT_MAX，那么您可以使用以下命令，这会更快，因为仅 (x - y)需要评估一次。

r = y + ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1))); // 最小值（x，y）
r = x - ((x - y) & ((x - y) >> (sizeof(int) * CHAR_BIT - 1))); // 最大值（x，y）

Answer 10

值得指出的是，我认为如果您使用三元运算定义 min 和 max ，例如

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

then ，对于 fmin(- 0.0,0.0) 和 fmax(-0.0,0.0) 您需要交换参数

fmax(a,b) = MAX(a,b)
fmin(a,b) = MIN(b,a)

Answer 11

看起来像 Windef.h （类似于 #include ）有 max 和 min （小写）宏，也遭受“双重评估”困难，但它们是为那些不想重新推出自己的宏而存在的:)

Answer 12

旧的 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，因为我认为这些运算符非常天才。

Answer 13

正如其他答案所建议的，一个简单的解决方案是一个宏：

#define max(a, b) ((a) > (b) ? (a) : (b))

但是，这可能会导致意外结果和不必要的(如果 a 和 b 是复杂表达式（有副作用）而不仅仅是变量，则重新计算。

该问题确实要求特定于编译器的扩展，因此其他答案也表明，更安全的选择是使用 GCC 语句表达式和 __typeof__ 。

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

如果您有 GCC，此解决方案非常有用。但否则根本不起作用。

如果您使用 C++，模板函数会更好。但问题被标记为 c 因此，仅 C++ 的答案并不适用于此处的所有情况。

我想提供一个便携式解决方案。由于 C 库已经具有以 l 和 ll 结尾的较大整数类型的函数，因此我们可以定义自己的 min 和 max< /code> 以同样的方式匹配库中找到的函数，例如 abs/absl/absll 和 div< /code>/divl/divll。

static inline int min(const int a, const int b) {
    return a < b ? a : b;
}
static inline int max(const int a, const int b) {
    return a > b ? a : b;
}
static inline long minl(const long a, const long b) {
    return a < b ? a : b;
}
static inline long maxl(const long a, const long b) {
    return a > b ? a : b;
}
static inline long long minll(const long long a, const long long b) {
    return a < b ? a : b;
}
static inline long long maxll(const long long a, const long long b) {
    return a > b ? a : b;
}

该解决方案是 GCC 扩展或仅 C++ 功能的良好替代品，并且比宏更安全。我们没有定义 fmin 和 < a href="https://en.cppreference.com/w/c/numeric/math/fmax" rel="nofollow noreferrer">fmax 及其浮点类型的变体因为那些已经存在了。

Answer 14

我知道那个人说“C”...
但如果有机会，请使用 C++ 模板：

template<class T> T min(T a, T b) { return a < b ? a : b; }

类型安全，并且与其他评论中提到的 ++ 没有问题。

Answer 15

在gcc中，你可以使用这个：

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

在msvc中，你可以使用这个：

#define SMART_MIN(x, y) \
    ([&]() -> decltype(x) { \
        decltype(x) _min1 = (x); \
        decltype(y) _min2 = (y); \
        return _min1 < _min2 ? _min1 : _min2; \
    })()

这样，可以确保x,y不会被计算2次

Answer 16

两个整数 a 和 b 的最大值为 (int)(0.5((a+b)+abs(ab)))。对于双精度数，这也可以与 (double) 和 fabs(ab) 一起使用（与浮点数类似）

Answer 17

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