Difference between revisions of "cpp/algorithm/min"
From cppreference.com
m (Text replace - "par req concept" to "par req named") |
(Remove duplicated if) |
||
| Line 57: | Line 57: | ||
{{par | a, b | the values to compare}} | {{par | a, b | the values to compare}} | ||
{{par | ilist | initializer list with the values to compare}} | {{par | ilist | initializer list with the values to compare}} | ||
| − | {{par cmp | cmp | t1=T | | + | {{par cmp | cmp | t1=T | {{tt|a}} is ''less'' than {{tt|b}}}} |
{{par hreq}} | {{par hreq}} | ||
{{par req named | T | LessThanComparable | overloads=1,3}} | {{par req named | T | LessThanComparable | overloads=1,3}} | ||
Revision as of 15:58, 27 November 2018
| Defined in header <algorithm>
|
||
| (1) | ||
| template< class T > const T& min( const T& a, const T& b ); |
(until C++14) | |
| template< class T > constexpr const T& min( const T& a, const T& b ); |
(since C++14) | |
| (2) | ||
| template< class T, class Compare > const T& min( const T& a, const T& b, Compare comp ); |
(until C++14) | |
| template< class T, class Compare > constexpr const T& min( const T& a, const T& b, Compare comp ); |
(since C++14) | |
| (3) | ||
| template< class T > T min( std::initializer_list<T> ilist ); |
(since C++11) (until C++14) |
|
| template< class T > constexpr T min( std::initializer_list<T> ilist ); |
(since C++14) | |
| (4) | ||
| template< class T, class Compare > T min( std::initializer_list<T> ilist, Compare comp ); |
(since C++11) (until C++14) |
|
| template< class T, class Compare > constexpr T min( std::initializer_list<T> ilist, Compare comp ); |
(since C++14) | |
Returns the smaller of the given values.
1-2) Returns the smaller of
a and b. 3-4) Returns the smallest of the values in initializer list
ilist.The (1,3) versions use operator< to compare the values, the (2,4) versions use the given comparison function comp.
Contents |
Parameters
| a, b | - | the values to compare |
| ilist | - | initializer list with the values to compare |
| cmp | - | comparison function object (i.e. an object that satisfies the requirements of Compare) which returns true if a is less than b.The signature of the comparison function should be equivalent to the following: bool cmp(const Type1& a, const Type2& b); While the signature does not need to have const&, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const) |
| Type requirements | ||
-T must meet the requirements of LessThanComparable in order to use overloads (1,3).
| ||
-T must meet the requirements of CopyConstructible in order to use overloads (3,4).
| ||
Return value
1-2) The smaller of
a and b. If the values are equivalent, returns a.3-4) The smallest value in
ilist. If several values are equivalent to the smallest, returns the leftmost such value.Complexity
1-2) Exactly one comparison
3-4) Exactly
ilist.size() - 1 comparisonsPossible implementation
| First version |
|---|
template<class T> const T& min(const T& a, const T& b) { return (b < a) ? b : a; } |
| Second version |
template<class T, class Compare> const T& min(const T& a, const T& b, Compare comp) { return (comp(b, a)) ? b : a; } |
| Third version |
template<class T> T min( std::initializer_list<T> ilist) { return *std::min_element(ilist.begin(), ilist.end()); } |
| Fourth version |
template<class T, class Compare> T min(std::initializer_list<T> ilist, Compare comp) { return *std::min_element(ilist.begin(), ilist.end(), comp); } |
Warning
Capturing the result of std::min by reference produces a dangling reference if one of the parameters is a temporary and that parameter is returned:
int n = -1; const int& r = std::min(n + 2, n * 2); // r is dangling
Example
Run this code
#include <algorithm> #include <iostream> #include <string> int main() { std::cout << "smaller of 1 and 9999: " << std::min(1, 9999) << '\n' << "smaller of 'a', and 'b': " << std::min('a', 'b') << '\n' << "shortest of \"foo\", \"bar\", and \"hello\": " << std::min( { "foo", "bar", "hello" }, [](const std::string& s1, const std::string& s2) { return s1.size() < s2.size(); }) << '\n'; }
Output:
smaller of 1 and 9999: 1 smaller of 'a', and 'b': a shortest of "foo", "bar", and "hello": foo
See also
| returns the greater of the given values (function template) | |
| (C++11) |
returns the smaller and larger of two elements (function template) |
| returns the smallest element in a range (function template) |
