std::max

定义于头文件 `<algorithm>`
template< class T > const T& max( const T& a, const T& b );	(1)	(C++14 起为 constexpr)
template< class T, class Compare > const T& max( const T& a, const T& b, Compare comp );	(2)	(C++14 起为 constexpr)
template< class T > T max( std::initializer_list<T> ilist );	(3)	(C++11 起) (C++14 起为 constexpr)
template< class T, class Compare > T max( 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 比较值。

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

[编辑] 返回值

1,2) a 和 b 中较大的一个。若它们等效，则返回 a。

3,4) ilist 中最大的值。若有多个值等效于最大值，则返回最左侧的一个。

[编辑] 复杂度

1) 恰好一次使用 operator< 的比较。

2) 恰好一次比较函数 comp 的应用。

3,4) 给定

N

为 ilist.size()

3) 使用 operator< 进行恰好

N-1

次比较。

4) 恰好

N-1

次应用比较函数 comp。

[编辑] 可能的实现

max (1)
template<class T> const T& max(const T& a, const T& b) { return (a < b) ? b : a; }
max (2)
template<class T, class Compare> const T& max(const T& a, const T& b, Compare comp) { return (comp(a, b)) ? b : a; }
max (3)
template<class T> T max(std::initializer_list<T> ilist) { return *std::max_element(ilist.begin(), ilist.end()); }
max (4)
template<class T, class Compare> T max(std::initializer_list<T> ilist, Compare comp) { return *std::max_element(ilist.begin(), ilist.end(), comp); }

[编辑] 注意

如果其中一个参数是临时对象，并且该参数被返回，则通过引用捕获 std::max 的结果会产生悬空引用。

int n = -1;
const int& r = std::max(n + 2, n * 2); // r is dangling

[编辑] 示例

运行此代码

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string_view>
 
int main()
{
    auto longest = [](const std::string_view s1, const std::string_view s2)
                   {
                       return s1.size() < s2.size();
                   };
 
    std::cout << "Larger of 69 and 96 is " << std::max(69, 96) << "\n"
                 "Larger of 'q' and 'p' is '" << std::max('q', 'p') << "'\n"
                 "Largest of 010, 10, 0X10, and 0B10 is "
              << std::max({010, 10, 0X10, 0B10}) << '\n'
              << R"(Longest of "long", "short", and "int" is )"
              << std::quoted(std::max({"long", "short", "int"}, longest)) << '\n';
}

输出

Larger of 69 and 96 is 96
Larger of 'q' and 'p' is 'q'
Largest of 010, 10, 0X10, and 0B10 is 16
Longest of "long", "short", and "int" is "short"

[编辑] 缺陷报告

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

缺陷报告	应用于	发布时的行为	正确的行为
LWG 281	C++98	重载 (1,2) 要求 `T` 必须是 CopyConstructible。	未要求
LWG 2239	C++98 C++11	1. 重载 (2) (C++98) 和 (4) (C++11) 要求 `T` 必须是 LessThanComparable。 2. 缺少复杂度要求	1. 不再要求 2. 添加了要求

[编辑] 参阅

min	返回给定值中较小的那个 (函数模板) [编辑]
minmax (C++11)	返回两个元素中较小和较大的一个 (函数模板) [编辑]
max_element	返回一个范围中最大的元素 (函数模板) [编辑]
clamp (C++17)	将值限制在边界值对之间 (函数模板) [编辑]
ranges::max (C++20)	返回给定值中较大的那个 (算法函数对象)[编辑]

编译器支持
自由（freestanding）与宿主（hosted）
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.cn

命名空间

变体

视图

操作