Académique Documents
Professionnel Documents
Culture Documents
<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
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
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
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