Vous êtes sur la page 1sur 13

TP Langage C Atelier de Programmation 1 Annexe TP2

Les Opérateurs et les structures conditionnelles


I. Les expressions et les instructions
1. Expressions
Une expression est une combinaison de constantes, de variables, d'appels de fonctions et
d'opérateurs qui fournit une valeur d'un type donné.
Exemples :
i =0
printf(" Bonjour !\n")
a=(5*x+10*y)*2
2. Instructions
Une expression devient une instruction, si elle est suivie d'un point-virgule.
Exemples :
i=0;
printf(" Bonjour !\n");
a=(5*x+10*y)*2;
II. Les opérateurs
1. L'opérateur d'affectation

<identificateur> = <expression>;
2. Les opérateurs arithmétiques
Opérateur Sémantique
+ addition
- soustraction
* multiplication
/ division (entière et rationnelle!)
% modulo (reste d'une div. entière)
N.B :
 La notation / désigne à la fois la division entière et la division entre flottants. Si les deux
opérandes sont de type entier, l'opérateur / produira une division entière. Par contre, il
délivrera une valeur flottante dès que l'un des opérandes est un flottant.
Exemple :
float x;

1
TP Langage C Atelier de Programmation 1 Annexe TP2
x = 3 / 2; affecte à x la valeur 1.
x = 3 / 2.; affecte à x la valeur 1.5.
 L'opérateur % ne s'applique qu'à des opérandes de type entier.
3. Les opérateurs d'incrémentation et de décrémentation.
++, -- ce sont des opérateurs unaires permettant d'ajouter ou de retrancher 1 au contenu de
leur opérande. Les opérateurs d'incrémentation ++ et de décrémentation - - s'utilisent aussi
bien en suffixe (i++) qu'en préfixe (++i).
 Si l'opérateur d'incrémentation ou de décrémentation est placé avant l'opérande alors la
variable sera incrémentée ou décrémentée avant d'être utilisée.
Exemple :
#include <stdio.h>
void main(){
int a,b; /* Déclaration de variable a et b */
a=2; /* Initialisation de a et b */
b=3;
/* Affichage de a avec incrémentation avant l'utilisation */
printf("a = %d\n",++a);
/* Affichage de b avec décrémentation avant l'utilisation */
printf("b = %d",--b);
printf("a = %d\n",a); /* Affichage de a */
printf("b = %d",b); /* Affichage de b */
}
Le résultat sera le suivant :
a=3 b=2 a=3 b=2
Si l'opérateur d'incrémentation ou de décrémentation est placé après l'opérande alors la
variable sera incrémentée ou décrémentée après avoir été utilisée.
Exemple :
#include <stdio.h>
void main(){
int a,b; /* Déclaration de variables a et b */
a=2; /* Initialisation de a et b */
b=3;
/* Affichage de a avec incrémentation après l'utilisation */

2
TP Langage C Atelier de Programmation 1 Annexe TP2
printf("a = %d\n",a++);
/* Affichage de b avec décrémentation après l'utilisation */
printf("b = %d\n",b--);
printf("a = %d\n",a); /* Affichage de a */
printf("b = %d",b); /* Affichage de b */
}
4. Les opérateurs de comparaison
Ils permettent de comparer une variable par rapport à une autre variable ou une valeur ou une
expression. Le résultat ne peut être que VRAI (correspond à 1) ou FAUX(correspond à 0).

Opérateur Sémantique
> strictement supérieur
< strictement inférieur
>= supérieur ou égal
<= inférieur ou égal
== Egal
!= Différent

5. Les opérateurs logiques


Les résultats des opérateurs logiques sont du type int:
 la valeur 1 correspond à la valeur booléenne vrai
 la valeur 0 correspond à la valeur booléenne faux
Opérateur Sémantique
&& et logique (binaire)
|| ou logique(binaire)
! négation logique (unaire)

Exemple :
#include <stdio.h>
void main()
{/* Déclaration d'entiers */
int a,b,c;
int res;
3
TP Langage C Atelier de Programmation 1 Annexe TP2
a=2,b=3,c=5;
res= ( (a>3) && (c>5) ); printf("res = %d\n",res); res= ( (b>2) || (c<4) ); printf("res = %d\n",res);
res=!(a<b);
printf("res = %d\n",res);
}
Le résultat sera le suivant :
6. Les opérateurs combinés
Pour la plupart des expressions de la forme: id1 = (id1) op (id2), il existe une
formulation équivalente qui utilise un opérateur combiné: id1 op= id2.
Opérateur Sémantique Exemple
+= ajouter à A+=2  A=A+2
-= diminuer de A-=2  A=A-2
*= multiplier par A*=2  A=A*2
/= diviser par A/=2  A=A/2
%= modulo A%=2  A=A%2

7. L’opérateur conditionnel
C'est le seul opérateur ternaire.
Syntaxe : <expression1>? <expression2> : <expression3>
Cette expression vaut la valeur de <expression2> si <expression1> est vrai (entier, différent de
0), et <expression3> si <expression1> est faux.
Exemples :
y=100;
a = (y < 200) ? 3.14 : 25; =>a =3.14
8. L’opérateur séquentiel
Une expression peut être constituée d'une suite d'expressions séparées par des virgules. Cette
expression est alors évaluée de gauche à droite. Sa valeur finale sera la valeur de
l'expression de droite.
Syntaxe : <expression1>, <expression2>, ..., <expressionN> ;
Exemple :
#include <stdio.h>
void main(){
int a, b,c;

4
TP Langage C Atelier de Programmation 1 Annexe TP2
b = ((a = 3), (a + 2));
printf("b = %d \n",b);
c= (b++,b+12); /* incrémente b, effectue la somme b+12 puis affecte le résultat à c*/
printf("c = %d \n",c);
}
Le résultat sera le suivant :
b=5
c=18
9. L’opérateur d’adressage
L'opérateur d'adresse & appliqué à une variable retourne l'adresse mémoire de cette variable.

Syntaxe : &identificateur
10. L’opérateur de taille
L'opérateur sizeof renvoie la taille en octets de son opérande. L'opérande est soit une
expression soit une expression de type.
Exemple :sizeof (i); => 4
III. a priorité des opérateurs
1. Ordre de priorité
Dans ce tableau, les opérateurs sont classés par priorité décroissante (de la plus forte à la plus
faible). Les opérateurs les plus prioritaires seront évalués en premier
Priorité Opérateurs Associativité
1 () Gauche Droite
2 ! ++ -- Gauche  Droite
3 */% G D
4 */% G D
5 < <= > >= G D
6 = = != G D
7 && G D
8 || G D
9 ?: G D
10 += -= *= /= %== G D
11 , G D

5
TP Langage C Atelier de Programmation 1 Annexe TP2
2. Exemples
Exemple 1 :
Supposons pour l'instruction suivante: A=5, B=10, C=1
X = 2*A+3*B+4*C;
L'ordinateur évalue d'abord les multiplications:
2*A ==> 10 , 3*B ==> 30 , 4*C ==> 4
Ensuite, il fait l'addition des trois résultats obtenus:
10+30+4 ==> 44
A la fin, il affecte le résultat général à la ariable:X= 44
Exemple 2 :
Dans l'instruction: X = 2*(A+3)*B+4*C;
L'ordinateur évalue d'abord l'expression entre parenthèses, ensuite les
multiplications, ensuite l'addition et enfin l'affectation. (En reprenant les valeurs de l'exemple
ci-dessus, le résultat sera 164)

Exemple 3 :
Pour A=3 et B=4, l'expression A *= B += 5 sera évaluée comme suit: B + = 5 ==> 9 ensuite, A * = 9
==> 27
Pour A=1 et B=4, l'expression ! -- A == ++ ! B sera évaluée comme suit:
 A ==> ! 0 ==> 1 ensuite, ! B ==> ++ 0 ==> 1 ensuite, 1 == 1 ==> 1

IV. Les conversions de type


1. La conversion implicite ou automatique
Si un opérateur porte sur deux opérandes de types différents, il y a conversion du type le plus
faible dans le type le plus fort (nombre d'octets).
Voici les règles simples permettant de déterminer les conversions implicites utilisées en
C. Ces règles sont appliquées dans l'ordre cité :
 Si l'un des opérandes est double, convertir l'autre en double.
 Si l'un des opérandes est float, convertir l'autre en float.
 Convertir les opérandes de type char et short en int.
 Si l'un des opérandes est long, convertir l'autre en long.
Exemple 1 :
char a='A';
6
TP Langage C Atelier de Programmation 1 Annexe TP2
int b=32;
alors a+b sera un int contenant 97 car le char a été convertit en int.
2. La conversion explicite ou forcée
Lorsqu’une conversion paraît logique (int  float), le compilateur procède à une
conversion. Cependant il est tout à fait possible de procéder à la conversion d'un float en un int
par exemple. Cette conversion est dite une conversion forcée ou explicite. Une conversion forcée
peut être effectuée en utilisant un cast.
Syntaxe
(type souhaité) <expression>
Exemple :
#include <stdio.h>
void main()
{/* Déclaration des variables */
char car; int a,b,c,d; float g; a=4;
b=7;
c=0x41; /* Code Ascii de 'A' */
/* Conversion implicite de a et b en float */
g = (a + b) /100. ;
printf("g= %f\n",g);
/* Conversion explicite c en char */
car = (char) c +3;
/* c est de type entier et sera converti en char */
printf("car = %c\n",car);
d = (int)b/a ;
printf("d = %d\n",d);
}
Le résultat sera le suivant :
g = 0.110000
car = D
d=1
N.B : Dans l'affectation de g, a et b sont de type entier, on a ajouté un point (.) derrière 100
pour forcer le compilateur à effectuer l'évaluation en flottant.

7
TP Langage C Atelier de Programmation 1 Annexe TP2
V. Instruction conditionnelle
Instruction conditionnelle simple : if (sans else)
Syntaxe :

If (condition)
{
/* si la condition est vraie*/
<bloc d’instructions>
}

Si condition fournit une valeur non nulle (vrai), alors le <bloc d'instructions> est
exécuté.
La partie condition peut désigner une variable d'un type numérique ou une expression
fournissant un résultat numérique.
La partie <bloc d'instructions> peut désigner plusieurs instructions comprises entre
accolades ou une seule instruction.
Exemple :
#include <stdio.h>
void main()
{
int a,b; /* Saisie de a et de b */ printf("Donner les valeurs de a et de b "); scanf("%d%d",&a,&b);
if (a<b) /* Structure SI ALORS */
{
printf("a=%d est inferieur à b=%d\n",a,b);
printf("a+b=%d\n",a+b);
}
}
1. Instruction conditionnelle double : if … else
Syntaxe :

If (condition1)
{
/* si la condition est vraie*/
<bloc 1 d’instructions>
}
Else
{
/**si la condition est fausse/
<bloc 2 d’instructions
}

8
TP Langage C Atelier de Programmation 1 Annexe TP2

Exemple :
#include <stdio.h>
void main()
{
int a,b; /* Saisie de a et de b */ printf("Donnez les valeurs de a et de b : "); scanf("%d %d",&a,&b);
if (a>b) /* Structure SI ALORS SINON */
{
printf("a=%d est supérieur à b=%d\n",a,b);
printf("a-b=%d\n",a-b);
}
else
{
printf("a=%d est inferieur ou égal à b=%d\n",a,b);
printf("a+b=%d\n",a+b);
}}
On obtient le résultat suivant :
Donner les valeurs de a et de b : 6 40
a=6 est inferieur ou égal à b=40
a+b=46
N.B.
 Les instructions if-else peuvent être imbriquées l'une dans l'autre.
 L'opérateur ternaire ? peut être utilisée comme alternative à if – else :
Exemple :
La suite d'instructions :
if (A>B)
MAX=A;
else
MAX=B;
Peut être remplacée par : MAX = (A > B) ? A : B;
2. Instruction conditionnelle imbriquée : if … else if ……else
Il est possible d'enchaîner plusieurs tests successifs grâce à else if. Une alternative imbriquée
peut ainsi avoir un nombre quelconque de else if.

9
TP Langage C Atelier de Programmation 1 Annexe TP2
Syntaxe :
If (condition 1)
{
/* si la condition1 est vraie*/
<bloc 1 d’instructions>
}
Else if (condition 2)
{
/**si la condition1 est fausse et condition 2 est vraie/
<bloc 2 d’instructions
}
Else
{
/* si les deusx conditions sont fausses*/
<bloc 3 d’instructions>
}
Exemple :
#include <stdio.h>
void main()
{
int A,B;
printf("Entrez deux nombres entiers :");
scanf("%i %i", &A, &B);
if (A > B && A > 0)
printf("%i est different de zero et plus grand que %i\n", A, B);
else if (A < B)
printf("%i est plus petit que %i\n", A, B);
else
printf("%i est égal à %i\n", A, B);
}
On obtient le résultat suivant :
Entrez deux nombres entiers : 9 3
9 est différent de zéro et plus grand que 3

10
TP Langage C Atelier de Programmation 1 Annexe TP2

3. Instruction conditionnelle à choix multiple : switch


Syntaxe :
switch (sélecteur)
{
case constante_1 : [bloc d'instruction_1]
case constante_2 : [bloc d'instruction_2]
...
case constante_n : [bloc d'instruction_n]
default : [bloc d'instruction_par_defaut]
}

 Le sélecteur ne peut être qu'entier (char, int, long).

 Les constantes sont des expressions constantes qui doivent être un entier unique de
type scalaire (int ou char).

 S'il n'y a pas de valeur correspondante, on exécute les instructions du cas default.
Exemple :
#include <stdio.h>
void main(){
char choix; /* Affichage du menu */ printf("\t\t\t\t MENU\n"); printf("\t a --> ACTION 1\n");
printf("\t b --> ACTION 2\n");
printf("\t\t tapez une touche en minuscule "); choix=getchar();/* saisie de la touche */
switch(choix) /* Structure de choix switch*/
{
case 'a': {
printf("Execution de l'ACTION1:\n");

11
TP Langage C Atelier de Programmation 1 Annexe TP2
printf("%d\n",'a');
}
case 'b': {
printf("Execution de l'ACTION2\n");
printf("%d\n",'b');
}
default : printf("Mauvaise touche, pas d'ACTION\n");
}
}
On obtient le résultat suivant :
MENU
a --> ACTION 1
b --> ACTION 2
tapez une touche en minuscule b
Execution de l'ACTION2
98
Mauvaise touche, pas d'ACTION
On remarque que l'exécution a continué sur le cas suivant : default. Donc la solution est
d’ajouter break à la fin de chaque bloc d’instructions afin de passer à l’instruction qui suit le
switch. D’où le code devient :
#include <stdio.h>
void main()
{ char choix; /* Affichage du menu */ printf("\t\t\t\t MENU\n"); printf("\t a --> ACTION 1\n");
printf("\t b --> ACTION 2\n");
printf("\t\t tapez sur une touche en minuscule "); choix=getchar();/* saisie de la touche */
switch(choix) { /* Structure de choix switch*/ case 'a': {
printf("Execution de l'ACTION1:\n");
printf("%d\n",'a');
}break;
case 'b': { printf("Execution de l'ACTION2\n");
printf("%d\n",'b');
}break;
default : printf("Mauvaise touche, pas d'ACTION\n");

12
TP Langage C Atelier de Programmation 1 Annexe TP2
}}
On obtient le résultat suivant :
MENU a --> ACTION 1 b --> ACTION 2
tapez sur une touche en minuscule b
Execution de l'ACTION2
98
N.B : On peut spécifier plusieurs valeurs pour une même série d'instructions en jouant avec
l’absence ou la présence du break :
switch (a) { case 1 : case 2 :
case 3 : b = 100;
break;
case 4 : b = 200;
break;
default : b = 0;
}
Dans l'exemple précédent, les valeurs 1, 2 et 3 déclenchent le même traitement. La valeur 4
est traitée séparément.

13

Vous aimerez peut-être aussi