# C++ Operators : opérateurs importants du langage orienté objet

Que vous [appreniez le C++](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/apprendre-le-c/) ou que vous travailliez avec ce langage de programmation depuis longtemps, les opérateurs C++ constituent la base d’une programmation efficace. Même si la signification de certains opérateurs est intuitive, ce n’est pas le cas pour tous.

## Que sont les opérateurs C++ ?

Fondamentalement, un opérateur est simplement **un caractère désignant une opération**. Un opérateur peut faire référence à un opérande, mais fréquemment, il réfère à plusieurs de ces derniers. Par conséquent, dans la plupart des cas, vous obtenez une nouvelle valeur. Un exemple populaire sont les opérateurs arithmétiques, par exemple « + » pour additionner et « - » pour soustraire deux nombres.

Les opérateurs C++ ne sont pas uniquement différenciés sur la base de leur fonction. Le **statut de l’opérateur ou son affinité** sont également des critères importants de différenciation :

<table>
  <thead>
    <tr>
      <th><strong>Continuité</strong></th>
      <th><strong>Nombre d’opérandes</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Opérateurs unaires</td>
      <td>Un opérande</td>
      <td>Négation logique : `!var_name`</td>
    </tr>
    <tr>
      <td>Opérateurs binaires</td>
      <td>Deux opérandes</td>
      <td>Ajout : `value1 + value2`</td>
    </tr>
    <tr>
      <td>Opérateurs ternaires</td>
      <td>Trois opérandes</td>
      <td>Condition if-else : `condition? condition_true : condition_false`</td>
    </tr>
  </tbody>
</table>

## Priorité de l’opérateur

Comme pour les opérateurs arithmétiques simples ou les [opérateurs Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-python/), il existe également une priorisation des opérateurs C++. Celle-ci indique **l’ordre dans lequel les opérateurs sont analysés**. Pour les opérateurs arithmétiques, les règles connues de point avant tiret s’appliquent. Cependant, il existe également d’autres règles que vous devez suivre pour les autres opérateurs C++.

```cpp
if (var1 && var2 || var3) {
    do_something();
}
```

Dans l’exemple ci-dessus, l’expression logique après l’opérateur « if » est évaluée en premier. Ici encore, l’opérateur « &amp;&amp; » (ET logique) a priorité sur l’opérateur « || » (OU logique). Ainsi, si l’évaluation de « var1 &amp;&amp; var2 » ou l’évaluation de « var3 » renvoie à « true », l’appel de fonction de « do\_something() » est exécuté.

Si vous voulez plus de certitude, vous pouvez également utiliser **des parenthèses**.

### Surcharge des opérateurs en C++

Vous pouvez surcharger la plupart des opérateurs C++. Cela signifie que vous pouvez attribuer **un nouveau sens à un opérateur existant dans un contexte**. Pour effectuer une surcharge d’opérateur en C++, vous devez utiliser le **mot-clé «operator** ». Ensuite, vous définissez l’opérateur C++ que vous souhaitez surcharger. Sinon, la surcharge des opérateurs en C++ se comporte comme une surcharge de fonctions.

## Présentation des opérateurs C++

### Opérateurs arithmétiques

Certains des opérateurs arithmétiques C++ sont déjà connus depuis l’école. Ils fonctionnent avec des nombres et renvoient ensuite un nouveau nombre. À deux exceptions près (les plus et moins que nous pouvons considérer comme des signes), les opérateurs arithmétiques sont tous des opérateurs binaires.

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`+`</td>
      <td>Addition / plus unaire</td>
      <td>`6 + 4`</td>
    </tr>
    <tr>
      <td>`-`</td>
      <td>Soustraction / moins unaire</td>
      <td>`10 - 6`</td>
    </tr>
    <tr>
      <td>`*`</td>
      <td>Multiplication</td>
      <td>`10*  3`</td>
    </tr>
    <tr>
      <td>`/`</td>
      <td>Division</td>
      <td>`20 / 10`</td>
    </tr>
    <tr>
      <td>`%`</td>
      <td>Modulo</td>
      <td>`21 % 2`</td>
    </tr>
  </tbody>
</table>

### Opérateurs d’affectation

Comme dans la plupart des langages de programmation, les valeurs sont stockées dans des variables en C++. Pour affecter des valeurs spécifiques à de telles variables, vous avez besoin d’opérateurs spéciaux.

#### Opérateurs d’affectation simples

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`=`</td>
      <td>Affectation simple</td>
      <td>`x = 3`</td>
    </tr>
    <tr>
      <td>`++`</td>
      <td>Incrémenter</td>
      <td>`x++`</td>
    </tr>
    <tr>
      <td>`--`</td>
      <td>Décrémenter</td>
      <td>`x--`</td>
    </tr>
  </tbody>
</table>

#### Opérateurs d’affectation composés

En plus des opérateurs d’affectation simples, le C++ prend également en charge les opérateurs composés. Il s’agit d’opérations arithmétiques ou « bit à bit » connectées **simultanément à une affectation de valeur** :

```cpp
int x = 4 ;
x += 2 ;
```

Dans l’exemple de code ci-dessus, la variable « x » reçoit une valeur numérique de 4 selon une affectation simple. L’opérateur d’affectation composé « += » est ensuite utilisé pour effectuer un ajout arithmétique et stocker la valeur résultante directement dans « x ». L’affectation se présente comme suit : « x = x + 2 ».

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`+=`</td>
      <td>Somme et affectation</td>
      <td>`x += 2`</td>
    </tr>
    <tr>
      <td>`-=`</td>
      <td>Soustraction et affectation</td>
      <td>`x -= 2`</td>
    </tr>
    <tr>
      <td>`*=`</td>
      <td>Multiplication et affectation</td>
      <td>`x* = 2`</td>
    </tr>
    <tr>
      <td>`/=`</td>
      <td>Division et affectation</td>
      <td>`x /= 2`</td>
    </tr>
    <tr>
      <td>`%=`</td>
      <td>Modulo et affectation</td>
      <td>`x % = 2`</td>
    </tr>
    <tr>
      <td>`&=`</td>
      <td>Opérateur de bits ET et affectation</td>
      <td>`b &= 1`</td>
    </tr>
    <tr>
      <td>`<<=`</td>
      <td>Rotation à gauche et affectation</td>
      <td>`b <<= 1`</td>
    </tr>
    <tr>
      <td>`>>=`</td>
      <td>Rotation à droite et affectation</td>
      <td>`b >>= 1`</td>
    </tr>
    <tr>
      <td>`^=`</td>
      <td>Opérateur de bits OU et affectation</td>
      <td>`b ^= 1`</td>
    </tr>
    <tr>
      <td>`</td><td>=`</td>
      <td>Opérateur de bits OU et affectation</td>
    </tr>
  </tbody>
</table>

### Opérateurs C++ logiques

Vous pouvez utiliser les opérateurs C++ logiques pour faire des comparaisons de deux expressions. À l’exception d’expression « non logique », qui fait toujours référence à une seule instruction et annule sa vraie valeur, les opérateurs logiques sont binaires.

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`&&`</td>
      <td>ET logique</td>
      <td>`true && true`</td>
    </tr>
    <tr>
      <td>`</td><td></td><td>`</td>
    </tr>
    <tr>
      <td>`!`</td>
      <td>NON logique</td>
      <td>`!true`</td>
    </tr>
  </tbody>
</table>

### Opérateurs de comparaison

Les opérateurs de comparaison sont des opérateurs C++ qui examinent la relation entre deux éléments ; ils sont donc binaires. À l’exception de la comparaison à trois voies qui renvoie un nombre, la valeur renvoyée par tous les opérateurs de comparaison C++ est une vraie valeur.

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`==`</td>
      <td>Égalité</td>
      <td>`a == b`</td>
    </tr>
    <tr>
      <td>`!=`</td>
      <td>Inégalité</td>
      <td>`a != b`</td>
    </tr>
    <tr>
      <td>`<=`</td>
      <td>Inférieur ou égal à</td>
      <td>`a <= b`</td>
    </tr>
    <tr>
      <td>`>=`</td>
      <td>Supérieur ou égal à</td>
      <td>`a >= b`</td>
    </tr>
    <tr>
      <td>`<`</td>
      <td>Plus petit que</td>
      <td>`a < b`</td>
    </tr>
    <tr>
      <td>`>`</td>
      <td>Plus grand que</td>
      <td>`a > b`</td>
    </tr>
    <tr>
      <td>`<=>`</td>
      <td>Comparaison à trois</td>
      <td>`a <=> b`</td>
    </tr>
  </tbody>
</table>

### Manipulation des bits

Pour pouvoir accéder efficacement à des bits individuels et améliorer la vitesse des programmes, il existe des opérateurs de bits C++ qui sont particulièrement importants pour la programmation axée sur la performance.

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`&`</td>
      <td>Opérateur de bits ET</td>
      <td>`a & b`</td>
    </tr>
    <tr>
      <td>`</td><td>`</td>
      <td>Opérateur de bits OU</td>
    </tr>
    <tr>
      <td>`^`</td>
      <td>Opérateur de bits OU exclusifs</td>
      <td>`a ^ b`</td>
    </tr>
    <tr>
      <td>`~`</td>
      <td>Opérateur de complément à 1</td>
      <td>`~a`</td>
    </tr>
    <tr>
      <td>`<<`</td>
      <td>Opérateurs de décalage vers la gauche</td>
      <td>`a << b`</td>
    </tr>
    <tr>
      <td>`>>`</td>
      <td>Opérateurs de décalage vers la droite</td>
      <td>`a >> b`</td>
    </tr>
  </tbody>
</table>

### Gestion du stockage

C++ est un langage machine et propose donc un certain nombre d’opérateurs pour vous aider à gérer la mémoire.

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`&`</td>
      <td>Détermine l’adresse</td>
      <td>`& x`</td>
    </tr>
    <tr>
      <td>`sizeof()`</td>
      <td>Détermine les besoins en mémoire d’une expression</td>
      <td>`sizeof(x)`</td>
    </tr>
    <tr>
      <td>`new`</td>
      <td>Crée un nouvel objet et retourne des pointeurs</td>
      <td>`object* pointer = new object()`</td>
    </tr>
    <tr>
      <td>`delete`</td>
      <td>Supprime un objet</td>
      <td>`delete object`</td>
    </tr>
  </tbody>
</table>

### Accès aux données pour les objets et les pointeurs

Les opérateurs C++ suivants vous aideront si vous souhaitez accéder aux membres individuels des objets ou aux zones de stockage des pointeurs.

<table>
  <thead>
    <tr>
      <th><strong>Opérateur C++</strong></th>
      <th><strong>Signification</strong></th>
      <th><strong>Exemple</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`*`</td>
      <td>Opérateur d’indirection</td>
      <td>`*pointer = 3;`</td>
    </tr>
    <tr>
      <td>`.`</td>
      <td>Opérateurs d’accès aux membres</td>
      <td>`object.member = 2;`</td>
    </tr>
    <tr>
      <td>`->`</td>
      <td>Opérateurs d’accès aux membres avec un pointeur</td>
      <td>`objectpointer-> member = 2 ;`</td>
    </tr>
  </tbody>
</table>


This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-c/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-c/) for AI/LLM consumption.