Cours Programmation en Langage C : Opérateurs et Expressions

Ce cours s'adresse aux étudiants de première année en informatique et présente les opérateurs et expressions en langage C. Il couvre les opérateurs arithmétiques, relationnels, logiques, d’affectation, ainsi que les conversions de types et quelques fonctions mathématiques prédéfinies.

Les opérateurs arithmétiques en C

Le langage C dispose d’opérateurs classiques binaires : + (addition), - (soustraction), * (multiplication), / (division), ainsi que d’opérateurs unaires : - (opposé) et + (identité).

Exemple d’opérateurs unaires :

-a ; +a

Les opérandes peuvent être de types différents. Le compilateur applique une conversion implicite pour que l’opération soit valide. Par exemple, pour additionner un entier et un réel, l’entier est converti en réel, et le résultat est un réel.

Il existe aussi l’opérateur modulo % qui ne s’applique qu’aux entiers et fournit le reste de la division entière.

Exemple :

• 5 / 2 vaut 2 (division entière)
• 5.0 / 2.0 vaut 2.5 (division flottante)

Les opérateurs arithmétiques sont :

• + addition
• - soustraction
• * multiplication
• / division (entière ou flottante)
• % modulo (reste d’une division entière)

Il n’existe pas d’opérateur d’élévation à la puissance en C. Pour calculer x^3, il faut écrire x * x * x ou utiliser la fonction pow(x, 3) de la bibliothèque math.h.

#include <stdio.h>
#include <math.h>

void main() {
    int x = 3, y;
    y = pow(x, 4);
    printf("la puissance est %d", y);
}

Exécution : la puissance est 81

Exemple d’utilisation de la racine carrée :

#include <stdio.h>
#include <math.h>

void main() {
    unsigned int x;
    float y;
    printf("saisir un entier positif: ");
    scanf("%d", &x);
    y = sqrt(x);
    printf("la racine carrée de %d est %f", x, y);
}

Exécution : saisir un entier positif 4
La racine carrée de 4 est 2.000000

Les priorités relatives des opérateurs

Lorsque plusieurs opérateurs apparaissent dans une même expression, il faut connaître leur priorité :

• Priorité la plus forte : opérateurs unaires + (identité) et - (opposé)
• Ensuite : *, /, %
• Enfin : opérateurs binaires + et -

En cas de priorité identique, l’évaluation se fait de gauche à droite.

Les parenthèses permettent de modifier ces règles de priorité.

Les conversions implicites dans les expressions

Les opérateurs peuvent porter sur des types différents. Le compilateur effectue des conversions automatiques selon l’échelle suivante :

int → long → float → double → long double

Exemple :

#include <stdio.h>

void main() {
    int n = 2, p = 3;
    float x = 2.0, z;
    z = n * x + p;
    printf("%f", z);
}

Exécution : 7.000000

Explication : n est converti en float, puis le calcul est effectué en flottant.

Règles de conversion automatique :

• Pour deux entiers : les types char et short sont convertis en int. Ensuite, le type le plus large est choisi parmi int, unsigned int, long, unsigned long.
• Pour un entier et un rationnel : l’entier est converti en rationnel.
• Pour deux rationnels : le type le plus large est choisi parmi float, double, long double.
• Lors d’une affectation, le résultat est converti dans le type de la variable cible, ce qui peut entraîner une perte de précision.

Exemple :

char A = 3;
int B = 4;
float C = 4;
float D, E;
char F;

D = A / C;  // A converti en float, résultat 0.75 affecté à D
E = A / B;  // A converti en int, division entière 0, converti en float, E=0.0
F = A / C;  // résultat float 0.75 converti en char, F=0

Le cas du type char

Le type char est systématiquement converti en int lors des opérations.

Un caractère peut être considéré comme :

• Le caractère lui-même (exemple : 'a', 'z', '\n')
• Le code ASCII correspondant (exemple : 'A' correspond à 65 en ASCII)

Exemples :

#include <stdio.h>

void main() {
    char x = 'A';
    printf("%c\n", x);
}

Exécution : A

#include <stdio.h>

void main() {
    char x = 'A';
    printf("%d\n", x);
}

Exécution : 65

Le code %c peut aussi s’appliquer à un entier :

#include <stdio.h>

void main() {
    int x = 65;
    printf("%c\n", x);
}

Exécution : A

Exemple d’incrémentation sur un caractère :

#include <stdio.h>

void main() {
    char x = 'A';
    printf("le code ASCII de %c est %d\n", x, x);
    x = x + 1;
    printf("le code ASCII de %c est %d\n", x, x);
}

Exécution :
le code ASCII de A est 65
le code ASCII de B est 66

Quelques codes ASCII :

• '0' = 48
• '1' = 49
• 'A' = 65
• 'B' = 66
• 'a' = 97
• 'b' = 98

Les opérateurs relationnels

Les opérateurs relationnels permettent de comparer deux expressions :

• < (plus petit que)
• <= (plus petit ou égal)
• > (plus grand que)
• >= (plus grand ou égal)
• == (égal à)
• != (différent de)

Le résultat d’une comparaison est un entier :

• 0 si la comparaison est fausse
• 1 si la comparaison est vraie

Priorités :

• <, <=, >, >= ont la même priorité
• ==, != ont une priorité inférieure à la précédente

Exemple de comparaison de caractères :

#include <stdio.h>

void main() {
    char c1 = '1', c2 = 'a';
    if (c1 < c2) printf("inferieur");
    else printf("superieur");
}

Exécution : inferieur

L’ordre alphabétique est respecté pour les minuscules et majuscules. Les chiffres sont classés par ordre naturel.

Les opérateurs logiques

Le langage C propose trois opérateurs logiques :

• && : et logique (and)
• || : ou logique (or)
• ! : négation logique (not)

Ces opérateurs produisent un résultat entier (0 ou 1).

Exemples :

• (a < b) && (c < d) vaut 1 si les deux expressions sont vraies, 0 sinon
• (a < b) || (c < d) vaut 1 si l’une des expressions est vraie, 0 sinon
• !(a < b) vaut 1 si l’expression est fausse, 0 sinon

Priorités :

• ! a la priorité la plus forte
• && a une priorité supérieure à ||
• Les opérateurs logiques ont une priorité inférieure aux opérateurs arithmétiques et relationnels

Exemple :

a < b && c < d  // équivalent à (a < b) && (c < d)

Évaluation courte : si a < b est faux, l’expression entière est fausse sans évaluer la deuxième condition.

L’opérateur d’affectation ordinaire

L’opérateur d’affectation = attribue une valeur à une variable :

• i = 5; affecte la valeur 5 à i
• c = b + 3; est équivalent à c = (b + 3);

La priorité de l’affectation est faible par rapport aux opérateurs arithmétiques et relationnels.

Associativité : droite à gauche, ce qui permet d’écrire :

i = j = 5;

Une conversion automatique est effectuée si les types des opérandes sont différents.

Les opérateurs d’incrémentation et de décrémentation

Pour augmenter ou diminuer une variable entière de 1, on peut écrire :

• i = i + 1; ou i++; ou ++i;
• n = n - 1; ou n--; ou --n;

Exemple :

#include <stdio.h>

void main() {
    int n, i = 5;
    n = ++i - 5;
    printf("i: %d et n: %d", i, n);  // i:6 et n:1

    i = 5;
    n = i++ - 5;
    printf("\ni: %d et n: %d", i, n);  // i:6 et n:0
}

Les opérateurs d’affectation élargie

Ces opérateurs condensent certaines opérations :

• i++ remplace i = i + 1;
• i += k; remplace i = i + k;
• a *= b; remplace a = a * b;
• Les opérateurs disponibles sont : +=, -=, *=, /=, %=

Les conversions forcées (casting)

Lors d’une affectation, toutes les conversions sont acceptées par le compilateur, ce qui peut entraîner une perte de précision.

Exemple :

#include <stdio.h>

void main() {
    int n;
    float x = 2.3;
    n = x + 5.3;
    printf("%d", n);
}

Exécution : 7 (la partie décimale est tronquée)

Le programmeur peut forcer une conversion de type avec le casting :

int n = 5, p = 2;
(double)(n / p);  // conversion du résultat de n/p en double

Exemple :

#include <stdio.h>

void main() {
    int x = 2, y = 3;
    printf("la somme est %f", (float)(x + y));
}

Exécution : 5.000000

Autre exemple :

char A = 3;
int B = 4;
float C;

C = A / B;
printf("%f", C);  // Exécution : 0.000000

C = (float) A / B;
printf("%f", C);  // Exécution : 0.750000

Le contenu des variables ne change pas, seule la valeur utilisée dans le calcul est convertie.

Classes de priorité des opérateurs

• Priorité 1 (la plus forte) : () (parenthèses)
• Priorité 2 : !, ++, --
• Priorité 3 : *, /, %
• Priorité 4 : +, -
• Priorité 5 : <, <=, >, >=
• Priorité 6 : ==, !=
• Priorité 7 : &&
• Priorité 8 : ||
• Priorité 9 (la plus faible) : =, +=, -=, *=, /=, %=

L’opérateur conditionnel

Le test conditionnel classique :

if (a > b)
    max = a;
else
    max = b;

Peut s’écrire de manière plus compacte avec l’opérateur ternaire :

max = a > b ? a : b;

Quelques fonctions prédéfinies de la bibliothèque math.h

Fonction	Explication
exp(X)	fonction exponentielle e^X
log(X)	logarithme naturel (X > 0)
log10(X)	logarithme en base 10 (X > 0)
pow(X, Y)	X exposant Y (X > 0)
sqrt(X)	racine carrée de X
fabs(X)	valeur absolue de X
floor(X)	arrondi inférieur
ceil(X)	arrondi supérieur
fmod(X, Y)	reste rationnel de X/Y (même signe que X) pour X ≠ 0
sin(X), cos(X), tan(X)	sinus, cosinus, tangente de X
asin(X), acos(X), atan(X)	arcsin, arccos, arctan
sinh(X), cosh(X), tanh(X)	sinus, cosinus, tangente hyperboliques

Glossaire des termes clés

• Opérateur unaire : opérateur qui agit sur un seul opérande (exemple : -a, +a)
• Opérateur binaire : opérateur qui agit sur deux opérandes (exemple : a + b)
• Modulo (%) : opérateur qui donne le reste d’une division entière
• Conversion implicite : conversion automatique d’un type en un autre lors d’une opération
• Conversion forcée (casting) : conversion explicite d’un type en un autre par le programmeur
• Opérateurs relationnels : opérateurs de comparaison (<, <=, >, >=, ==, !=)
• Opérateurs logiques : opérateurs booléens (&&, ||, !)
• Opérateur d’affectation : opérateur qui assigne une valeur à une variable (=)
• Opérateurs d’incrémentation/décrémentation : opérateurs pour augmenter ou diminuer une variable de 1 (++ et --)
• Opérateurs d’affectation élargie : opérateurs combinant une opération et une affectation (+=, -=, *=, /=, %=)
• ASCII : code numérique représentant les caractères
• Bibliothèque math.h : bibliothèque standard C fournissant des fonctions mathématiques

Points clés à retenir

• Les opérateurs arithmétiques de base sont +, -, *, /, et % (modulo).
• Les priorités des opérateurs déterminent l’ordre d’évaluation dans une expression.
• Les conversions implicites permettent d’opérer sur des types différents, en convertissant vers le type le plus large.
• Le type char est converti automatiquement en int lors des opérations.
• Les opérateurs relationnels et logiques retournent 0 ou 1 selon la vérité de la condition.
• L’opérateur d’affectation a une priorité faible et une associativité droite à gauche.
• Les opérateurs d’incrémentation et de décrémentation simplifient l’écriture des opérations +1 et -1.
• Le casting permet de forcer une conversion de type pour éviter les erreurs ou pertes de précision.
• La bibliothèque math.h fournit des fonctions utiles pour les calculs mathématiques avancés.