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

CKTIS / C++

Opérateur d’addition +

L’opérateur binaire + additionne des nombres ou déplace un pointeur d’un nombre entier d’éléments. Découvrez ses conversions de types, les limites de l’arithmétique des pointeurs et les risques de dépassement.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

a + b

L’opérateur binaire intégré + dans l’expression a + b calcule la somme de valeurs numériques ; il ne modifie pas lui-même ses opérandes. Les conversions arithmétiques usuelles déterminent un type commun pour les opérandes et le résultat : par exemple, 7 + 0.5 est de type double et vaut 7.5. Les petits types entiers subissent des promotions ; l’addition de deux valeurs short produit donc un résultat de type int.

Les opérateurs additifs se groupent de gauche à droite : a + b + c signifie (a + b) + c. La multiplication a une priorité supérieure, donc a + b * c signifie a + (b * c). Le groupement ne détermine pas l’ordre d’évaluation des opérandes. Un dépassement du résultat d’un type entier signé entraîne un comportement indéfini. Les calculs dont le résultat est un type entier non signé s’effectuent modulo 2^N, où N est la largeur de ce type ; mélanger des types signés et non signés demande de la prudence lors des conversions.

Pour un pointeur p vers un élément de tableau et un entier n, p + n et n + p déplacent tous deux le pointeur de n éléments, et non d’autant d’octets. Le type pointé par p doit être un type objet complet et être similaire au type des éléments du tableau. Si p pointe vers un élément d’un tableau déclaré avec extern dont le type des éléments est encore incomplet à l’endroit où figure l’addition, p + 1 est mal formé, même si le type pointé et celui des éléments sont identiques. Le résultat doit désigner un élément du même tableau ou la position immédiatement après sa fin ; cette dernière position ne doit pas être déréférencée. Sortir de cette plage ou utiliser un pointeur dont le type pointé n’est pas similaire au type des éléments entraîne un comportement indéfini. Par exemple, ajouter 1 à un unsigned int* qui pointe vers un élément d’un tableau de type int[] entraîne un comportement indéfini, même si l’élément suivant se trouve dans les limites du tableau. L’addition de deux pointeurs n’est pas autorisée.

L’opérateur unaire +a est un opérateur distinct, et non l’addition de deux valeurs. Les types définis par l’utilisateur peuvent définir operator+ ; son comportement dépend de la surcharge sélectionnée. Les règles ci-dessus décrivent l’opérateur intégré. L’exemple montre une somme entière, une somme de type double, un déplacement de pointeur et les valeurs inchangées de a et b. La source citée est un projet de travail en évolution, et non un texte C++23 figé.

Exemples

#include <iostream>

int main() {
    int a = 7;
    int b = 5;
    int values[] = {10, 20, 30};
    int* p = values;

    std::cout << a + b << '\n';
    std::cout << a + 0.5 << '\n';
    std::cout << *(p + 1) << '\n';
    std::cout << a << ' ' << b << '\n';
}

Résultat

12
7.5
20
7 5

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources