Cours programmation en langage C - Chapitre 2 : Opérateurs et expressions
Cours programmation en langage C - Chapitre 2 : Opérateurs et expressions
Computer Science · course
Voir tous les documents en programmationTous les cours en programmation
Fiche de révisionFiche de cours
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce cours s’adresse aux étudiants de première année en informatique et couvre les opérateurs et expressions en langage C. Il présente les différents types d’opérateurs, leurs priorités, les conversions de types automatiques et forcées, ainsi que les fonctions mathématiques prédéfinies utiles en programmation C.
Le langage C dispose d’opérateurs classiques binaires, qui agissent sur deux opérandes : + (addition), - (soustraction), * (multiplication), / (division), ainsi que d’opérateurs unaires, qui agissent sur un seul opérande : - (opposé), + (identité).
Exemple d’opérateur unaire :
-a ; +a
Le modulo, noté %, est un opérateur binaire qui ne s’applique qu’aux entiers et retourne le reste de la division entière.
Exemple :
5 / 2 = 2 (division entière)
5.0 / 2.0 = 2.5 (division flottante)
5 % 2 = 1 (reste de la 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 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
Autre exemple avec 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
Lorsque plusieurs opérateurs apparaissent dans une même expression, il faut connaître leur ordre d’évaluation :
+ (identité) et - (opposé) ont la priorité la plus forte.*, / et %.+ et -.En cas de priorité identique, l’évaluation se fait de gauche à droite.
Les parenthèses permettent de modifier cet ordre.
Les opérateurs peuvent s’appliquer à des opérandes de types différents. Le compilateur effectue alors des conversions automatiques selon les règles suivantes :
char et short sont d’abord convertis en int. Puis, le type le plus large est choisi parmi int, unsigned int, long, unsigned 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
Le compilateur convertit n en float avant le calcul.
Exemple d’affectations :
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
E = A / B; // A converti en int, division entière 0, converti en float 0.0
F = A / C; // résultat float 0.75 converti en char, valeur 0
Le type char est systématiquement converti en int lors des opérations. Une variable de type caractère peut être vue comme :
Exemple d’affichage :
#include <stdio.h>
void main() {
char x = 'A';
printf("%c", x); // affiche A
printf("%d", x); // affiche 65
}
On peut aussi afficher un caractère à partir d’un entier :
#include <stdio.h>
void main() {
int x = 65;
printf("%c", x); // affiche A
}
Exemple d’incrémentation :
#include <stdio.h>
void main() {
char x = 'A';
printf("le code ASCII de %c est %d ", x, x);
x = x + 1;
printf("le code ASCII de %c est %d", x, x);
}
Exécution : le code ASCII de A est 65 le code ASCII de B est 66
Quelques codes ASCII usuels :
Ils permettent de comparer deux expressions :
< : strictement inférieur<= : inférieur ou égal> : strictement supérieur>= : supérieur ou égal== : égal à!= : différent deLe résultat est un entier : 0 si la comparaison est fausse, 1 si elle est vraie.
Priorités :
<, <=, >, >= ont la même priorité.==, != ont une priorité inférieure à celle des précédents.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, ainsi que l’ordre naturel des chiffres.
Trois opérateurs logiques existent :
&& : et logique (and)|| : ou logique (or)! : négation logique (not)Ils retournent un entier (0 ou 1).
Exemples :
(a < b) && (c < d) vaut 1 si les deux conditions sont vraies, 0 sinon.(a < b) || (c < d) vaut 1 si au moins une condition est vraie, 0 sinon.!(a < b) vaut 1 si la condition est fausse, 0 sinon.Priorités :
! a la priorité la plus forte.&& a une priorité plus forte que ||.Exemple :
a < b && c < d // équivalent à (a < b) && (c < d)
L’évaluation est courte-circuitée : si a < b est faux, c < d n’est pas évalué.
L’opérateur d’affectation simple est =. Il affecte la valeur de l’expression de droite à la variable de gauche.
Exemple :
i = 5; // i prend la valeur 5
c = b + 3; // c prend la valeur de b + 3
La priorité de = est faible par rapport aux opérateurs arithmétiques et relationnels.
L’opérateur d’affectation est associatif de droite à gauche :
i = j = 5; // équivalent à i = (j = 5);
Lorsqu’on affecte une valeur d’un type à une variable d’un autre type, une conversion automatique est effectuée.
Les opérateurs ++ et -- permettent d’incrémenter ou décrémenter une variable de 1 :
i = i + 1; peut s’écrire i++ ou ++in = n - 1; peut s’écrire n-- ou --nExemple :
#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("\n i: %d et n: %d", i, n); // i:6 et n:0
}
Ces opérateurs condensent certaines opérations :
i++ remplace i = i + 1;i += k; remplace i = i + k;a *= b; remplace a = a * b;+=, -=, *=, /=, %=.Le programmeur peut forcer la conversion d’une expression dans un type donné en utilisant le casting.
Exemple :
int n = 5, p = 2;
(double)(n / p);
Cette expression calcule n / p en entier (donc 2), puis convertit le résultat en double (2.0).
Exemple avec affichage :
#include <stdio.h>
void main() {
int x = 2, y = 3;
printf("la somme est %f", (float)(x + y));
}
Exécution : la somme est 5.000000
Exemple sans casting :
char A = 3;
int B = 4;
float C;
C = A / B;
printf("%f", C);
Exécution : 0.000000 (division entière 3/4 = 0)
Avec casting :
C = (float) A / B;
printf("%f", C);
Exécution : 0.750000 (A converti en float avant division)
Le contenu des variables ne change pas, seule la valeur utilisée dans le calcul est convertie.
| Priorité | Opérateurs |
|---|---|
| 1 (la plus forte) | ( ) |
| 2 | ! ++ -- |
| 3 | * / % |
| 4 | + - |
| 5 | < <= > >= |
| 6 | == != |
| 7 | && |
| 8 | || |
| 9 (la plus faible) | = += -= *= /= %= |
L’opérateur conditionnel ternaire permet d’écrire une instruction conditionnelle simple :
if (a > b) max = a; else max = b;
peut s’écrire :
max = a > b ? a : b;
| 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 différent de 0 |
| sin(X), cos(X), tan(X) | sinus, cosinus, tangente de X |
| asin(X), acos(X), atan(X) | arcsinus, arccosinus, arctangente de X |
| sinh(X), cosh(X), tanh(X) | sinus, cosinus, tangente hyperboliques de X |
-a.a + b.<, <=, >, >=, ==, !=).&& (et), || (ou), ! (non).= qui assigne une valeur à une variable.++ et -- pour augmenter ou diminuer une variable de 1.+=, *=.math.h pour les calculs avancés (exponentielle, racine carrée, trigonométrie, etc.).+, -, *, /, %, avec des règles de priorité strictes.char est converti en int dans les expressions, et correspond à un code ASCII.math.h offre de nombreuses fonctions utiles pour les calculs mathématiques avancés.