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
Definiert im Header <algorithm>
template < class T >
constexpr const T & clamp ( const T & v, const T & lo, const T & hi ) ;
(1) (seit C++17)
template < class T, class Compare >

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

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

Wenn der Wert von v innerhalb des Bereichs [ lo , hi ] liegt, wird v zurückgegeben; andernfalls wird die nächstgelegene Grenze zurückgegeben.

1) Verwendet operator < (bis C++20) std:: less { } (seit C++20) zum Vergleichen der Werte.
Wenn T nicht LessThanComparable ist, ist das Verhalten undefiniert. [1]
2) Verwendet die Vergleichsfunktion comp zum Vergleichen der Werte.

Wenn lo größer als hi ist, ist das Verhalten undefiniert.

  1. ↑ Falls NaN vermieden wird, kann T ein Gleitkommatyp sein.

Inhaltsverzeichnis

Parameter

v - der zu begrenzende Wert
lo, hi - die Grenzen, zwischen denen v begrenzt werden soll
comp - Vergleichsfunktionsobjekt (d.h. ein Objekt, das die Anforderungen von Compare erfüllt), das true zurückgibt, wenn das erste Argument kleiner als das zweite ist.

Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgender sein:

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

Obwohl die Signatur keine const & benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte der Typen (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt , ebenso wenig wie Type1 , es sei denn, für Type1 ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) ).
Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ T implizit in beide konvertiert werden kann.

Rückgabewert

Referenz auf lo falls v kleiner als lo , Referenz auf hi falls hi kleiner als v , andernfalls Referenz auf v .

Komplexität

1) Höchstens zwei Vergleiche unter Verwendung von operator < (bis C++20) std:: less { } (seit C++20) .
2) Höchstens zwei Anwendungen der Vergleichsfunktion comp .

Mögliche Implementierung

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

Hinweise

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 ist hängend

Wenn v äquivalent zu einer der Grenzen verglichen wird, wird eine Referenz auf v zurückgegeben, nicht auf die Grenze.

Feature-Test Makro Wert Std Feature
__cpp_lib_clamp 201603L (C++17) std::clamp

Beispiel

Diesen Code ausführen 
#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';
}

Ausgabe: 

[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

Siehe auch

gibt den kleineren der gegebenen Werte zurück
(Funktions-Template)
gibt den größeren der gegebenen Werte zurück
(Funktions-Template)
(C++20)
prüft, ob ein ganzzahliger Wert im Wertebereich eines gegebenen Ganzzahltyps liegt
(Funktions-Template)
(C++20)
begrenzt einen Wert zwischen einem Paar von Grenzwerten
(Algorithmus-Funktionsobjekt)