Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Négation unaire (`-`) en C++

Le moins unaire calcule l’opposé d’un opérande, tandis que la soustraction binaire calcule une différence. Le type après promotion détermine le comportement aux limites de l’intervalle.

Version : ISO C++23; implementation support may vary

Syntaxe

-expression       // unary negation
left - right      // binary subtraction

En C++23, l’opérateur intégré -x prend un seul opérande et calcule l’opposé de x sans modifier x lui-même. En revanche, a - b est une soustraction binaire à deux opérandes. Dans -7, le moins est un opérateur appliqué au littéral 7, pas une partie du littéral.

Le moins unaire intégré accepte les types arithmétiques et les types énumérés non cloisonnés. Les promotions intégrales s’appliquent aux opérandes entiers et énumérés ; le résultat a le type de l’opérande après une éventuelle promotion. Si ce type est non signé et de largeur N, la négation est calculée modulo 2 à la puissance N. Ainsi, -1u est la plus grande valeur de unsigned int, et non moins un. Évaluer -INT_MIN (<climits>) entraîne un comportement indéfini, car le résultat n’est pas représentable en int. Vérifiez l’intervalle avant de calculer l’opposé.

Dans -DBL_MAX, l’opérande est DBL_MAX, la macro de <cfloat> qui désigne la plus grande valeur finie de double. Pour un double conforme à IEC 60559, le résultat est la borne inférieure des valeurs finies. Pour obtenir cette borne sans supposer cette représentation, utilisez std::numeric_limits<double>::lowest() de <limits>. Pour double, min() donne au contraire la plus petite valeur positive normalisée.

Pour un type classe, la résolution de surcharge peut sélectionner un operator- unaire : une fonction membre non statique sans autre paramètre que le paramètre objet, ou une fonction non membre à un paramètre. La fonction sélectionnée définit le sens de l’opération, sans être tenue de suivre les règles de la négation intégrée.

Exemples

#include <cfloat>
#include <iostream>
#include <limits>

int main() {
    const int x = 7;
    double lower = std::numeric_limits<double>::lowest();
    if constexpr (std::numeric_limits<double>::is_iec559) {
        lower = -DBL_MAX;
    }

    std::cout << "unary: " << -x << '\n'
              << "binary: " << 10 - x << '\n'
              << std::boolalpha
              << "unsigned maximum: " << (-1u == std::numeric_limits<unsigned int>::max()) << '\n'
              << "negative lower bound: " << (lower < 0.0) << '\n';
}

Résultat

unary: -7
binary: 3
unsigned maximum: true
negative lower bound: true

Le programme oppose la négation à la soustraction, puis vérifie le résultat non signé et si la borne inférieure finie est négative. Il n’utilise `-DBL_MAX` que pour un `double` conforme à IEC 60559.

Leçons associées

  • C++ · Leçon 60 · Avancé · Version : 3

Sources