命名空间
变体
操作

std::minmax

来自 cppreference.cn
< cpp‎ | 算法
 
C++
 
算法库
有约束算法与针对范围的算法 (C++20)
有约束的算法，例如 ranges::copy、 ranges::sort 等……
执行策略 (C++17)
排序及相关操作
划分操作
排序操作
二分搜索操作
（于已划分范围上）
集合操作（于已排序范围上）
归并操作（于已排序范围上）
堆操作
最小/最大值操作
minmax
(C++11)
(C++17)
字典序比较操作
(C++20)
排列操作
C 库
数值操作
未初始化内存上的操作
 
定义于头文件 <algorithm>
template< class T >
std::pair<const T&, const T&> minmax( const T& a, const T& b );
 (1) (C++11 起)
(C++14 起为 constexpr)
template< class T, class Compare >

std::pair<const T&, const T&> minmax( const T& a, const T& b,

                                      Compare comp );
 (2) (C++11 起)
(C++14 起为 constexpr)
template< class T >
std::pair<T, T> minmax( std::initializer_list<T> ilist );
 (3) (C++11 起)
(C++14 起为 constexpr)
template< class T, class Compare >

std::pair<T, T> minmax( std::initializer_list<T> ilist,

                        Compare comp );
 (4) (C++11 起)
(C++14 起为 constexpr)

返回给定值中的最小值和最大值。

1,2) 返回 a 和 b 中较小和较大的值的引用。
1) 使用 operator< 比较值。
如果 T 不是 LessThanComparable，则行为未定义。
2) 使用比较函数 comp 比较值。
3,4) 返回初始化列表 ilist 中的最小值和最大值。
如果 ilist.size() 为零，或者 T 不是 CopyConstructible，则行为未定义。
3) 使用 operator< 比较值。
如果 T 不是 LessThanComparable，则行为未定义。
4) 使用比较函数 comp 比较值。

目录

[edit] 参数

a, b - 要比较的值
ilist - 包含要比较值的初始化列表
comp - 比较函数对象（即满足 Compare 要求的对象），如果第一个参数“小于”第二个参数，则返回 true。

比较函数的签名应等效于以下内容

bool cmp(const Type1& a, const Type2& b);

虽然签名不需要包含 const&，但函数不能修改传递给它的对象，并且必须能够接受 Type1 和 Type2 类型（可能为 const）的所有值，无论 值类别 如何（因此，不允许使用 Type1&，也不允许使用 Type1，除非对于 Type1 移动等同于复制(C++11 起)）。
类型 Type1 和 Type2 必须能够让类型 T 的对象隐式转换为它们两者。

[edit] 返回值

1,2) 如果 a < b 或 a 等同于 b，则返回 std::pair<const T&, const T&>(a, b) 的结果。如果 b < a，则返回 std::pair<const T&, const T&>(b, a) 的结果。
3,4) 一个 pair，其中第一个元素是 ilist 中的最小值，第二个元素是最大值。如果多个元素等同于最小值，则返回最左侧的此类元素。如果多个元素等同于最大值，则返回最右侧的此类元素。

[edit] 复杂度

1) 恰好一次使用 operator< 的比较。
2) 恰好一次比较函数 comp 的应用。
3,4) 给定 N 作为 ilist.size()
3) 最多
3N
2
 次使用 operator< 的比较。
4) 最多
3N
2
 次比较函数 comp 的应用。

[edit] 可能的实现

minmax (1) 
template<class T>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b)
{
    return (b < a) ? std::pair<const T&, const T&>(b, a)
                   : std::pair<const T&, const T&>(a, b);
}
minmax (2) 
template<class T, class Compare>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp)
{
    return comp(b, a) ? std::pair<const T&, const T&>(b, a)
                      : std::pair<const T&, const T&>(a, b);
}
minmax (3) 
template<class T>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end());
    return std::pair(*p.first, *p.second);
}
minmax (4) 
template<class T, class Compare>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist, Compare comp)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end(), comp);
    return std::pair(*p.first, *p.second);
}

[edit] 注意

对于重载 (1,2)，如果其中一个参数是临时对象，则返回的引用在包含对 minmax 调用的完整表达式结束时会变成悬空引用。

int n = 1;
auto p = std::minmax(n, n + 1);
int m = p.first; // ok
int x = p.second; // undefined behavior
 
// Note that structured bindings have the same issue
auto [mm, xx] = std::minmax(n, n + 1);
xx; // undefined behavior

[edit] 示例

运行此代码
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};
    std::srand(std::time(0));
    std::pair<int, int> bounds = std::minmax(std::rand() % v.size(),
                                             std::rand() % v.size());
 
    std::cout << "v[" << bounds.first << "," << bounds.second << "]: ";
    for (int i = bounds.first; i < bounds.second; ++i)
        std::cout << v[i] << ' ';
    std::cout << '\n';
}

可能的输出

v[2,7]: 4 1 5 9 2

[edit] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 发布时的行为 正确的行为
LWG 2239 C++11 对于重载 (2,4)，曾要求 T 为 LessThanComparable 未要求

[edit] 另请参阅

 返回给定值中较小的那个
(函数模板) [编辑]
 返回给定值中较大的那个
(函数模板) [编辑]
(C++11)
 返回范围中最小和最大的元素
(函数模板) [编辑]
(C++20)
 返回两个元素中较小和较大的一个
(算法函数对象)[编辑]
取自“https://cppreference.cn/mwiki/index.php?title=cpp/algorithm/minmax&oldid=178177”