C++最小/最大（min；max；minmax；min_element；max_element；minmax_element）

一、min

头文件algorithm

【C++ 98】

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

【C++ 11】

default (1)	
template <class T> const T& min (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& min (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T> T min (initializer_list<T> il);
template <class T, class Compare>
  T min (initializer_list<T> il, Compare comp);

【C++ 14】

default (1)	
template <class T> constexpr const T& min (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  constexpr const T& min (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T> constexpr T min (initializer_list<T> il);
template <class T, class Compare>
  constexpr T min (initializer_list<T> il, Compare comp);

返回最小的

返回a和b中的最小值。如果两者都是等价的，则返回a。

初始化列表（3）的版本返回列表中所有元素中最小的元素。如果这些不止一个，则返回第一个。

该函数使用operator <（或comp，如果提供）来比较值。

此函数模板（C ++ 98）的行为等效于：

template <class T> const T& min (const T& a, const T& b) {
  return !(b<a)?a:b;     // or: return !comp(b,a)?a:b; for version (2)
}

参数

a，b
要比较的值。
comp
二进制函数，它接受两个类型为T的值作为参数，并返回一个可转换为bool的值。返回的值指示作为第一个参数传递的元素是否小于第二个参数。该函数不得修改其任何参数。这可以是函数指针或函数对象。
il
initializer_list对象。这些对象是从初始化列表声明符自动构造的。

T应支持用operator <进行比较。：
【C++ 98】T应是可复制的。
【C++ 11】对于（3），T应是可复制的。

返回值

作为参数传递的值中较小的值。

// min example
#include <iostream>     // std::cout
#include <algorithm>    // std::min

int main () {
  std::cout << "min(1,2)==" << std::min(1,2) << '\n';
  std::cout << "min(2,1)==" << std::min(2,1) << '\n';
  std::cout << "min('a','z')==" << std::min('a','z') << '\n';
  std::cout << "min(3.14,2.72)==" << std::min(3.14,2.72) << '\n';
  return 0;
}

在这里插入图片描述

二、max

头文件algorithm

【C++ 98】

default (1)	
template <class T> const T& max (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& max (const T& a, const T& b, Compare comp);

【C++ 11】

default (1)	
template <class T> const T& max (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& max (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T> T max (initializer_list<T> il);
template <class T, class Compare>
  T max (initializer_list<T> il, Compare comp);

【C++ 14】

default (1)	
template <class T> constexpr const T& max (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  constexpr const T& max (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T> constexpr T max (initializer_list<T> il);
template <class T, class Compare>
  constexpr T max (initializer_list<T> il, Compare comp);

返回最大的

返回a和b中的最大值。如果两者都是等价的，则返回a。

初始化列表（3）的版本返回列表中所有元素中最大的一个。如果这些不止一个，则返回第一个。

该函数使用operator <（或comp，如果提供）来比较值。

此函数模板（C ++ 98）的行为等效于：

template <class T> const T& max (const T& a, const T& b) {
  return (a<b)?b:a;     // or: return comp(a,b)?b:a; for version (2)
}

参数

a，b
要比较的值。
comp
二进制函数，它接受两个类型为T的值作为参数，并返回一个可转换为bool的值。返回的值指示作为第一个参数传递的元素是否小于第二个参数。
该函数不得修改其任何参数。这可以是函数指针或函数对象。
il
initializer_list对象。
这些对象是从初始化列表声明符自动构造的。

T应支持用operator <进行比较：
【C++ 98】T应是可复制的。
【C++ 11】对于（3），T应是可复制的。

返回值

作为参数传递的最大值。

// max example
#include <iostream>     // std::cout
#include <algorithm>    // std::max

int main () {
  std::cout << "max(1,2)==" << std::max(1,2) << '\n';
  std::cout << "max(2,1)==" << std::max(2,1) << '\n';
  std::cout << "max('a','z')==" << std::max('a','z') << '\n';
  std::cout << "max(3.14,2.73)==" << std::max(3.14,2.73) << '\n';
  return 0;
}

在这里插入图片描述

三、minmax

头文件algorithm

【C++ 11】

default (1)	
template <class T>
  pair <const T&,const T&> minmax (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  pair <const T&,const T&> minmax (const T& a, const T& b, Compare comp);
initializer list (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);

【C++ 14】

default (1)	
template <class T>
  constexpr pair <const T&,const T&> minmax (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  constexpr pair <const T&,const T&> minmax (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T>
  constexpr pair<T,T> minmax (initializer_list<T> il);
template <class T, class Compare>
  constexpr pair<T,T> minmax (initializer_list<T> il, Compare comp);

返回最小和最大的元素

返回一对最小的a和b作为第一个元素，最大的作为第二个元素。如果两者都是等价的，则函数返回make_pair（a，b）。

initializer lists (3)的版本返回一对，列表中所有元素中的最小元素作为第一个元素（第一个元素，如果有多个元素），最大的元素作为第二个元素（最后一个，如果有的话，最后一个，如果不止一个）。

该函数使用operator <（或comp，如果提供）来比较值。

此函数模板（version (1)）的行为等效于：

template <class T> pair <const T&,const T&> minmax (const T& a, const T& b) {
  return (b<a) ? std::make_pair(b,a) : std::make_pair(a,b);
}

参数

a，b
要比较的值。
comp
二进制函数，它接受两个类型为T的值作为参数，并返回一个可转换为bool的值。返回的值指示作为第一个参数传递的元素是否小于第二个参数。
该函数不得修改其任何参数。这可以是函数指针或函数对象。
il
initializer_list对象。
这些对象是从初始化列表声明符自动构造的。

T应支持用operator <进行比较。对于（3），T应是可复制的。

返回值

作为参数传递的值中较小的值。

// minmax example
#include <iostream>     // std::cout
#include <algorithm>    // std::minmax

int main () {
  auto result = std::minmax({1,2,3,4,5});

  std::cout << "minmax({1,2,3,4,5}): ";
  std::cout << result.first << ' ' << result.second << '\n';
  return 0;
}

在这里插入图片描述

四、min_element

头文件algorithm

default (1)	
template <class ForwardIterator>
  ForwardIterator min_element (ForwardIterator first, ForwardIterator last);
custom (2)	
template <class ForwardIterator, class Compare>
  ForwardIterator min_element (ForwardIterator first, ForwardIterator last, Compare comp);

返回范围内的最小元素

返回指向范围[first，last]中具有最小值的元素的迭代器。

比较是使用operator <作为第一个版本，或comp作为第二个版本; 如果没有其他元素比它少，则元素是最小的。如果多个元素满足此条件，则迭代器返回指向第一个这样的元素。

此函数模板的行为等效于：

template <class ForwardIterator>
  ForwardIterator min_element ( ForwardIterator first, ForwardIterator last )
{
  if (first==last) return last;
  ForwardIterator smallest = first;

  while (++first!=last)
    if (*first<*smallest)    // or: if (comp(*first,*smallest)) for version (2)
      smallest=first;
  return smallest;
}

参数

fisrt，last
将迭代器输入到要比较的序列的初始和最终位置。使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
comp
二进制函数，接受范围中的两个元素作为参数，并返回可转换为bool的值。返回的值指示作为第一个参数传递的元素是否小于第二个参数。
该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

迭代器到范围中的最小值，如果范围为空则为last。

// min_element/max_element example
#include <iostream>     // std::cout
#include <algorithm>    // std::min_element, std::max_element

bool myfn(int i, int j) { return i<j; }

struct myclass {
  bool operator() (int i,int j) { return i<j; }
} myobj;

int main () {
  int myints[] = {3,7,2,5,6,4,9};

  // using default comparison:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7) << '\n';

  // using function myfn as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myfn) << '\n';

  // using object myobj as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myobj) << '\n';

  return 0;
}

在这里插入图片描述

五、max_element

头文件algorithm

default (1)	
template <class ForwardIterator>
  ForwardIterator max_element (ForwardIterator first, ForwardIterator last);
custom (2)	
template <class ForwardIterator, class Compare>
  ForwardIterator max_element (ForwardIterator first, ForwardIterator last,
                               Compare comp);

返回范围内的最大元素

返回指向范围[first，last]中具有最大值的元素的迭代器。

比较是使用operator <作为第一个版本，或comp作为第二个版本; 如果没有其他元素没有比它少，则元素是最大的。如果多个元素满足此条件，则迭代器返回指向第一个这样的元素。

此函数模板的行为等效于：

template <class ForwardIterator>
  ForwardIterator max_element ( ForwardIterator first, ForwardIterator last )
{
  if (first==last) return last;
  ForwardIterator largest = first;

  while (++first!=last)
    if (*largest<*first)    // or: if (comp(*largest,*first)) for version (2)
      largest=first;
  return largest;
}

参数

first，last
将迭代器输入到要比较的序列的初始和最终位置。使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
comp
二进制函数，接受范围中的两个元素作为参数，并返回可转换为bool的值。返回的值指示作为第一个参数传递的元素是否小于第二个参数。
该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

迭代器到范围中的最大值，如果范围为空则为last。

// min_element/max_element example
#include <iostream>     // std::cout
#include <algorithm>    // std::min_element, std::max_element

bool myfn(int i, int j) { return i<j; }

struct myclass {
  bool operator() (int i,int j) { return i<j; }
} myobj;

int main () {
  int myints[] = {3,7,2,5,6,4,9};

  // using default comparison:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7) << '\n';

  // using function myfn as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myfn) << '\n';

  // using object myobj as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myobj) << '\n';

  return 0;
}

在这里插入图片描述

六、minmax_element

头文件algorithm

default (1)	
template <class ForwardIterator>
  pair<ForwardIterator,ForwardIterator>
    minmax_element (ForwardIterator first, ForwardIterator last);
custom (2)	
template <class ForwardIterator, class Compare>
  pair<ForwardIterator,ForwardIterator>
    minmax_element (ForwardIterator first, ForwardIterator last, Compare comp);

返回范围内的最小和最大元素

返回一个迭代器对，该迭代器指向范围[first，last]中最小值为第一个元素的元素，最大值为第二个元素。

使用运算符<对于第一个版本执行比较，或对于第二个版本执行comp。

如果多个等效元素具有最小值，则第一个迭代器指向第一个这样的元素。

如果多个等效元素具有最大值，则第二个迭代器指向最后一个这样的元素。

参数

first，last
将迭代器输入到要比较的序列的初始和最终位置。使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
comp
二进制函数，接受范围中的两个元素作为参数，并返回可转换为bool的值。返回的值指示作为第一个参数传递的元素是否小于第二个参数。
该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

具有迭代器的对，其指向具有[first，last]范围中的最小值的元素作为第一元素，并且最大值作为第二元素。

pair是中定义的类模板。

// minmax_element
#include <iostream>     // std::cout
#include <algorithm>    // std::minmax_element
#include <array>        // std::array

int main () {
  std::array<int,7> foo {3,7,2,9,5,8,6};

  auto result = std::minmax_element (foo.begin(),foo.end());

  // print result:
  std::cout << "min is " << *result.first;
  std::cout << ", at position " << (result.first-foo.begin()) << '\n';
  std::cout << "max is " << *result.second;
  std::cout << ", at position " << (result.second-foo.begin()) << '\n';

  return 0;
}

在这里插入图片描述