Namespaces
Variants

std:: min

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
min
(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 >
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) 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 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
cmp - objeto función de comparación (es decir, un objeto que cumple con 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 ) ;

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) 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 dichos valores.

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) Exactamente N-1 comparaciones usando operator < .
4) Exactamente N-1 aplicaciones de la función de comparación comp .

Implementación posible

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 de traducción:** - Se han preservado todos los tags HTML y atributos sin cambios - El código C++ dentro de las etiquetas ` 
` y `` no ha sido traducido
- Los términos específicos de C++ (template, class, const, etc.) se mantienen en inglés
- La estructura y formato de la tabla se conserva idéntica al original
- Los enlaces y referencias permanecen sin alteraciones

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 es devuelto: 

int n = -1;
const int& r = std::min(n + 2, n * 2); // r está colgando

Ejemplo

Ejecutar este código 
#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 modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado 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 añadieron los requisitos

Véase también

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