Namespaces
Variants

std:: minmax

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
minmax
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Определено в заголовке <algorithm>
template < class T >
std:: pair < const T & , const T & > minmax ( const T & a, const T & b ) ;
(1) (начиная с C++11)
(constexpr начиная с C++14)
template < class T, class Compare >

std:: pair < const T & , const T & > minmax ( const T & a, const T & b,

Compare comp ) ;
(2) (начиная с C++11)
(constexpr начиная с C++14)
template < class T >
std:: pair < T, T > minmax ( std:: initializer_list < T > ilist ) ;
(3) (начиная с C++11)
(constexpr начиная с C++14)
template < class T, class Compare >

std:: pair < T, T > minmax ( std:: initializer_list < T > ilist,

Compare comp ) ;
(4) (начиная с C++11)
(constexpr начиная с C++14)

Возвращает наименьшее и наибольшее из заданных значений.

1,2) Возвращает ссылки на меньший и больший из a и b .
1) Использует operator < для сравнения значений.
Если T не является LessThanComparable , поведение не определено.
2) Используйте функцию сравнения comp для сравнения значений.
3,4) Возвращает наименьшее и наибольшее из значений в списке инициализации ilist .
Если ilist. size ( ) равен нулю, или T не является CopyConstructible , поведение не определено.
3) Использует operator < для сравнения значений.
Если T не является LessThanComparable , поведение не определено.
4) Используйте функцию сравнения comp для сравнения значений.

Содержание

Параметры

a, b - сравниваемые значения
ilist - список инициализации со значениями для сравнения
comp - функциональный объект сравнения (т.е. объект, удовлетворяющий требованиям Compare ), который возвращает true если первый аргумент меньше второго.

Сигнатура функции сравнения должна быть эквивалентна следующей:

bool cmp ( const Type1 & a, const Type2 & b ) ;

Хотя сигнатура не обязана содержать const & , функция не должна модифицировать передаваемые ей объекты и должна быть способна принимать все значения типа (возможно const) Type1 и Type2 независимо от категории значения (следовательно, Type1 & не допускается , как и Type1 , если для Type1 перемещение не эквивалентно копированию (since C++11) ).
Типы Type1 и Type2 должны быть такими, чтобы объект типа T мог быть неявно преобразован в оба из них.

Возвращаемое значение

1,2) Возвращает результат std:: pair < const T & , const T & > ( a, b ) если a < b или если a эквивалентен b . Возвращает результат std:: pair < const T & , const T & > ( b, a ) если b < a .
3,4) Пара с наименьшим значением в ilist в качестве первого элемента и наибольшим в качестве второго. Если несколько элементов эквивалентны наименьшему, возвращается крайний левый такой элемент. Если несколько элементов эквиваленты наибольшему, возвращается крайний правый такой элемент.

Сложность

1) Ровно одно сравнение с использованием operator < .
2) Ровно одно применение функции сравнения comp .
3,4) Дано N как ilist. size ( ) :
3) Не более
3N
2
сравнений с использованием operator < .
4) Не более
3N
2
применений функции сравнения comp .

Возможная реализация

minmax (1) 
template<class T>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b)
{
    return (b < a) ? std::pair<const T&, const T&>(b, a)
                   : std::pair<const T&, const T&>(a, b);
}
minmax (2) 
template<class T, class Compare>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp)
{
    return comp(b, a) ? std::pair<const T&, const T&>(b, a)
                      : std::pair<const T&, const T&>(a, b);
}
minmax (3) 
template<class T>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end());
    return std::pair(*p.first, *p.second);
}
minmax (4) 
template<class T, class Compare>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist, Compare comp)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end(), comp);
    return std::pair(*p.first, *p.second);
}
Все HTML-теги, атрибуты и код внутри ` 
` и `` блоков сохранены без изменений. Только текст вне этих блоков был переведен на русский язык в соответствии с требованиями.

Примечания

Для перегрузок ( 1,2 ) , если один из параметров является временным объектом, возвращаемая ссылка становится висячей ссылкой в конце полного выражения, содержащего вызов minmax : 

int n = 1;
auto p = std::minmax(n, n + 1);
int m = p.first; // корректно
int x = p.second; // неопределённое поведение
// Заметим, что структурированные привязки имеют ту же проблему
auto [mm, xx] = std::minmax(n, n + 1);
xx; // неопределённое поведение

Пример

Запустить этот код 
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};
    std::srand(std::time(0));
    std::pair<int, int> bounds = std::minmax(std::rand() % v.size(),
                                             std::rand() % v.size());
    std::cout << "v[" << bounds.first << "," << bounds.second << "]: ";
    for (int i = bounds.first; i < bounds.second; ++i)
        std::cout << v[i] << ' ';
    std::cout << '\n';
}

Возможный вывод: 

v[2,7]: 4 1 5 9 2

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 2239 C++11 T was required to be LessThanComparable for overloads ( 2,4 ) not required

Смотрите также

возвращает меньшее из заданных значений
(function template)
возвращает большее из заданных значений
(function template)
(C++11)
возвращает наименьший и наибольший элементы в диапазоне
(function template)
(C++20)
возвращает меньший и больший из двух элементов
(algorithm function object)