Namespaces
Variants

std:: max

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
max
(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 & 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 es indefinido.
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 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 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 mayor de a y b . Si son equivalentes, devuelve a .
3,4) El valor máximo en ilist . Si varios valores son equivalentes al máximo, retorna el más a la izquierda.

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

máx (1) 
template<class T> 
const T& max(const T& a, const T& b)
{
    return (a < b) ? b : a;
}
máx (2) 
template<class T, class Compare> 
const T& max(const T& a, const T& b, Compare comp)
{
    return (comp(a, b)) ? b : a;
}
máx (3) 
template<class T>
T max(std::initializer_list<T> ilist)
{
    return *std::max_element(ilist.begin(), ilist.end());
}
máx (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 está colgando

Ejemplo

Ejecutar este código 
#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 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 menor 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 grande 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 mayor de los valores dados
(objeto función de algoritmo)