Les opérateurs en C++ : arithmétiques, de comparaison, logiques et plus

Le rôle des opérateurs

Un opérateur est un symbole qui effectue une action sur une ou plusieurs valeurs, appelées opérandes. Vous en utilisez déjà un : le = qui lie une valeur à une variable. C++ est livré avec un riche ensemble d'opérateurs pour les mathématiques, la comparaison, la logique et la manipulation de bits - et quelques pièges qui font trébucher les débutants.

À la page précédente, vous avez vu comment const verrouille une valeur. Les opérateurs sont la façon dont vous calculez les valeurs que vous stockez, qu'elles soient constantes ou non. Passons en revue les familles que vous utiliserez tous les jours.

Opérateurs arithmétiques

Les cinq opérateurs arithmétiques sont +, -, *, / et % (modulo, le reste d'une division) :

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << "sum:       " << a + b << "\n";
    cout << "difference: " << a - b << "\n";
    cout << "product:    " << a * b << "\n";
    cout << "quotient:   " << a / b << "\n";
    cout << "remainder:  " << a % b << "\n";

    return 0;
}

Le gros piège se cache dans ce quotient. 17 / 5 affiche 3, pas 3.4. Quand les deux opérandes sont des entiers, / effectue une division entière et jette la partie fractionnaire - il tronque vers zéro, il n'arrondit pas. Si vous voulez une vraie fraction, au moins un opérande doit être à virgule flottante :

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << a / b << "\n";          // 3  -> division entière
    cout << 17.0 / 5 << "\n";       // 3.4 -> 17.0 est un double
    cout << (double)a / b << "\n";  // 3.4 -> convertit un opérande d'abord

    return 0;
}

L'opérateur % ne fonctionne qu'avec des entiers. Utiliser % sur un double est une erreur de compilation - employez std::fmod de <cmath> pour les restes à virgule flottante.

Affectation et opérateurs composés

Un seul = affecte ; il ne compare pas. C++ vous offre des formes composées qui combinent une opération avec l'affectation pour vous éviter de répéter le nom de la variable :

#include <iostream>
using namespace std;

int main() {
    int score = 10;

    score += 5;   // score = score + 5  -> 15
    score -= 3;   // 12
    score *= 2;   // 24
    score /= 4;   // 6
    score %= 4;   // 2

    cout << score << "\n";   // 2
    return 0;
}

Une erreur classique et douloureuse consiste à écrire = là où vous vouliez == dans une condition. if (x = 0) affecte 0 à x puis teste le résultat (qui est faux), au lieu de comparer. Les compilateurs modernes vous avertissent à ce sujet lorsque vous activez les avertissements - gardez -Wall activé et prenez l'avertissement au sérieux.

Opérateurs de comparaison

Les opérateurs de comparaison posent une question oui/non et produisent un bool (true ou false) :

#include <iostream>
using namespace std;

int main() {
    int x = 7, y = 10;

    cout << (x == y) << "\n";  // 0  (false)
    cout << (x != y) << "\n";  // 1  (true)
    cout << (x <  y) << "\n";  // 1
    cout << (x >= 7) << "\n";  // 1

    cout << boolalpha;          // affiche true/false au lieu de 1/0
    cout << (x < y) << "\n";    // true
    return 0;
}

Par défaut, cout affiche un bool sous la forme 1 ou 0. Insérez boolalpha une fois et il bascule vers les mots true/false pour le reste de ce flux.

Un piège subtil : n'enchaînez pas les comparaisons comme 1 < x < 10. Cela s'analyse comme (1 < x) < 10 - la première comparaison produit un bool (0 ou 1), qui est ensuite comparé à 10, si bien que l'ensemble est presque toujours true. Écrivez plutôt 1 < x && x < 10.

Opérateurs logiques et évaluation court-circuit

&& (et), || (ou) et ! (non) combinent des expressions booléennes. Les deux premiers font une évaluation court-circuit : l'évaluation s'arrête dès que le résultat est connu.

#include <iostream>
using namespace std;

bool check(const char* label) {
    cout << "checked " << label << "\n";
    return true;
}

int main() {
    // Le côté droit de && est ignoré car le côté gauche est false :
    if (false && check("A")) {}

    // Le côté droit de || est ignoré car le côté gauche est true :
    if (true || check("B")) {}

    cout << "done\n";
    return 0;
}

Ni check("A") ni check("B") ne s'exécutent jamais - c'est l'évaluation court-circuit. Ce n'est pas qu'une optimisation ; c'est un outil. Vous pouvez écrire en toute sécurité if (ptr != nullptr && ptr->ready) car la partie ptr->ready n'est atteinte que lorsque ptr est non nul, ce qui évite le déréférencement d'un pointeur invalide.

Incrémentation et décrémentation

++ ajoute un ; -- retranche un. Chacun a une forme préfixe et une forme postfixe, et la différence compte lorsque vous utilisez le résultat :

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // incrémente à 6, puis affiche 6 (pré)

    int j = 5;
    cout << j++ << "\n";  // affiche 5, PUIS incrémente à 6 (post)
    cout << j   << "\n";  // 6

    return 0;
}

Quand vous ne voulez que l'effet de bord (dans une boucle for, par exemple), préférez ++i. Pour un int simple, c'est identique, mais pour des types plus lourds comme les itérateurs, la post-incrémentation doit d'abord copier l'ancienne valeur, ce qui est un travail gaspillé.

Un dernier avertissement : ne modifiez pas la même variable deux fois dans une seule expression, comme i = i++ + 1; ou arr[i] = i++;. L'ordre de ces mises à jour n'est pas spécifié et le résultat est un comportement indéfini. Limitez chaque variable à une seule modification par instruction.

Opérateurs bit à bit et priorité

Pour le travail bas niveau, il existe des opérateurs bit à bit : & (et), | (ou), ^ (xor), ~ (non) et les décalages << et >>.

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // littéral binaire : 5

    cout << (flags & 0b0001) << "\n";  // 1  -> le bit 0 est activé
    cout << (flags | 0b0010) << "\n";  // 7  -> active le bit 1
    cout << (flags ^ 0b0101) << "\n";  // 0  -> xor avec lui-même
    cout << (flags << 1)      << "\n"; // 10 -> décalage à gauche, le double

    return 0;
}

Attention : << et >> sont aussi les opérateurs de flux sur cout. À l'intérieur d'une ligne cout, vous avez généralement besoin de parenthèses autour d'un décalage de bits, sinon le compilateur le lit comme une insertion dans le flux.

Enfin, la priorité décide de ce qui se lie en premier lorsque vous mélangez les opérateurs. * et / se lient plus fort que + et -, exactement comme en mathématiques, donc 2 + 3 * 4 vaut 14. La comparaison se lie plus faiblement que l'arithmétique, et les opérateurs logiques &&/|| plus faiblement encore. En cas de doute, ne mémorisez pas toute la table - ajoutez des parenthèses. (a + b) * c est plus clair que de compter sur le lecteur pour se souvenir des règles.

Suivant : la conversion de types

Vous avez vu plus haut que (double)a / b a forcé un entier dans une division à virgule flottante. C'est une conversion (cast) - convertir délibérément une valeur d'un type vers un autre. À la page suivante, nous couvrirons les outils de conversion de C++, des promotions implicites à static_cast, et quand chacun est sûr.