Namespaces
Variants

std::minmax

С ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы для диапазонов (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Неизменяющие операции последовательности    
Пакетные операции
(C++17)
Операции поиска
Изменяющие операции последовательности
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разбиения
(C++11)    

Операции сортировки
Операции двоичного поиска
(по разбитым диапазонам)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции с пирамидой (кучей)
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановки


Политики выполнения (C++17)
(только для демонстрации*)(C++26)

Числовые операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory>алгоритмы

Специализированные <random>алгоритмы
Библиотека C









 
Определён в заголовке <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 перемещение эквивалентно копированию (начиная с 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) Пара (pair) с наименьшим значением в 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);
}

Примечания

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

int n = 1;
auto p = std::minmax(n, n + 1);
int m = p.first; // ok
int x = p.second; // undefined behavior

// Note that structured bindings have the same issue
auto [mm, xx] = std::minmax(n, n + 1);
xx; // undefined behavior

Пример

#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 Применён к Поведение в опубликованном виде Корректное поведение
LWG 2239 C++11 T требовался LessThanComparable для перегрузок (2,4) не требуется

См. также

возвращает меньшее из заданных значений
(шаблон функции & объект функции алгоритма)
возвращает большее из заданных значений
(шаблон функции & объект функции алгоритма)
возвращает наименьший и наибольший элементы в диапазоне
(шаблон функции & объект функции алгоритма)
возвращает меньшее и большее из двух элементов
(объект функции алгоритма)