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
.
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 if a is less than b . The signature of the comparison function should be equivalent to the following:
The signature does not need to have |
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); } |
Notes
Capturing the result of std::min
by reference if one of the parameters is rvalue produces a dangling reference if that parameter is returned:
int n = 1; const int& r = std::min(n-1, n+1); // r is dangling
Example
#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 larger and the smaller of two elements (function template) |
returns the smallest element in a range (function template) |
Please login to continue.