Namespaces
Variants

std::min

Desde es.cppreference.net
 
 
Biblioteca de algoritmos
Algoritmos restringidos y algoritmos sobre rangos (C++20)
Algoritmos restringidos, p.ej. ranges::copy, ranges::sort, ...
Operaciones de secuencia no modificadoras    
Operaciones por lotes
(C++17)
Operaciones de búsqueda
Operaciones de secuencia modificadoras
Operaciones de copia
(C++11)
(C++11)
Operaciones de intercambio
Operaciones de transformación
Operaciones de generación
Operaciones de eliminación
Operaciones de cambio de orden
(hasta C++17)(C++11)
(C++20)(C++20)
Operaciones de muestreo
(C++17)

Ordenamiento y operaciones relacionadas
Operaciones de partición
(C++11)    

Operaciones de ordenamiento
Operaciones de búsqueda binaria
(en rangos particionados)
Operaciones de conjuntos (en rangos ordenados)
Operaciones de fusión (en rangos ordenados)
Operaciones de montículo
Operaciones de mínimo/máximo
(C++11)
(C++17)
Operaciones de comparación lexicográfica
Operaciones de permutación


 
Definido en el encabezado <algorithm>
template< class T >
const T& min( const T& a, const T& b );
(1) (constexpr desde C++14)
template< class T, class Compare >
const T& min( const T& a, const T& b, Compare comp );
(2) (constexpr desde C++14)
template< class T >
T min( std::initializer_list<T> ilist );
(3) (desde C++11)
(constexpr desde C++14)
template< class T, class Compare >
T min( std::initializer_list<T> ilist, Compare comp );
(4) (desde C++11)
(constexpr desde C++14)

Devuelve el menor de los valores dados.

1,2) Devuelve el menor de a y b.
1) Usa operator< para comparar los valores.
Si T no es LessThanComparable, el comportamiento no está definido.
2) Use la función de comparación comp para comparar los valores.
3,4) Devuelve el menor de los valores en la lista de inicializadores ilist.
Si ilist.size() es cero, o T no es CopyConstructible, el comportamiento no está definido.
3) Usa operator< para comparar los valores.
Si T no es LessThanComparable, el comportamiento no está definido.
4) Use la función de comparación comp para comparar los valores.

Parámetros

a, b - los valores a comparar
ilist - lista de inicializadores con los valores a comparar
cmp - objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare) que devuelve true si a es menor que b.

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

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

Si bien la firma no necesita tener const&, la función no debe modificar los objetos que se le pasan 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 una mudanza 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) El menor de a y b. Si los valores son equivalentes, devuelve a.
3,4) El valor más pequeño en ilist. Si varios valores son equivalentes al más pequeño, devuelve el valor más a la izquierda de ellos.

Complejidad

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

Posible implementación

min (1)
template<class T>
const T& min(const T& a, const T& b)
{
    return (b < a) ? b : a;
}
min (2)
template<class T, class Compare>
const T& min(const T& a, const T& b, Compare comp)
{
    return (comp(b, a)) ? b : a;
}
min (3)
template<class T>
T min(std::initializer_list<T> ilist)
{
    return *std::min_element(ilist.begin(), ilist.end());
}
min (4)
template<class T, class Compare>
T min(std::initializer_list<T> ilist, Compare comp)
{
    return *std::min_element(ilist.begin(), ilist.end(), comp);
}

Notas

Capturar el resultado de std::min por referencia produce una referencia colgante si uno de los parámetros es temporal y ese parámetro se devuelve:

int n = -1;
const int& r = std::min(n + 2, n * 2); // r is dangling

Ejemplo

#include <algorithm>
#include <iostream>
#include <string_view>

int main()
{
    std::cout << "smaller of 10 and 010 is " << std::min(10, 010) << '\n'
              << "smaller of 'd' and 'b' is '" << std::min('d', 'b') << "'\n"
              << "shortest of \"foo\", \"bar\", and \"hello\" is \""
              << std::min({"foo", "bar", "hello"},
                          [](const std::string_view s1, const std::string_view s2)
                          {
                              return s1.size() < s2.size();
                          }) << "\"\n";
}

Salida:

smaller of 10 and 010 is 8
smaller of 'd' and 'b' is 'b'
shortest of "foo", "bar", and "hello" is "foo"

Informes de defectos

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

DR Aplicado a Comportamiento como se publicó Comportamiento correcto
LWG 281 C++98 T se requería que fuera CopyConstructible para las sobrecargas (1,2) no requerido
LWG 2239 C++98
C++11
1. T se requería que fuera LessThanComparable para
    las sobrecargas (2) (C++98) y (4) (C++11)
2. faltaban los requisitos de complejidad
1. no requerido
2. se agregaron los requisitos

Véase también

devuelve el mayor de los valores dados
(plantilla de función & objeto función de algoritmo)
(C++11)
devuelve el menor y el mayor de dos elementos
(plantilla de función & objeto función de algoritmo)
devuelve el elemento más pequeño en un rango
(plantilla de función & objeto función de algoritmo)
(C++17)
limita un valor entre un par de valores límite
(plantilla de función & objeto función de algoritmo)
devuelve el menor de los valores dados
(objeto función de algoritmo)