std::saturating_sub
| Definido en el encabezado <numeric>
|
||
template< class T >
constexpr T saturating_sub( T x, T y ) noexcept;
|
(desde C++26) | |
Calcula la saturación de la resta 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 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 cercano alq.
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 a operaciones aritméticas.
Parámetros
| x, y | - | valores enteros |
Valor de retorno
Resta saturada x - y.
Notas
A diferencia de los operadores aritméticos integrados en enteros, la promoción integral no se aplica a los argumentos x y y.
Si se pasan dos argumentos de diferente tipo, la llamada falla al compilar, es decir, el comportamiento con respecto 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.
| Macro de prueba de funcionalidad | Valor | Estándar | Funcionalidad |
|---|---|---|---|
__cpp_lib_saturation_arithmetic |
202311L |
(C++26) | Aritmética de saturación |
202603L |
(C++26) | 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
#include <climits>
#include <numeric>
static_assert
(""
&& (std::saturating_sub<int>(INT_MIN + 4, 3) == INT_MIN + 1) // not saturated
&& (std::saturating_sub<int>(INT_MIN + 4, 5) == INT_MIN) // saturated
&& (std::saturating_sub<int>(INT_MAX - 4, -3) == INT_MAX - 1) // not saturated
&& (std::saturating_sub<int>(INT_MAX - 4, -5) == INT_MAX) // saturated
&& (std::saturating_sub<unsigned>(4, 3) == 1) // not saturated
&& (std::saturating_sub<unsigned>(4, 5) == 0) // saturated
);
int main() {}
Véase también
(C++26) |
operación de suma saturada sobre dos enteros (plantilla de función) |
(C++26) |
operación de multiplicación saturada sobre dos enteros (plantilla de función) |
(C++26) |
operación de división saturada sobre dos enteros (plantilla de función) |
(C++26) |
devuelve un valor entero limitado al rango de otro tipo entero (plantilla de función) |
(C++17) |
acota un valor entre un par de valores límite (plantilla de función & objeto de función de algoritmo) |
(C++20) |
|
(C++20) |
comprueba si un valor entero está en el rango de un tipo entero dado (plantilla de función) |
[estático] |
devuelve el valor finito más pequeño del tipo no punto flotante dado, o el valor normal positivo más pequeño del tipo punto flotante dado (función miembro estática pública de std::numeric_limits<T>)
|
[estático] |
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 bifurcaciones de la aritmética de saturación — Locklessinc.com, 2012 |