std::saturating_add
| Definido en el encabezado <numeric>
|
||
template< class T >
constexpr T saturating_add( T x, T y ) noexcept;
|
(desde C++26) | |
Calcula la saturación suma x + y. Esta operación (a diferencia de las operaciones aritméticas integradas en enteros) se comporta como si fuera una operación matemática con un rango infinito. Sea q denota el resultado de dicha operación.
Devuelve:
q, siqes representable como un valor de tipoT. De lo contrario,- el valor más grande o más pequeño de tipo
T, el que esté más cerca delq.
Esta sobrecarga participa en la resolución de sobrecarga solo si T es un tipo entero, es decir: signed char, short, int, long, long long, un tipo entero con signo extendido, o una versión sin signo de dichos tipos. En particular, T no debe ser (posiblemente cv-calificado) bool, char, wchar_t, char8_t, char16_t, y char32_t, ya que estos tipos no están destinados para aritmética.
Parámetros
| x, y - | valores enteros | Valor de retorno |
Saturada
.
x + yNotas
A diferencia de los operadores aritméticos integrados en enteros, la
promoción integral no se aplica a los argumentos y x.
ySi se pasan dos argumentos de tipo diferente, la llamada falla al compilar, es decir, el comportamiento relativo a la
deducción de argumentos de plantilla es el mismo que para std::min o std::max. La mayoría de las arquitecturas de hardware modernas tienen soporte eficiente para la aritmética de saturación en
vectores SIMD, incluyendo SSE2 para x86 y NEON para ARM. Feature-test
| macro Valor | Estándar | Característica | (C++26) |
|---|---|---|---|
__cpp_lib_saturation_arithmetic |
202311L |
Aritmética de saturación | (C++26) |
202603L |
Renombramiento de funciones de aritmética de saturación | Posible implementación |
Véase
libstdc++ (GCC), libc++ (Clang). Ejemplo
Se puede previsualizar en
Compiler Explorer. Ejecutar este código
#include <climits>
#include <limits>
#include <numeric>
static_assert(CHAR_BIT == 8);
static_assert(UCHAR_MAX == 255);
int main()
{
constexpr int a = std::saturating_add(3, 4); // no saturation occurs, T = int
static_assert(a == 7);
constexpr unsigned char b = std::saturating_add<unsigned char>(UCHAR_MAX, 4); // saturated
static_assert(b == UCHAR_MAX);
constexpr unsigned char c = std::saturating_add(UCHAR_MAX, 4); // not saturated, T = int
// saturating_add(int, int) returns int tmp == 259,
// then assignment truncates 259 % 256 == 3 (might yield int -> unsigned char warning)
static_assert(c == 3);
// unsigned char d = std::saturating_add(252, c); // Error: inconsistent deductions for T
constexpr unsigned char e = std::saturating_add<unsigned char>(251, a); // saturated
static_assert(e == UCHAR_MAX);
// 251 is of type T = unsigned char, `a` is converted to unsigned char value;
// might yield an int -> unsigned char conversion warning for `a`
constexpr signed char f = std::saturating_add<signed char>(-123, -3); // not saturated
static_assert(f == -126);
constexpr signed char g = std::saturating_add<signed char>(-123, -13); // saturated
static_assert(g == std::numeric_limits<signed char>::min()); // g == -128
}
saturating_sub
operación de resta saturada en dos enteros |
(plantilla de función)
saturating_mul |
operación de multiplicación saturada en dos enteros |
(plantilla de función)
saturating_div |
operación de división saturada en dos enteros |
(plantilla de función)
saturating_cast |
devuelve un valor entero restringido al rango de otro tipo entero |
(plantilla de función)
clamp |
restringe un valor entre un par de valores límite |
(plantilla de función objeto función de algoritmo) &ranges::clamp |
in_range |
|
comprueba si un valor entero está en el rango de un tipo entero dado |
(plantilla de función)
min |
devuelve el valor finito más pequeño del tipo no flotante dado, o el valor normal positivo más pequeño del tipo flotante dado |
(función miembro estática pública de ) std::numeric_limits<T>max
|
devuelve el valor finito más grande del tipo dado |
(función miembro estática pública de ) std::numeric_limits<T>Enlaces externos
|
1.
| Una implementación sin ramificaciones de la aritmética de saturación | Locklessinc.com, 2012 — |