• // <algorithm> 
    // 等价比较(1)
    template <class T> const T& max (const T& a, const T& b);
    // 自定义谓词比较(2)
    template <class T, class Compare>
        const T& max (const T& a, const T& b, Compare comp);
    
  • // <algorithm> 
    ​// 等价比较(1)    
    template <class T> const T& max (const T& a, const T& b);
    // 自定义谓词比较(2)    
    template <class T, class Compare>
        const T& max (const T& a, const T& b, Compare comp);
    // 初始化列表(3)    
    template <class T> T max (initializer_list<T> il);
    template <class T, class Compare>
        T max (initializer_list<T> il, Compare comp);
    

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

该函数等价于:

template<class _Ty> inline
    const _Ty& (max)(const _Ty& _Left, const _Ty& _Right)
    {    // return larger of _Left and _Right
    return (_DEBUG_LT(_Left, _Right) ? _Right : _Left);
    }
  • ab

    用于比较的值。

    comp

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

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

    该函数不能修改其参数。

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

    il

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

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

    模版参数 T

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

    C++98

    T 必须可拷贝构造。

    C++11

    只有初始化列表(3) 中的 T 需要支持可拷贝构造。

  • 返回以参数形式传入的值中较大的那一个。

  • 例 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 Max_1() {
            std::cout << std::max(4, 6) << std::endl;
            std::cout << std::max(6.4, 4.6) << std::endl;
            std::cout << std::max('x', 'y') << std::endl;
            // 传入谓词 std::great
            std::cout << std::max(4, 6, std::less<int>()) << std::endl;
            // 传入自定义函数 MyIntLessFunc
            std::cout << std::max(7, 3, MyIntLessFunc) << std::endl;
            // 传入自定义函数对象 MyIntLessStruct
            std::cout << std::max(12, 9, MyIntLessStruct) << std::endl;
        }
    }
    int main()
    {
        ClassFoo::Max_1();
        return 0;
    }

    6
    6.4
    y
    6
    7
    12

    例 2

    #include <iostream>
    #include <algorithm>
    namespace ClassFoo{
        struct Node{
            int x;
            int y;
        };
        bool MyNodeLessFunc(Node a, Node b) {
            if (a.x == b.x)
                return a.y < b.y;
            return a.x < b.x;
        }
        void Max_2() {
            Node n1 = { 3, 11 };
            Node n2 = { 9, 4 };
            Node n3 = { 9, 3 };
            const Node& p = std::max(n1, n2, MyNodeLessFunc);
            std::cout << p.x << " " << p.y << std::endl;
            const Node& q = std::max(n2, n3, MyNodeLessFunc);
            std::cout << q.x << " " << q.y << std::endl;
        }
    }
    int main()
    {
        ClassFoo::Max_2();
        return 0;
    }

    9 4
    9 4

  • 复杂度

    O(1)

    异常安全性相关

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

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