Namespaces
Variants

std::max

De es.cppreference.net
 
 
Biblioteca de algoritmos
Algoritmos restringidos y algoritmos sobre rangos (C++20)
Algoritmos restringidos, ej. ranges::copy, ranges::sort, ...
Operaciones de secuencia no modificantes    
Operaciones por lotes
(C++17)
Operaciones de búsqueda
Operaciones de secuencia modificantes
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)

Operaciones de ordenamiento y 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 mezcla (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& max( const T& a, const T& b );
(1) (constexpr desde C++14)
template< class T, class Compare >
const T& max( const T& a, const T& b, Compare comp );
(2) (constexpr desde C++14)
template< class T >
T max( std::initializer_list<T> ilist );
(3) (desde C++11)
(constexpr desde C++14)
template< class T, class Compare >
T max( std::initializer_list<T> ilist, Compare comp );
(4) (desde C++11)
(constexpr desde C++14)

Devuelve el mayor de los valores dados.

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

Parámetros

a, b - los valores a comparar
ilist - lista de inicialización con los valores a comparar
comp - 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 signatura de la función de comparación debe ser equivalente a la siguiente:

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

Si bien la signatura 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 mayor de a y b. Si son equivalentes, devuelve a.
3,4) El mayor valor en ilist. Si varios valores son equivalentes al mayor, devuelve el más a la izquierda.

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

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

Notas

Capturar el resultado de std::max por referencia produce una referencia colgante si uno de los parámetros es un temporal y ese parámetro es devuelto:

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

Ejemplo

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

int main()
{
    auto longest = [](const std::string_view s1, const std::string_view s2)
                   {
                       return s1.size() < s2.size();
                   };
    
    std::cout << "Larger of 69 and 96 is " << std::max(69, 96) << "\n"
                 "Larger of 'q' and 'p' is '" << std::max('q', 'p') << "'\n"
                 "Largest of 010, 10, 0X10, and 0B10 is "
              << std::max({010, 10, 0X10, 0B10}) << '\n'
              << R"(Longest of "long", "short", and "int" is )"
              << std::quoted(std::max({"long", "short", "int"}, longest)) << '\n';
}

Salida:

Larger of 69 and 96 is 96
Larger of 'q' and 'p' is 'q'
Largest of 010, 10, 0X10, and 0B10 is 16
Longest of "long", "short", and "int" is "short"

Informes de defectos

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

DR Aplicado a Comportamiento como se publicó Comportamiento correcto
LWG 281 C++98 TSe requería que T fuera CopyConstructible para las sobrecargas (1,2) no requerido
LWG 2239 C++98
C++11
1. TSe requería que T 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

Ver también

devuelve el menor 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 grande en un rango
(plantilla de función & objeto función de algoritmo)
(C++17)
sujeta un valor entre un par de valores límite
(plantilla de función & objeto función de algoritmo)
devuelve el mayor de los valores dados
(objeto función de algoritmo)