Implémenter les opérateurs C++

Introduction

Dans ce laboratoire (lab), vous apprendrez à implémenter divers opérateurs C++, y compris les opérations mathématiques de base, les opérateurs d'incrémentation/décrémentation, les opérateurs relationnels et logiques, les opérations au niveau des bits, les affectations composées, l'ordre des opérations et l'opérateur conditionnel ternaire. Ces opérateurs fondamentaux sont essentiels pour effectuer des opérations arithmétiques, faire des comparaisons et manipuler des données en programmation C++. Grâce à une série d'exercices pratiques, vous acquerrez une solide compréhension de la manière d'utiliser efficacement ces opérateurs pour construire des applications C++ plus complexes et plus efficaces.

Effectuer des opérations mathématiques de base (+, -, *, /, %)

Dans cette étape, vous apprendrez à effectuer des opérations mathématiques de base en C++. Les opérations mathématiques sont fondamentales en programmation et vous permettent de manipuler des valeurs numériques à l'aide d'opérateurs arithmétiques standard.

Ouvrez le WebIDE et créez un nouveau fichier appelé math_operations.cpp dans le répertoire ~/project :

touch ~/project/math_operations.cpp

Ajoutez le code suivant au fichier math_operations.cpp :

#include <iostream>

int main() {
    // Déclarer des variables pour les opérations mathématiques
    int a = 10;
    int b = 3;

    // Addition (+)
    int sum = a + b;
    std::cout << "Addition: " << a << " + " << b << " = " << sum << std::endl;

    // Soustraction (-)
    int difference = a - b;
    std::cout << "Soustraction: " << a << " - " << b << " = " << difference << std::endl;

    // Multiplication (*)
    int product = a * b;
    std::cout << "Multiplication: " << a << " * " << b << " = " << product << std::endl;

    // Division (/)
    int quotient = a / b;
    std::cout << "Division: " << a << " / " << b << " = " << quotient << std::endl;

    // Modulo (%) - Reste de la division
    int remainder = a % b;
    std::cout << "Modulo: " << a << " % " << b << " = " << remainder << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ math_operations.cpp -o math_operations
./math_operations

Exemple de sortie :

Addition: 10 + 3 = 13
Soustraction: 10 - 3 = 7
Multiplication: 10 * 3 = 30
Division: 10 / 3 = 3
Modulo: 10 % 3 = 1

Analysons les opérateurs mathématiques :

+ (Addition) : Additionne deux nombres. Par exemple, 5 + 3 donnerait 8.
- (Soustraction) : Soustrait le deuxième nombre du premier. Par exemple, 10 - 4 donnerait 6.
* (Multiplication) : Multiplie deux nombres. Par exemple, 6 * 7 donnerait 42.
/ (Division) : Divise le premier nombre par le deuxième. Lorsque les deux nombres sont des entiers, cela entraîne une division entière, ce qui signifie que la partie décimale est tronquée. Par exemple, 10 / 3 donnerait 3.
% (Modulo) : Renvoie le reste de la division. Par exemple, 10 % 3 donnerait 1 car le reste de 10 divisé par 3 est 1.

Quelques notes importantes :

La division entière tronque la partie décimale. Par exemple, 5 / 2 donnera 2, pas 2.5.
L'opérateur de modulo ne fonctionne qu'avec des types entiers. Vous ne pouvez pas l'utiliser avec des nombres à virgule flottante (comme float ou double).
Soyez toujours prudent avec la division par zéro, qui provoque des erreurs d'exécution. Votre programme plantera si vous essayez de diviser n'importe quel nombre par zéro.

Utiliser les incrémentations/décrémentations préfixées et postfixées (++i, i++)

Dans cette étape, vous apprendrez à utiliser les opérateurs d'incrémentation et de décrémentation en C++. Ces opérateurs vous permettent d'augmenter ou de diminuer la valeur d'une variable de 1, avec des différences subtiles entre l'incrémentation préfixée et l'incrémentation postfixée.

Ouvrez le WebIDE et créez un nouveau fichier appelé increment_decrement.cpp dans le répertoire ~/project :

touch ~/project/increment_decrement.cpp

Ajoutez le code suivant au fichier increment_decrement.cpp :

#include <iostream>

int main() {
    // Incrémentation préfixée (++i)
    int a = 5;
    std::cout << "Valeur originale de a: " << a << std::endl;

    // Incrémentation préfixée : l'incrémentation se produit avant l'utilisation de la valeur
    std::cout << "Incrémentation préfixée (++a): " << ++a << std::endl;
    std::cout << "Valeur après incrémentation préfixée: " << a << std::endl;

    // Incrémentation postfixée (i++)
    int b = 5;
    std::cout << "\nValeur originale de b: " << b << std::endl;

    // Incrémentation postfixée : l'incrémentation se produit après l'utilisation de la valeur
    std::cout << "Incrémentation postfixée (b++): " << b++ << std::endl;
    std::cout << "Valeur après incrémentation postfixée: " << b << std::endl;

    // Les opérateurs de décrémentation fonctionnent de la même manière
    int c = 5;
    std::cout << "\nDécrémentation préfixée (--c): " << --c << std::endl;

    int d = 5;
    std::cout << "Décrémentation postfixée (d--): " << d-- << std::endl;
    std::cout << "Valeur après décrémentation postfixée: " << d << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ increment_decrement.cpp -o increment_decrement
./increment_decrement

Exemple de sortie :

Valeur originale de a: 5
Incrémentation préfixée (++a): 6
Valeur après incrémentation préfixée: 6

Valeur originale de b: 5
Incrémentation postfixée (b++): 5
Valeur après incrémentation postfixée: 6

Décrémentation préfixée (--c): 4
Décrémentation postfixée (d--): 5
Valeur après décrémentation postfixée: 4

Principales différences :

Incrémentation préfixée ++i : Incrémente la valeur avant qu'elle ne soit utilisée dans l'expression. Dans l'exemple de code, ++a incrémente d'abord a à 6, puis la valeur 6 est utilisée dans l'instruction cout.
Incrémentation postfixée i++ : Utilise d'abord la valeur actuelle dans l'expression, puis incrémente la valeur. Dans l'exemple de code, b++ utilise d'abord la valeur actuelle de b, qui est 5, dans l'instruction cout, puis incrémente b à 6.

Les mêmes principes s'appliquent aux opérateurs de décrémentation --i et i--, où --i décrémente d'abord la valeur puis l'utilise, et i-- utilise d'abord la valeur puis la décrémente.

Notes importantes :

L'incrémentation préfixée modifie la valeur avant qu'elle ne soit utilisée dans une expression, ce qui signifie que la valeur incrémentée est immédiatement disponible pour utilisation.
L'incrémentation postfixée utilise d'abord la valeur originale, puis l'incrémente. Cela signifie que vous obtenez la valeur originale dans l'instruction actuelle et la valeur incrémentée dans la suivante.
Ces opérateurs sont couramment utilisés dans les boucles (comme les boucles for) et les expressions complexes où vous souhaitez modifier une variable tout en utilisant sa valeur.
Lorsque vous utilisez ces opérateurs, surtout dans des expressions complexes, il est important de garder à l'esprit si vous avez besoin de la version préfixée ou postfixée pour obtenir le comportement souhaité.

Comparer des valeurs à l'aide d'opérateurs relationnels (<, >, ==,!=)

Dans cette étape, vous apprendrez à utiliser les opérateurs relationnels en C++. Ces opérateurs vous aident à comparer des valeurs et à déterminer les relations entre différents nombres ou variables.

Ouvrez le WebIDE et créez un nouveau fichier appelé relational_operators.cpp dans le répertoire ~/project :

touch ~/project/relational_operators.cpp

Ajoutez le code suivant au fichier relational_operators.cpp :

#include <iostream>

int main() {
    int a = 10;
    int b = 5;
    int c = 10;

    // Inférieur à (<)
    std::cout << "Inférieur à (<):" << std::endl;
    std::cout << a << " < " << b << " est " << (a < b) << std::endl;
    std::cout << b << " < " << a << " est " << (b < a) << std::endl;

    // Supérieur à (>)
    std::cout << "\nSupérieur à (>):" << std::endl;
    std::cout << a << " > " << b << " est " << (a > b) << std::endl;
    std::cout << b << " > " << a << " est " << (b > a) << std::endl;

    // Égal à (==)
    std::cout << "\nÉgal à (==):" << std::endl;
    std::cout << a << " == " << b << " est " << (a == b) << std::endl;
    std::cout << a << " == " << c << " est " << (a == c) << std::endl;

    // Différent de (!=)
    std::cout << "\nDifférent de (!=):" << std::endl;
    std::cout << a << "!= " << b << " est " << (a!= b) << std::endl;
    std::cout << a << "!= " << c << " est " << (a!= c) << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ relational_operators.cpp -o relational_operators
./relational_operators

Exemple de sortie :

Inférieur à (<):
10 < 5 est 0
5 < 10 est 1

Supérieur à (>):
10 > 5 est 1
5 > 10 est 0

Égal à (==):
10 == 5 est 0
10 == 10 est 1

Différent de (!=):
10!= 5 est 1
10!= 10 est 0

Points clés sur les opérateurs relationnels :

< (Inférieur à) : Vérifie si la valeur de gauche est inférieure à la valeur de droite. Par exemple, 5 < 10 est vrai (renvoie 1), tandis que 10 < 5 est faux (renvoie 0).
> (Supérieur à) : Vérifie si la valeur de gauche est supérieure à la valeur de droite. Par exemple, 10 > 5 est vrai (renvoie 1), tandis que 5 > 10 est faux (renvoie 0).
== (Égal à) : Vérifie si deux valeurs sont exactement égales. Par exemple, 5 == 5 est vrai (renvoie 1), tandis que 5 == 6 est faux (renvoie 0).
!= (Différent de) : Vérifie si deux valeurs ne sont pas égales. Par exemple, 5!= 6 est vrai (renvoie 1), tandis que 5!= 5 est faux (renvoie 0).
Ces opérateurs renvoient 1 (vrai) ou 0 (faux). En C++, 1 représente vrai et 0 représente faux. Ces valeurs peuvent être utilisées dans des instructions conditionnelles.

Notes importantes :

Les opérateurs relationnels sont fondamentaux pour créer des instructions conditionnelles, permettant à votre programme de prendre des décisions en fonction de comparaisons.
Ils renvoient toujours une valeur booléenne, qui est représentée par un entier en C++ (1 pour vrai, 0 pour faux).
Ces opérateurs sont couramment utilisés dans les instructions if, les boucles while et les boucles for pour contrôler le flux d'exécution.

Combiner des conditions avec les opérateurs logiques ET (&&) et OU (||)

Dans cette étape, vous apprendrez à combiner plusieurs conditions à l'aide des opérateurs logiques ET (&&) et OU (||) en C++. Ces opérateurs vous aident à créer des instructions conditionnelles plus complexes en évaluant plusieurs conditions.

Ouvrez le WebIDE et créez un nouveau fichier appelé logical_operators.cpp dans le répertoire ~/project :

touch ~/project/logical_operators.cpp

Ajoutez le code suivant au fichier logical_operators.cpp :

#include <iostream>

int main() {
    int x = 10;
    int y = 5;
    int z = 15;

    // Opérateur logique ET (&&)
    std::cout << "Opérateur logique ET (&&):" << std::endl;

    // Les deux conditions doivent être vraies
    if (x > y && x < z) {
        std::cout << "x est supérieur à y ET inférieur à z" << std::endl;
    }

    if (x > 20 && y < 10) {
        std::cout << "Ceci ne sera pas affiché" << std::endl;
    }

    // Opérateur logique OU (||)
    std::cout << "\nOpérateur logique OU (||):" << std::endl;

    // Au moins une condition doit être vraie
    if (x > 20 || y < 10) {
        std::cout << "Au moins une condition est vraie" << std::endl;
    }

    if (x > 20 || z < 20) {
        std::cout << "Une autre condition vraie" << std::endl;
    }

    // Combinaison de ET et OU
    std::cout << "\nCombinaison de ET et OU:" << std::endl;

    if ((x > y && y < z) || x == 10) {
        std::cout << "La condition complexe est vraie" << std::endl;
    }

    return 0;
}

Compilez et exécutez le programme :

g++ logical_operators.cpp -o logical_operators
./logical_operators

Exemple de sortie :

Opérateur logique ET (&&):
x est supérieur à y ET inférieur à z

Opérateur logique OU (||):
Au moins une condition est vraie
Une autre condition vraie

Combinaison de ET et OU:
La condition complexe est vraie

Points clés sur les opérateurs logiques :

&& (ET) : Les deux conditions reliées par && doivent être vraies pour que l'expression entière soit vraie. Si l'une des conditions est fausse, l'expression entière est évaluée comme fausse. Dans le code, x > y && x < z est vrai car x > y (10 > 5) et x < z (10 < 15) sont toutes deux vraies.
|| (OU) : Au moins l'une des conditions reliées par || doit être vraie pour que l'expression entière soit vraie. Si toutes les conditions sont fausses, l'expression entière est évaluée comme fausse. Dans le code, x > 20 || y < 10 est vrai car y < 10 (5 < 10) est vrai.
Vous pouvez combiner plusieurs conditions à l'aide de parenthèses pour contrôler l'ordre d'évaluation. Cela rend vos expressions complexes plus faciles à lire et à comprendre.
Ces opérateurs sont extrêmement utiles pour créer une logique de prise de décision complexe au sein d'instructions conditionnelles.

Notes importantes :

Les opérateurs logiques sont souvent utilisés dans les instructions if, les boucles while et d'autres structures de contrôle de flux pour rendre vos programmes plus polyvalents.
Ils aident à créer des vérifications conditionnelles plus sophistiquées en vous permettant de vérifier plusieurs critères simultanément.
Évaluation en court-circuit :
- Pour &&, si la première condition est fausse, la deuxième condition n'est pas évaluée car l'expression entière sera fausse quelle que soit la deuxième condition. Cette optimisation peut améliorer les performances.
- Pour ||, si la première condition est vraie, la deuxième condition n'est pas évaluée car l'expression entière sera vraie.

Appliquer des opérations au niveau des bits pour la manipulation binaire

Dans cette étape, vous apprendrez à utiliser les opérateurs au niveau des bits en C++. Ces opérateurs agissent directement sur la représentation binaire des entiers, vous permettant de manipuler des bits individuels.

Ouvrez le WebIDE et créez un nouveau fichier appelé bitwise_operations.cpp dans le répertoire ~/project :

touch ~/project/bitwise_operations.cpp

Ajoutez le code suivant au fichier bitwise_operations.cpp :

#include <iostream>
#include <bitset>

int main() {
    // Représentation binaire des nombres
    unsigned int a = 5;   // 0101 en binaire
    unsigned int b = 3;   // 0011 en binaire

    // ET au niveau des bits (&)
    std::cout << "ET au niveau des bits (&):" << std::endl;
    std::cout << "a = " << std::bitset<4>(a) << " (5 en décimal)" << std::endl;
    std::cout << "b = " << std::bitset<4>(b) << " (3 en décimal)" << std::endl;
    unsigned int and_result = a & b;
    std::cout << "a & b = " << std::bitset<4>(and_result)
              << " (" << and_result << " en décimal)" << std::endl;

    // OU au niveau des bits (|)
    std::cout << "\nOU au niveau des bits (|):" << std::endl;
    unsigned int or_result = a | b;
    std::cout << "a | b = " << std::bitset<4>(or_result)
              << " (" << or_result << " en décimal)" << std::endl;

    // OU exclusif au niveau des bits (^)
    std::cout << "\nOU exclusif au niveau des bits (^):" << std::endl;
    unsigned int xor_result = a ^ b;
    std::cout << "a ^ b = " << std::bitset<4>(xor_result)
              << " (" << xor_result << " en décimal)" << std::endl;

    // NON au niveau des bits (~)
    std::cout << "\nNON au niveau des bits (~):" << std::endl;
    unsigned int not_result = ~a;
    std::cout << "~a = " << std::bitset<32>(not_result)
              << " (" << not_result << " en décimal)" << std::endl;

    // Décalage à gauche (<<)
    std::cout << "\nDécalage à gauche (<<):" << std::endl;
    unsigned int left_shift = a << 2;
    std::cout << "a << 2 = " << std::bitset<8>(left_shift)
              << " (" << left_shift << " en décimal)" << std::endl;

    // Décalage à droite (>>)
    std::cout << "\nDécalage à droite (>>):" << std::endl;
    unsigned int right_shift = a >> 1;
    std::cout << "a >> 1 = " << std::bitset<4>(right_shift)
              << " (" << right_shift << " en décimal)" << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ bitwise_operations.cpp -o bitwise_operations
./bitwise_operations

Exemple de sortie :

ET au niveau des bits (&):
a = 0101 (5 en décimal)
b = 0011 (3 en décimal)
a & b = 0001 (1 en décimal)

OU au niveau des bits (|):
a | b = 0111 (7 en décimal)

OU exclusif au niveau des bits (^):
a ^ b = 0110 (6 en décimal)

NON au niveau des bits (~):
~a = 11111111111111111111111111111010 (4294967290 en décimal)

Décalage à gauche (<<):
a << 2 = 00010100 (20 en décimal)

Décalage à droite (>>):
a >> 1 = 0010 (2 en décimal)

Points clés sur les opérateurs au niveau des bits :

& (ET) : Compare les bits correspondants de deux nombres. Si les deux bits sont à 1, le bit résultant est à 1 ; sinon, il est à 0. Dans l'exemple de code, 5 & 3 (binaire 0101 & 0011) donne 0001 qui est 1 en décimal.
| (OU) : Compare les bits correspondants de deux nombres. Si au moins l'un des bits est à 1, le bit résultant est à 1 ; sinon, il est à 0. Dans l'exemple, 5 | 3 (binaire 0101 | 0011) donne 0111 qui est 7 en décimal.
^ (OU exclusif) : Compare les bits correspondants de deux nombres. Si les bits sont différents, le bit résultant est à 1 ; sinon, il est à 0. Dans l'exemple, 5 ^ 3 (binaire 0101 ^ 0011) donne 0110 qui est 6 en décimal.
~ (NON) : Inverse tous les bits d'un nombre. Si un bit est à 1, il devient 0, et vice versa. Notez que la sortie ~a est 11111111111111111111111111111010 qui est la représentation binaire du résultat lorsque le nombre est traité comme un entier non signé sur 32 bits.
<< (Décalage à gauche) : Décale les bits d'un nombre vers la gauche d'un nombre spécifié de positions. Cela revient à multiplier le nombre par 2 pour chaque décalage. Dans l'exemple, 5 << 2 (binaire 0101 << 2) décale les bits pour devenir 010100 qui est 20 en décimal.
>> (Décalage à droite) : Décale les bits d'un nombre vers la droite d'un nombre spécifié de positions. Cela revient à diviser le nombre par 2 pour chaque décalage. Dans l'exemple, 5 >> 1 (binaire 0101 >> 1) décale les bits pour devenir 0010 qui est 2 en décimal.

Notes importantes :

Les opérations au niveau des bits agissent directement sur les représentations binaires des entiers, permettant une manipulation et une optimisation de bas niveau.
Elles sont couramment utilisées dans les systèmes embarqués, la programmation graphique et dans les scénarios où vous devez définir, effacer ou tester des bits individuels au sein d'une valeur.
Soyez prudent avec les entiers signés et non signés, car le comportement du décalage à droite peut varier (décalage arithmétique vs. décalage logique).
L'utilisation de std::bitset facilite la visualisation du fonctionnement de ces opérations au niveau des bits.

Utiliser les opérateurs d'affectation composée (+=, -=, *=)

Dans cette étape, vous apprendrez à utiliser les opérateurs d'affectation composée en C++. Ces opérateurs combinent une opération arithmétique avec une affectation, rendant votre code plus concis et plus lisible.

Ouvrez le WebIDE et créez un nouveau fichier appelé compound_operators.cpp dans le répertoire ~/project :

touch ~/project/compound_operators.cpp

Ajoutez le code suivant au fichier compound_operators.cpp :

#include <iostream>

int main() {
    // Initialiser les variables
    int x = 10;
    int y = 5;

    // Affectation additionnelle (+=)
    std::cout << "Affectation additionnelle (+=):" << std::endl;
    std::cout << "Valeur initiale de x: " << x << std::endl;
    x += 3;  // Équivalent à x = x + 3
    std::cout << "x += 3: " << x << std::endl;

    // Affectation soustractive (-=)
    std::cout << "\nAffectation soustractive (-=):" << std::endl;
    std::cout << "Valeur initiale de y: " << y << std::endl;
    y -= 2;  // Équivalent à y = y - 2
    std::cout << "y -= 2: " << y << std::endl;

    // Affectation multiplicative (*=)
    std::cout << "\nAffectation multiplicative (*=):" << std::endl;
    int z = 4;
    std::cout << "Valeur initiale de z: " << z << std::endl;
    z *= 3;  // Équivalent à z = z * 3
    std::cout << "z *= 3: " << z << std::endl;

    // Affectation divisionnelle (/=)
    std::cout << "\nAffectation divisionnelle (/=):" << std::endl;
    int a = 15;
    std::cout << "Valeur initiale de a: " << a << std::endl;
    a /= 3;  // Équivalent à a = a / 3
    std::cout << "a /= 3: " << a << std::endl;

    // Affectation modulo (%=)
    std::cout << "\nAffectation modulo (%=):" << std::endl;
    int b = 17;
    std::cout << "Valeur initiale de b: " << b << std::endl;
    b %= 5;  // Équivalent à b = b % 5
    std::cout << "b %= 5: " << b << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ compound_operators.cpp -o compound_operators
./compound_operators

Exemple de sortie :

Affectation additionnelle (+=):
Valeur initiale de x: 10
x += 3: 13

Affectation soustractive (-=):
Valeur initiale de y: 5
y -= 2: 3

Affectation multiplicative (*=):
Valeur initiale de z: 4
z *= 3: 12

Affectation divisionnelle (/=):
Valeur initiale de a: 15
a /= 3: 5

Affectation modulo (%=):
Valeur initiale de b: 17
b %= 5: 2

Points clés sur les opérateurs d'affectation composée :

+= (Ajouter et affecter) : Ajoute l'opérande de droite à l'opérande de gauche et affecte le résultat à l'opérande de gauche. x += 3 est équivalent à x = x + 3.
-= (Soustraire et affecter) : Soustrait l'opérande de droite de l'opérande de gauche et affecte le résultat à l'opérande de gauche. y -= 2 est équivalent à y = y - 2.
*= (Multiplier et affecter) : Multiplie l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche. z *= 3 est équivalent à z = z * 3.
/= (Diviser et affecter) : Divise l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche. a /= 3 est équivalent à a = a / 3.
%= (Calculer le modulo et affecter) : Calcule le modulo de l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche. b %= 5 est équivalent à b = b % 5.

Notes importantes :

Les opérateurs d'affectation composée rendent votre code plus concis et plus facile à lire en combinant une opération et une affectation en une seule étape.
Ils fonctionnent avec toutes les opérations arithmétiques de base (+, -, *, /, %).
Ils peuvent aider à réduire la quantité de saisie, à raccourcir le code et potentiellement à améliorer les performances.

Comprendre l'ordre des opérations avec plusieurs opérateurs

Dans cette étape, vous apprendrez l'ordre des opérations en C++, souvent mémorisé grâce à l'acronyme PEMDAS (Parentheses, Exponents, Multiplication and Division, Addition and Subtraction - Parenthèses, Exposants, Multiplication et Division, Addition et Soustraction). Comprendre cet ordre est crucial pour écrire des expressions mathématiques correctes.

Ouvrez le WebIDE et créez un nouveau fichier appelé order_of_operations.cpp dans le répertoire ~/project :

touch ~/project/order_of_operations.cpp

Ajoutez le code suivant au fichier order_of_operations.cpp :

#include <iostream>

int main() {
    // Démonstration de l'ordre de base des opérations
    int a = 10;
    int b = 5;
    int c = 3;

    // Multiplication avant addition
    std::cout << "Multiplication avant Addition:" << std::endl;
    int result1 = a + b * c;
    std::cout << "a + b * c = " << result1 << std::endl;

    // Les parenthèses changent l'ordre des opérations
    std::cout << "\nLes parenthèses changent l'ordre:" << std::endl;
    int result2 = (a + b) * c;
    std::cout << "(a + b) * c = " << result2 << std::endl;

    // Expression complexe avec plusieurs opérateurs
    std::cout << "\nExpression complexe:" << std::endl;
    int x = 4;
    int y = 2;
    int z = 3;

    int complex_result = x + y * z - (x / y);
    std::cout << "x + y * z - (x / y) = " << complex_result << std::endl;

    // Démonstration de la priorité avec incrémentation et multiplication
    std::cout << "\nIncrémentation et Multiplication:" << std::endl;
    int m = 3;
    int n = 2;
    int precedence_result = m++ * n;
    std::cout << "m++ * n = " << precedence_result << std::endl;
    std::cout << "m après l'opération = " << m << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ order_of_operations.cpp -o order_of_operations
./order_of_operations

Exemple de sortie :

Multiplication avant Addition:
a + b * c = 25

Les parenthèses changent l'ordre:
(a + b) * c = 45

Expression complexe:
x + y * z - (x / y) = 8

Incrémentation et Multiplication:
m++ * n = 6
m après l'opération = 4

Points clés sur l'ordre des opérations :

L'ordre des opérations, également connu sous le nom de priorité des opérateurs, détermine comment une expression est évaluée. C++ suit les règles de la mathématique à cet égard.
PEMDAS/BODMAS : C'est un mnémotechnique courant pour se souvenir de l'ordre :
- Parentheses / Brackets (Parenthèses) : Les expressions entre parenthèses sont évaluées en premier.
- Exponents / Orders (Exposants) : Les exposants ou les opérations de puissance (comme les racines carrées) sont évalués ensuite. Bien que C++ n'ait pas d'opérateur d'exposant intégré, cette étape fait référence à des opérations comme pow().
- MD Multiplication et Division : La multiplication et la division ont la même priorité et sont évaluées de gauche à droite.
- AS Addition et Soustraction : L'addition et la soustraction ont la même priorité et sont évaluées de gauche à droite.
Dans le code, int result1 = a + b * c; s'évalue en 10 + (5 * 3) qui est égal à 10 + 15 = 25 car la multiplication a une priorité supérieure à l'addition.
Les parenthèses peuvent remplacer l'ordre par défaut des opérations. Ainsi, l'expression int result2 = (a + b) * c; s'évalue en (10 + 5) * 3 qui est égal à 15 * 3 = 45, car l'expression entre les parenthèses est calculée en premier.
Les opérateurs d'incrémentation/décrémentation ont des règles de priorité spécifiques qui peuvent parfois être confuses. Dans le code, l'opérateur d'incrémentation postfixée m++ est utilisé. La valeur originale de m est utilisée d'abord dans la multiplication m * n, et seule ensuite la variable m est incrémentée.
Dans l'expression complexe x + y * z - (x / y), la multiplication et la division sont effectuées avant l'addition et la soustraction. Les parenthèses imposent que la division entière x / y soit effectuée en premier.
Utilisez toujours des parenthèses pour clarifier votre intention, surtout lorsque vous avez des expressions compliquées. Cela non seulement rend le code plus facile à lire, mais aussi assure que l'expression est évaluée exactement comme prévu.

Notes importantes :

PEMDAS/BODMAS aide à prédire comment les expressions seront évaluées, mais gardez à l'esprit que C++ n'a pas d'opérateur d'exposant intégré.
Lorsque vous avez des doutes, utilisez des parenthèses pour définir explicitement l'ordre. Cela peut rendre votre code plus clair et éviter les erreurs qui pourraient survenir en raison d'une mauvaise compréhension de la priorité des opérateurs.
Certains opérateurs ont la même priorité et sont évalués de gauche à droite. Par exemple, si vous avez a - b + c, la soustraction sera effectuée avant l'addition.
Soyez particulièrement prudent lorsque vous combinez plusieurs opérateurs dans une seule expression sans utiliser de parenthèses. Cela peut entraîner des bugs subtils si vous ne comprenez pas correctement la priorité des opérateurs.

S'entraîner avec l'opérateur conditionnel ternaire

Dans cette étape, vous apprendrez à utiliser l'opérateur conditionnel ternaire, une façon compacte d'écrire des instructions if-else simples sur une seule ligne. Cet opérateur offre une méthode concise pour prendre des décisions dans votre code.

Ouvrez le WebIDE et créez un nouveau fichier appelé ternary_operator.cpp dans le répertoire ~/project :

touch ~/project/ternary_operator.cpp

Ajoutez le code suivant au fichier ternary_operator.cpp :

#include <iostream>

int main() {
    // Syntaxe de base de l'opérateur ternaire
    // condition? valeur_si_vrai : valeur_si_faux

    // Comparaison simple
    int x = 10;
    int y = 5;

    // Déterminer le plus grand nombre
    int max_value = (x > y)? x : y;
    std::cout << "Valeur la plus grande : " << max_value << std::endl;

    // Vérifier si un nombre est pair ou impair
    int number = 7;
    std::string result = (number % 2 == 0)? "Pair" : "Impair";
    std::cout << number << " est " << result << std::endl;

    // Opérateur ternaire imbriqué
    int a = 15;
    std::string category = (a < 10)? "Petit"
                         : (a < 20)? "Moyen"
                         : "Grand";
    std::cout << "Catégorie : " << category << std::endl;

    // Opérateur ternaire avec des appels de fonction
    int abs_value = (x < 0)? -x : x;
    std::cout << "Valeur absolue de x : " << abs_value << std::endl;

    // Opérateur ternaire dans la sortie
    std::cout << "Est-ce que x est supérieur à y? "
              << ((x > y)? "Oui" : "Non") << std::endl;

    return 0;
}

Compilez et exécutez le programme :

g++ ternary_operator.cpp -o ternary_operator
./ternary_operator

Exemple de sortie :

Valeur la plus grande : 10
7 est Impair
Catégorie : Moyen
Valeur absolue de x : 10
Est-ce que x est supérieur à y? Oui

Points clés sur l'opérateur ternaire :

Syntaxe : condition? valeur_si_vrai : valeur_si_faux. C'est une façon abrégée d'écrire une instruction if-else sur une seule ligne.
La condition est évaluée. Si elle est vraie, l'expression retourne valeur_si_vrai ; sinon, elle retourne valeur_si_faux.
Dans le code, int max_value = (x > y)? x : y; détermine le plus grand nombre entre x et y. Si x est supérieur à y, il affectera x à max_value, sinon il affectera y. Comme x vaut 10 et y vaut 5, max_value prend la valeur 10.
L'expression std::string result = (number % 2 == 0)? "Pair" : "Impair"; utilise l'opérateur modulo % pour vérifier si le nombre est pair ou impair. Le résultat est soit "Pair" soit "Impair", selon le résultat de la vérification, et est affecté à la variable de type chaîne result.
Les opérateurs ternaires peuvent être imbriqués, mais cela peut rapidement rendre le code difficile à lire. Dans l'exemple, l'opérateur ternaire imbriqué affecte la chaîne "Petit", "Moyen" ou "Grand" à la variable category selon la valeur de l'entier a.
L'exemple avec int abs_value = (x < 0)? -x : x; montre comment l'opérateur ternaire peut être utilisé pour obtenir la valeur absolue de x. Si x est négatif, il prendra l'opposé de x, ce qui équivaut à le convertir en valeur absolue. Sinon, il retournera x tel quel.
Le dernier exemple montre comment le résultat d'un opérateur ternaire peut être affiché directement : std::cout << "Est-ce que x est supérieur à y? " << ((x > y)? "Oui" : "Non") << std::endl;

Notes importantes :

Utilisez-le avec modération pour maintenir la lisibilité du code. Un usage excessif des opérateurs ternaires, en particulier des opérateurs ternaires imbriqués, peut rendre le code difficile à suivre.
Il peut devenir difficile à lire s'il est trop complexe. Les décisions complexes devraient souvent être exprimées avec des blocs if-else complets.
Il est principalement utilisé pour des conditions simples et directes où l'une de deux valeurs doit être retournée ou affectée.

Résumé

Dans ce laboratoire, vous avez appris à effectuer des opérations mathématiques de base en C++, y compris l'addition, la soustraction, la multiplication, la division et le modulo. Vous avez également exploré l'utilisation des opérateurs d'incrémentation/décrémentation préfixés et postfixés, en comprenant les subtiles différences entre eux. De plus, vous avez appris à utiliser les opérateurs relationnels et logiques pour comparer et combiner des valeurs efficacement. En outre, vous avez pratiqué les opérations au niveau des bits pour la manipulation binaire et les opérateurs d'affectation composée pour simplifier et condenser les opérations arithmétiques avec affectation. Enfin, vous avez compris l'ordre des opérations avec plusieurs opérateurs et utilisé l'opérateur conditionnel ternaire pour écrire des instructions conditionnelles concises. Ces concepts fondamentaux sont essentiels pour développer des programmes C++ robustes et efficaces. En maîtrisant ces opérateurs de base, vous serez bien armé pour relever des défis de codage plus complexes.