std::min() 算法

自 C++14 起

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

// (2)
template< class T, class Compare >
constexpr const T& min( const T& a, const T& b, Compare comp );

// (3)
template< class T >
constexpr T min( std::initializer_list<T> ilist );

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

自 C++11 起

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

// (2)
template< class T, class Compare >
const T& min( const T& a, const T& b, Compare comp );

// (3)
template< class T >
T min( std::initializer_list<T> ilist );

// (4)
template< class T, class Compare >
T min( std::initializer_list<T> ilist, Compare comp );

直到 C++11

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

// (2)
template< class T, class Compare >
const T& min( const T& a, const T& b, Compare comp );

返回给定值中较小的一个。

• (1 - 2) 返回 a 和 b 中较小的一个。
• (3 - 4) 返回初始化列表 ilist 中最小的值。

参数

a b	要比较的值。
ilist	包含要比较值的初始化列表。
cmp	比较函数对象（即满足Compare要求的对象），如果 a 小于 b 则返回 true。比较函数的签名应与以下内容等效 bool cmp(const Type1 &a, const Type2 &b); 虽然签名不需要有 const&，但函数不得修改传递给它的对象，并且必须能够接受 Type1 和 Type2 类型的所有值（可能是 const），无论其值类别如何（因此，不允许使用 Type1&，除非对于 Type1，移动等同于复制，否则也不允许使用 Type1 （自 C++11 起））。 Type1 和 Type2 的类型必须使得 T 类型的对象可以隐式转换为它们两者。

类型要求

• (1, 3):

  T	LessThanComparable

• (3 - 4):

  T	CopyConstructible

返回值

• (1 - 2) 根据投影，a 和 b 中较小的一个。如果它们相等，则返回 a。
• (3 - 4) ilist 中最小的值。如果多个值与最小值的等价，则返回最左边的那个值。

复杂度

• (1 - 2) 恰好一次比较。
• (3 - 4) 恰好 ilist.size() - 1 次比较。

异常

(无)

可能的实现

min (1)

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

min (2)

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

min (3)

template<class T>
T min(std::initializer_list<T> ilist)
{
    return *std::min_element(ilist.begin(), ilist.end());
}

min (4)

template<class T, class Compare>
T min(std::initializer_list<T> ilist, Compare comp)
{
    return *std::min_element(ilist.begin(), ilist.end(), comp);
}

备注

未定义行为

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

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

示例

Main.cpp

#include <algorithm>
#include <iostream>
#include <string_view>

int main()
{
    std::cout << "smaller of 1 and 9999 is " << std::min(1, 9999) << '\n'
              << "smaller of 'a', and 'b' is '" << std::min('a', 'b') << "'\n"
              << "shortest of \"foo\", \"bar\", and \"hello\" is \""
              << std::min({"foo", "bar", "hello"},
                          [](const std::string_view s1, const std::string_view s2)
                          {
                              return s1.size() < s2.size();
                          }) << "\"\n";
}

输出

smaller of 1 and 9999 is 1
smaller of 'a', and 'b' is 'a'
shortest of "foo", "bar", and "hello" is "foo"