C++11

// <algorithm> 
// 默认(1)    
template <class T> 
    pair <const T&,const T&> minmax (const T& a, const T& b);
// 自定义(2)    
template <class T, class Compare>
    pair <const T&,const T&>
​    minmax (const T& a, const T& b, Compare comp);
// 初始化列表(3)
template <class T> pair<T,T> minmax (initializer_list<T> il);
template <class T, class Compare>
    pair<T,T> minmax (initializer_list<T> il, Compare comp);

返回两个元素中值最大及最小的元素。

该函数等价于:

template<class _Ty,
class _Pr> inline
    pair<const _Ty&, const _Ty&>
    minmax(const _Ty& _Left, const _Ty& _Right, _Pr _Pred)
{	// return pair(leftmost/smaller, rightmost/larger) of _Left and _Right
    return (_Pred(_Right, _Left)
        ? pair<const _Ty&, const _Ty&>(_Right, _Left)
        : pair<const _Ty&, const _Ty&>(_Left, _Right));
}
template<class _Ty,
class _Pr> inline
    pair<_Ty, _Ty> minmax(_XSTD initializer_list<_Ty> _Ilist, _Pr _Pred)
{	// return {leftmost/smallest, rightmost/largest}
    pair<const _Ty *, const _Ty *> _Res = _STD minmax_element(
        _Ilist.begin(), _Ilist.end(), _Pred);
    return (pair<_Ty, _Ty>(*_Res.first, *_Res.second));
}
  • ab

    用于比较的值。

    comp

    二元谓词(Binary)函数,以两个元素为参数,然后返回一个可转换成 bool 类型的值。

    其返回值表明以第一个参数传入的元素是否比第二个参数传入的元素小。

    该函数不能修改其参数。

    可以是函数指针(Function pointer)类型或函数对象(Function object)类型。

    il

    一个初始化列表(initializer_list)对象。

    所有对象都是从初始化化列表声明部分中构造获得。

    模版参数 T

    类型 T 必须支持 operator< 比较。

  • 返回一个 std::pair,其中 first 成员为最小值,second 成员为最大值。

  • 参照 std::sort 以获得与自定义函数谓词、函数对象谓词、对象数组、lambda 表达式 C++11、初始化列表 std::initializer_list C++11 等相关的例子。

    例 1

    #include <iostream>
    #include <algorithm>
    
    namespace ClassFoo{
        bool MyIntLessFunc(int m, int n) {
            return m < n;
        }
        struct _MyIntLessStruct{
            bool operator()(int m, int n) {
                return m < n;
            }
        }MyIntLessStruct;
        void MinMax_1() {
            std::pair<int, int> p;
    
            p = std::minmax(4, 6);
            std::cout << p.first << "  " << p.second << std::endl;
    
            // 传入谓词 std::great
            p = std::minmax(4, 6, std::less<int>());
            std::cout << p.first << "  " << p.second << std::endl;
    
            // 传入自定义函数 MyIntLessFunc
            p = std::minmax(7, 3, MyIntLessFunc);
            std::cout << p.first << "  " << p.second << std::endl;
    
            // 传入自定义函数对象 MyIntLessStruct
            p = std::minmax(12, 9, MyIntLessStruct);
            std::cout << p.first << "  " << p.second << std::endl;
    
            // 初始化列表
            p = std::minmax({ 13, 2, 1, 9, 8, 23, 5 });
            std::cout << p.first << "  " << p.second << std::endl;
        }
    }
    int main()
    {
        ClassFoo::MinMax_1();
        return 0;
    }

    4  6
    4  6
    3  7
    9  12
    1  23

  • 复杂度

    情况(1)、(2)为 O(1)

    情况(3)为 O(N)N 为元素个数。

    异常安全性相关

    如果元素比较抛异常,该函数才会抛异常。

    注意 无效参数将导致未定义行为(Undefined behavior)