Namespaces
Variants

std:: clamp

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
(C++11)
clamp
(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 >
constexpr const T & clamp ( const T & v, const T & lo, const T & hi ) ;
(1) (desde C++17)
template < class T, class Compare >

constexpr const T & clamp ( const T & v, const T & lo, const T & hi,

Compare comp ) ;
(2) (desde C++17)

Si el valor de v está dentro del rango [ lo , hi ] , devuelve v ; de lo contrario devuelve el límite más cercano.

1) Utiliza operator < (hasta C++20) std:: less { } (desde C++20) para comparar los valores.
Si T no es LessThanComparable , el comportamiento es indefinido. [1]
2) Utiliza la función de comparación comp para comparar los valores.

Si lo es mayor que hi , el comportamiento es indefinido.

  1. ↑ Si se evita NaN , T puede ser un tipo de punto flotante.

Contenidos

Parámetros

v - el valor a limitar
lo, hi - los límites entre los cuales limitar v
comp - objeto función de comparación (es decir, un objeto que satisface 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

Referencia a lo si v es menor que lo , referencia a hi si hi es menor que v , de lo contrario referencia a v .

Complejidad

1) Como máximo dos comparaciones usando operator < (until C++20) std:: less { } (since C++20) .
2) Como máximo dos aplicaciones de la función de comparación comp .

Implementación posible

clamp (1) 
template<class T>
constexpr const T& clamp(const T& v, const T& lo, const T& hi)
{
    return clamp(v, lo, hi, less{});
}
clamp (2) 
template<class T, class Compare>
constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp)
{
    return comp(v, lo) ? lo : comp(hi, v) ? hi : v;
}

Notas

Capturing the result of std::clamp by reference produces a dangling reference if one of the parameters is a temporary and that parameter is returned: 
int n = -1;
const int& r = std::clamp(n, 0, 255); // r está colgando

Si v se compara como equivalente a cualquiera de los límites, devuelve una referencia a v , no al límite.

Macro de prueba de características Valor Std Característica
__cpp_lib_clamp 201603L (C++17) std::clamp

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <cstdint>
#include <iomanip>
#include <iostream>
int main()
{
    std::cout << "[raw] "
                 "[" << INT8_MIN << ',' << INT8_MAX << "] "
                 "[0," << UINT8_MAX << "]\n";
    for (const int v : {-129, -128, -1, 0, 42, 127, 128, 255, 256})
        std::cout << std::setw(4) << v
                  << std::setw(11) << std::clamp(v, INT8_MIN, INT8_MAX)
                  << std::setw(8) << std::clamp(v, 0, UINT8_MAX) << '\n';
}

Salida: 

[raw] [-128,127] [0,255]
-129       -128       0
-128       -128       0
  -1         -1       0
   0          0       0
  42         42      42
 127        127     127
 128        127     128
 255        127     255
 256        127     255

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++20)
verifica si un valor entero está en el rango de un tipo entero dado
(plantilla de función)
(C++20)
limita un valor entre un par de valores límite
(objeto función de algoritmo)