Respecter l'ordre des opérations en C

Introduction

Dans ce laboratoire, vous apprendrez à respecter l'ordre des opérations en programmation C lors de l'exécution d'opérations arithmétiques de base. Vous commencerez par déclarer des variables et former une expression, puis vous explorerez comment utiliser les parenthèses pour contrôler l'ordre d'évaluation. Enfin, vous afficherez le résultat final pour observer l'impact de l'ordre des opérations. Ce laboratoire couvre les concepts fondamentaux des opérations arithmétiques de base en C, essentiels à la construction de programmes plus complexes.

Déclarer des variables et former une expression

Dans cette étape, vous apprendrez à déclarer des variables et à créer une expression arithmétique en C qui illustre l'ordre des opérations.

Tout d'abord, créez un nouveau fichier C dans le répertoire ~/project :

cd ~/project
nano order_of_operations.c

Maintenant, saisissez le code suivant :

#include <stdio.h>

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

    int result = a + b * c;

    printf("Résultat de a + b * c : %d\n", result);

    return 0;
}

Décomposons le code :

• Nous déclarons trois variables entières : a, b et c.
• Nous créons une expression a + b * c qui illustrera l'ordre des opérations par défaut en C.
• L'instruction printf affichera le résultat de ce calcul.

Compilez et exécutez le programme :

gcc order_of_operations.c -o order_of_operations
./order_of_operations

Exemple de sortie :

Résultat de a + b * c : 25

Dans cet exemple, la multiplication (b * c) est effectuée avant l'addition (a + ...) en raison de l'ordre des opérations standard en C. Le calcul est équivalent à a + (b * c), soit 10 + (5 * 3) = 10 + 15 = 25.

Utiliser les parenthèses pour contrôler l'ordre d'évaluation

Dans cette étape, vous apprendrez à utiliser les parenthèses pour modifier l'ordre des opérations dans les expressions arithmétiques C.

Ouvrez le fichier précédent pour modifier le code :

cd ~/project
nano order_of_operations.c

Remplacez le code précédent par le suivant :

#include <stdio.h>

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

    // Utilisation des parenthèses pour modifier l'ordre d'évaluation
    int result_avec_parentheses = a + (b * c);
    int result_sans_parentheses = a + b * c;

    printf("Résultat avec parenthèses (a + (b * c)) : %d\n", result_avec_parentheses);
    printf("Résultat sans parenthèses (a + b * c) : %d\n", result_sans_parentheses);

    return 0;
}

Compilez et exécutez le programme :

gcc order_of_operations.c -o order_of_operations
./order_of_operations

Exemple de sortie :

Résultat avec parenthèses (a + (b * c)) : 25
Résultat sans parenthèses (a + b * c) : 25

Dans cet exemple :

• a + (b * c) indique explicitement que la multiplication est effectuée en premier.
• Le résultat est identique à l'exemple précédent car l'ordre des opérations par défaut effectue déjà la multiplication avant l'addition.
• Les parenthèses permettent de clarifier l'ordre d'opération souhaité et peuvent modifier les calculs dans des expressions plus complexes.

Afficher le résultat final

Dans cette étape, vous approfondirez l'exemple précédent en créant une expression arithmétique plus complexe et en affichant des résultats détaillés pour illustrer l'ordre des opérations.

Ouvrez le fichier pour modifier le code :

cd ~/project
nano order_of_operations.c

Remplacez le code précédent par le suivant :

#include <stdio.h>

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

    // Expression complexe avec plusieurs opérations
    int result_default = a + b * c - d;
    int result_with_parentheses = a + (b * c - d);

    printf("Décomposition de l'expression originale :\n");
    printf("a = %d, b = %d, c = %d, d = %d\n", a, b, c, d);

    printf("\nÉvaluation par défaut (a + b * c - d) :\n");
    printf("Étape 1 : b * c = %d\n", b * c);
    printf("Étape 2 : a + (b * c) = %d\n", a + (b * c));
    printf("Étape 3 : (a + b * c) - d = %d\n", result_default);

    printf("\nÉvaluation avec parenthèses (a + (b * c - d)) :\n");
    printf("Étape 1 : b * c - d = %d\n", b * c - d);
    printf("Étape 2 : a + (b * c - d) = %d\n", result_with_parentheses);

    return 0;
}

Compilez et exécutez le programme :

gcc order_of_operations.c -o order_of_operations
./order_of_operations

Exemple de sortie :

Décomposition de l'expression originale :
a = 10, b = 5, c = 3, d = 2

Évaluation par défaut (a + b * c - d) :
Étape 1 : b * c = 15
Étape 2 : a + (b * c) = 25
Étape 3 : (a + b * c) - d = 23

Évaluation avec parenthèses (a + (b * c - d)) :
Étape 1 : b * c - d = 13
Étape 2 : a + (b * c - d) = 23

Points clés :

• Le code démontre comment les parenthèses peuvent modifier l'ordre des opérations.
• Nous montrons l'évaluation pas à pas des expressions.
• Les deux expressions aboutissent finalement à la même valeur (23).

Résumé

Dans ce laboratoire, vous avez appris à respecter l'ordre des opérations en programmation C. Tout d'abord, vous avez déclaré des variables et formé une expression arithmétique pour démontrer l'ordre des opérations par défaut, où la multiplication est effectuée avant l'addition. Ensuite, vous avez utilisé des parenthèses pour contrôler l'ordre d'évaluation et modifier le résultat de l'expression. En comprenant l'importance de l'ordre des opérations et en utilisant efficacement les parenthèses, vous pouvez écrire des programmes C plus précis et plus prévisibles.