std::min — cppreference.com

Материал из cppreference.com

Объявление

Определено в заголовочном файле `<algorithm>`
`template< class T > const T& min( const T& a, const T& b );`	(1)	(constexpr начиная с C++14)
`template< class T, class Compare > const T& min( const T& a, const T& b, Compare comp );`	(2)	(constexpr начиная с C++14)
`template< class T > T min( std::initializer_list<T> ilist );`	(3)	(начиная с C++11) (constexpr начиная с C++14)
`template< class T, class Compare > T min( std::initializer_list<T> ilist, Compare comp );`	(4)	(начиная с C++11) (constexpr начиная с C++14)

Описание

1,2) Возвращает меньшее из двух значений.

3,4) Возвращает наименьшее из значений в списке инициализации ilist.

1,3) версии используют operator< для сравнения значений,

2,4) версии используют данную функцию сравнения comp.

Параметры

`a, b`	—	значения для сравнения
`ilist`	—	список инициализации содержащий значения для сравнения
cmp	—	объект функции сравнения (т.е. объект, удовлетворяющий требованиям Compare), который возвращает `true`, если если `a` меньше чем `b`. Определение сравнения должно быть эквивалентно: `bool cmp(const Type1 &a, const Type2 &b);` Использование `noexcept` (начиная с C++11) желательно но не обязательно. Параметры не обязаны передаваться по `const&`, но не должны модифицироваться. Они должны быть способны принимать все значения типа (даже `const`) `Type1` и `Type2` независимо от категории значений (таким образом, `Type1&` не допускается, равно как и `Type1`, если только для `Type1` перемещение не эквивалентно копированию (начиная с C++11)). Типы `Type1` и `Type2` должны быть таковы, что объект типа `T` может быть преобразован в оба из них.
Требования к типам
-`T` должен соответствовать требованиям `LessThanComparable`. для вариантов (1,3)
-`T` должен соответствовать требованиям `CopyConstructible`. для вариантов (3,4)

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

1,2) Меньший из a и b. Если значения эквивалентны, возвращает a.

3,4) Наименьшее значение в ilist. Если несколько самых маленьких значений эквивалентны, возвращает первое(левое) такое значение.

Предусловия

См. #Описание и Требования к типам параметров

Постусловия

1) [[assume(!((a<result)||(b<result)))]]

2) [[assume(!(cmp(result,a)||cmp(result,b)))]]

Исключения

Сильная гарантия, но не выше чем cmp

Сложность

1,2) O(1) - константная.

3,4) O(ilist.size()) - пропорциональна ilist.size().

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

Первый вариант
template<class T> const T& min(const T& a, const T& b) { return (a < b) ? a : b; }
Второй вариант
template<class T, class Compare> const T& min(const T& a, const T& b, Compare comp) { return (comp(a, b)) ? a : b; }
Третий вариант
template<class T> T min( std::initializer_list<T> ilist) { return *std::min_element(ilist.begin(), ilist.end()); }
Четвёртый вариант
template<class T, class Compare> T min(std::initializer_list<T> ilist, Compare comp) { return *std::min_element(ilist.begin(), ilist.end(), comp); }

Пример

#include <algorithm>
#include <iostream>

int main()
{
    auto inv=[](auto const&a,decltype(a)const&b)noexcept->bool{return b<a;};
    std::cout << "std::min(1, 9999) = "
              <<  std::min(1, 9999) << '\n';
    std::cout << "std::min('a', 'b') = "
              <<  std::min('a', 'b') << '\n';
    std::cout << "std::min({4.1, 3.5, 2.5}) = "
              <<  std::min({4.1, 3.5, 2.5}) << '\n';
    std::cout << "std::min(1, 9999, inv) = "
              <<  std::min(1, 9999, inv) << '\n';
    std::cout << "std::min('a', 'b', inv) = "
              <<  std::min('a', 'b', inv ) << '\n';
    std::cout << "std::min({4.1, 3.5, 2.5}, inv) = "
              <<  std::min({4.1, 3.5, 2.5}, inv) << '\n';
}

Вывод:

std::min(1, 9999) = 1
std::min('a', 'b') = a
std::min({4.1, 3.5, 2.5}) = 2.5
std::min(1, 9999, inv) = 9999
std::min('a', 'b', inv) = b
std::min({4.1, 3.5, 2.5}, inv) = 4.1

Defect reports

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам 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. добавлено к требованиям

См. также

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

Категории: