Namespaces
Variants
Views
Actions

std::minmax

From cppreference.com
< cpp‎ | algorithm
Revision as of 22:45, 31 May 2013 by P12bot (Talk | contribs)

 
 
 
Defined in header <algorithm>
template< class T >
std::pair<const T&,const T&> minmax( const T& a, const T& b );
(1) (since C++11)
template< class T, class Compare >
std::pair<const T&,const T&> minmax( const T& a, const T& b, Compare comp );
(2) (since C++11)
template< class T >
std::pair<T,T> minmax( std::initializer_list<T> ilist);
(3) (since C++11)
template< class T, class Compare >
std::pair<T,T> minmax( std::initializer_list<T> ilist, Compare comp );
(4) (since C++11)
1-2) Returns the smaller and the greater of the two values.
3-4) Returns the smallest and the greatest of the values in initializer list ilist.

The (1,3) versions use operator< to compare the values, whereas 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
comp - 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:

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

The signature does not need to have const &, but the function object must not modify the objects passed to it.
The types Type1 and Type2 must be such that an object of type T can be implicitly converted to both of them. ​

Type requirements
-
T must meet the requirements of LessThanComparable. for the overloads (1) and (3)
-
T must meet the requirements of CopyConstructible. for the overloads (3) and (4)

Return value

1-2) Returns the result of std::make_pair(a, b) if a<b or if a is equivalent to b. Returns the result of std::make_pair(b, a) if b<a.
3-4) A pair with the smallest value in ilist as the first element and the greatest as the second. If several elements are equivalent to the smallest, the leftmost such element is returned. If several elements are equivalent to the largest, the rightmost such element is returned.

Complexity

1-2) Constant
3-4) Linear in ilist.size()

Possible implementation

First version
template<class T> 
std::pair<const T&,const T&> minmax(const T& a, const T& b)
{
    return (b < a) ? std::make_pair(b, a)
                   : std::make_pair(a, b);
}
Second version
template<class T, class Compare> 
std::pair<const T&,const T&> minmax(const T& a, const T& b, Compare comp)
{
    return comp(b, a) ? std::make_pair(b, a)
                      : std::make_pair(a, b);
}
Third version
template< class T >
std::pair<T,T> minmax( std::initializer_list ilist)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end());
    return std::make_pair(*p.first, *p.second);
}
Fourth version
template< class T, class Compare >
std::pair<T,T> minmax( std::initializer_list ilist, Compare comp )
{
    auto p = std::minmax_element(ilist.begin(), ilist.end(), comp);
    return std::make_pair(*p.first, *p.second);
}

Example

#include <algorithm>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
 
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';
}

Possible output:

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

See also

returns the smaller of two elements
(function template) [edit]
returns the larger of two elements
(function template) [edit]