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
Défini dans l'en-tête <algorithm>
template < class T >
constexpr const T & clamp ( const T & v, const T & lo, const T & hi ) ;
(1) (depuis C++17)
template < class T, class Compare >

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

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

Si la valeur de v est comprise dans l'intervalle [ lo , hi ] , retourne v ; sinon retourne la limite la plus proche.

1) Utilise operator < (jusqu'à C++20) std:: less { } (depuis C++20) pour comparer les valeurs.
Si T n'est pas LessThanComparable , le comportement est indéfini. [1]
2) Utilise la fonction de comparaison comp pour comparer les valeurs.

Si lo est supérieur à hi , le comportement est indéfini.

  1. ↑ Si NaN est évité, T peut être un type à virgule flottante.

Table des matières

Paramètres

v - la valeur à limiter
lo, hi - les bornes entre lesquelles limiter v
comp - fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare ) qui renvoie true si le premier argument est inférieur au second.

La signature de la fonction de comparaison doit être équivalente à ce qui suit :

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

Bien que la signature n'ait pas besoin d'avoir const & , la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) Type1 et Type2 indépendamment de la catégorie de valeur (ainsi, Type1 & n'est pas autorisé , pas plus que Type1 sauf si pour Type1 un déplacement équivaut à une copie (depuis C++11) ).
Les types Type1 et Type2 doivent être tels qu'un objet de type T puisse être implicitement converti vers les deux.

Valeur de retour

Référence à lo si v est inférieur à lo , référence à hi si hi est inférieur à v , sinon référence à v .

Complexité

1) Au maximum deux comparaisons en utilisant operator < (jusqu'au C++20) std:: less { } (depuis C++20) .
2) Au maximum deux applications de la fonction de comparaison comp .

Implémentation possible

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;
}

Notes

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 pendante

Si v est équivalent à l'une des bornes, retourne une référence à v , et non à la borne.

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_clamp 201603L (C++17) std::clamp

Exemple

Exécuter ce code 
#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';
}

Sortie : 

[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

Voir aussi

renvoie la plus petite des valeurs données
(modèle de fonction)
renvoie la plus grande des valeurs données
(modèle de fonction)
(C++20)
vérifie si une valeur entière est dans la plage d'un type entier donné
(modèle de fonction)
(C++20)
limite une valeur entre une paire de valeurs limites
(objet fonction d'algorithme)