std:: add_sat

Calcula la suma con saturación 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. Retorna:

• q , si q es representable como un valor de tipo T . De lo contrario,
• el valor mayor o menor de tipo T , el que esté más cerca de q .

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 calificado con cv) 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

Valor de retorno

Saturated x + y .

Notas

A diferencia de los operadores aritméticos incorporados en enteros, la integral promotion no se aplica a los argumentos x y y .

Si se pasan dos argumentos de tipo diferente, la llamada falla al compilar, es decir, el comportamiento relativo a template argument deduction es el mismo que para std::min o std::max .

La mayoría de las arquitecturas de hardware modernas tienen soporte eficiente para aritmética de saturación en vectores SIMD , incluyendo SSE2 para x86 y NEON para ARM .

Implementación posible

Ver libstdc++ (gcc) .

Ejemplo

#include <climits>
#include <limits>
#include <numeric>
static_assert(CHAR_BIT == 8);
static_assert(UCHAR_MAX == 255);
int main()
{
    constexpr int a = std::add_sat(3, 4); // no ocurre saturación, T = int
    static_assert(a == 7);
    constexpr unsigned char b = std::add_sat<unsigned char>(UCHAR_MAX, 4); // saturado
    static_assert(b == UCHAR_MAX);
    constexpr unsigned char c = std::add_sat(UCHAR_MAX, 4); // no saturado, T = int
        // add_sat(int, int) devuelve int tmp == 259,
        // luego la asignación trunca 259 % 256 == 3
    static_assert(c == 3);
//  unsigned char d = std::add_sat(252, c); // Error: deducciones inconsistentes para T
    constexpr unsigned char e = std::add_sat<unsigned char>(251, a); // saturado
    static_assert(e == UCHAR_MAX);
        // 251 es de tipo T = unsigned char, `a` se convierte a valor unsigned char;
        // podría generar una advertencia de conversión int -> unsigned char para `a`
    constexpr signed char f = std::add_sat<signed char>(-123, -3); // no saturado
    static_assert(f == -126);
    constexpr signed char g = std::add_sat<signed char>(-123, -13); // saturado
    static_assert(g == std::numeric_limits<signed char>::min()); // g == -128
}

Véase también

Enlaces externos