std:: add_sat

Calcule l'addition saturante x + y . Cette opération (contrairement aux opérations arithmétiques intégrées sur les entiers ) se comporte comme s'il s'agissait d'une opération mathématique avec une plage infinie . Soit q le résultat d'une telle opération. Retourne :

• q , si q est représentable comme une valeur de type T . Sinon,
• la plus grande ou la plus petite valeur de type T , selon celle qui est la plus proche de q .

Cette surcharge participe à la résolution de surcharge uniquement si T est un type entier , c'est-à-dire : signed char , short , int , long , long long , un type entier signé étendu, ou une version non signée de ces types. En particulier, T ne doit pas être (éventuellement qualifié cv) bool , char , wchar_t , char8_t , char16_t , et char32_t , car ces types ne sont pas destinés à l'arithmétique.

Paramètres

Valeur de retour

Saturated x + y .

Notes

Contrairement aux opérateurs arithmétiques intégrés sur les entiers, la promotion intégrale ne s'applique pas aux arguments x et y .

Si deux arguments de types différents sont passés, l'appel échoue à la compilation, c'est-à-dire que le comportement relatif à la déduction d'arguments de template est le même que pour std::min ou std::max .

La plupart des architectures matérielles modernes disposent d'une prise en charge efficace de l'arithmétique de saturation pour les vecteurs SIMD , incluant SSE2 pour x86 et NEON pour ARM .

Implémentation possible

Voir libstdc++ (gcc) .

Exemple

#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); // aucune saturation ne se produit, T = int
    static_assert(a == 7);
    constexpr unsigned char b = std::add_sat<unsigned char>(UCHAR_MAX, 4); // saturé
    static_assert(b == UCHAR_MAX);
    constexpr unsigned char c = std::add_sat(UCHAR_MAX, 4); // non saturé, T = int
        // add_sat(int, int) retourne int tmp == 259,
        // puis l'assignation tronque 259 % 256 == 3
    static_assert(c == 3);
//  unsigned char d = std::add_sat(252, c); // Erreur : déductions incohérentes pour T
    constexpr unsigned char e = std::add_sat<unsigned char>(251, a); // saturé
    static_assert(e == UCHAR_MAX);
        // 251 est de type T = unsigned char, `a` est converti en valeur unsigned char ;
        // peut générer un avertissement de conversion int -> unsigned char pour `a`
    constexpr signed char f = std::add_sat<signed char>(-123, -3); // non saturé
    static_assert(f == -126);
    constexpr signed char g = std::add_sat<signed char>(-123, -13); // saturé
    static_assert(g == std::numeric_limits<signed char>::min()); // g == -128
}

Voir aussi

Liens externes