Namespaces
Variants

std:: minmax

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
minmax
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definido en el encabezado <algorithm>
template < class T >
std:: pair < const T & , const T & > minmax ( const T & a, const T & b ) ;
(1) (desde C++11)
(constexpr desde C++14)
template < class T, class Compare >

std:: pair < const T & , const T & > minmax ( const T & a, const T & b,

Compare comp ) ;
(2) (desde C++11)
(constexpr desde C++14)
template < class T >
std:: pair < T, T > minmax ( std:: initializer_list < T > ilist ) ;
(3) (desde C++11)
(constexpr desde C++14)
template < class T, class Compare >

std:: pair < T, T > minmax ( std:: initializer_list < T > ilist,

Compare comp ) ;
(4) (desde C++11)
(constexpr desde C++14)

Devuelve el menor y el mayor de los valores dados.

1,2) Devuelve referencias al menor y al mayor de a y b .
1) Utiliza operator < para comparar los valores.
Si T no es LessThanComparable , el comportamiento es indefinido.
2) Utilice la función de comparación comp para comparar los valores.
3,4) Devuelve el menor y el mayor de los valores en la lista de inicialización ilist .
Si ilist. size ( ) es cero, o T no es CopyConstructible , el comportamiento es indefinido.
3) Utiliza operator < para comparar los valores.
Si T no es LessThanComparable , el comportamiento es indefinido.
4) Utilice la función de comparación comp para comparar los valores.

Contenidos

Parámetros

a, b - los valores a comparar
ilist - lista de inicializadores con los valores a comparar
comp - objeto función de comparación (es decir, un objeto que cumple con los requisitos de Compare ) que devuelve true si el primer argumento es menor que el segundo.

La firma de la función de comparación debe ser equivalente a la siguiente:

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

Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder aceptar todos los valores de tipo (posiblemente const) Type1 y Type2 independientemente de la categoría de valor (por lo tanto, Type1 & no está permitido , ni tampoco Type1 a menos que para Type1 un movimiento sea equivalente a una copia (desde C++11) ).
Los tipos Type1 y Type2 deben ser tales que un objeto de tipo T pueda convertirse implícitamente a ambos.

Valor de retorno

1,2) Devuelve el resultado de std:: pair < const T & , const T & > ( a, b ) si a < b o si a es equivalente a b . Devuelve el resultado de std:: pair < const T & , const T & > ( b, a ) si b < a .
3,4) Un par con el valor más pequeño en ilist como primer elemento y el mayor como segundo. Si varios elementos son equivalentes al más pequeño, se devuelve el elemento más a la izquierda. Si varios elementos son equivalentes al más grande, se devuelve el elemento más a la derecha.

Complejidad

1) Exactamente una comparación utilizando operator < .
2) Exactamente una aplicación de la función de comparación comp .
3,4) Dado N como ilist. size ( ) :
3) Como máximo
3N
2
comparaciones usando operator < .
4) Como máximo
3N
2
aplicaciones de la función de comparación comp .

Implementación posible

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);
}

Notas

Para las sobrecargas ( 1,2 ) , si uno de los parámetros es un temporal, la referencia devuelta se convierte en una referencia colgante al final de la expresión completa que contiene la llamada a minmax : 

int n = 1;
auto p = std::minmax(n, n + 1);
int m = p.first; // correcto
int x = p.second; // comportamiento indefinido
// Nótese que los enlaces estructurados presentan el mismo problema
auto [mm, xx] = std::minmax(n, n + 1);
xx; // comportamiento indefinido

Ejemplo

Ejecutar este código 
#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';
}

Salida posible: 

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2239 C++11 T se requería que fuera LessThanComparable para las sobrecargas ( 2,4 ) no requerido

Véase también

devuelve el menor de los valores dados
(plantilla de función)
devuelve el mayor de los valores dados
(plantilla de función)
(C++11)
devuelve los elementos menor y mayor en un rango
(plantilla de función)
(C++20)
devuelve el elemento menor y mayor de dos elementos
(objeto función de algoritmo)