La lecture

Il s’agit du stockage en mémoire d’une donnée saisie par l’utilisateur. La première fonction
de lecture que nous allons étudier est la fonction scanf.
Synapsis : scanf(« format » , adresseVariable) ;
Exemple :
printf(« saisir un entier ») ; scanf(« %d »,&i) ;
printf(« saisir un caractère ») ; scanf(« %c »,&alpha) ;
printf(« saisir 2 nombres réels») ; scanf(« %f %f »,&x,&y) ;

Remarque : Dans l’exemple 3, l’utilisateur saisit 2 réels en respectant le mode d’affichage

des formats.
Exemple de saisie : 2 4
Si la lecture s’était présentée comme suit :
Scanf(« %f,%f »,&x,&y) ;
La saisie aurait été : 2,4

L’affectation étendue
Il s’agit de regrouper un opérateur et une affectation
Synapsis :
variable opérateur = variable ou expression ou valeur ;
Exemple :
int a = 5, b, c ;
1. a += 10 ; // signifie a = a + 10 donc a vaut 15
2. b = 30 ; b -= a ; // signifie b = b – a donc b vaut 15
3. c = b % 2 ; c *= a+b ; // signifie c = c * (a+b) donc c vaut 30

L’incrémentation et la décrémentation
Il s’agit respectivement de l’évolution d’une variable numérique par PAS de 1 et par PAS de
-1.
L’incrémentation :
Exemple :
int i = 5 ;

1
i = i + 1 ; //oubien i += 1 ;
//oubien opérateur d’incrémentation : i++ ;

Post incrémentation et pré incrémentation

Post incrémentation : i++ ;
Pré incrémentation : ++i ;
Utilisées sans affectation, la post et la pré incrémentation sont identiques : i++ ; < = = > ++i ;
Utilisation de la pré incrémentation dans une affectation
int a = 10, b ;
b = ++a ; // équivaut à ++a ; b = a ;
Cela signifie que l’incrémentation de a précède l’affectation (a vaut 11, b vaut 11).
Utilisation de la post incrémentation dans une affectation
int a = 10, b ;
b = a++ ; // équivaut à b = a ; a++ ;
Cela signifie que l’affectation précède l’incrémentation de a (a vaut 11, b vaut 10).
Exercice :
Donner les valeurs de i, j, k à la fin des instructions :
int i = 5 , j , k ;
//affectation étendue
k = j = ++i ;
i *= j + k ;
k = j++ * 5 ;
j-- ;
j -= k++ ;

La décrémentation

Elle garde les mêmes logiques que l’incrémentation.

Exemple 1 :

int a = 5, b ;

b = 10 ;

b -= --a ; // a = a – 1 = 4 ; b = 10 – 4 = 6

2
Exemple 2 :

int a = 5, b ;

b = 10 ;

b -= --a ; // a = 5 – 1 = 4 ; b = 10 – 4 = 6

a *= a-- ; // a = a * a ; a-- ; donc a = 4*4 = 16 ; a = 16 – 1 ; a = 15 ;

Les structures conditionnelles

Il s’agit de structures permettant de poser une ou plusieurs conditions avant d’exécuter une
ou plusieurs instructions. Les instructions de la structure sont dans un bloc c’est-à-dire entre
accolades {}. Si le bloc ne contient qu’une seule instruction, les accolades sont facultatives.

La structure de test : if
Syntaxe :

1) if (condition)
{ instruction ;}

2) if (condition)
instruction ;

3) if (condition)
{
instruction ;
instruction ;
}

4) if (condition1 && condition2)

{ instruction ;}

5) if ((condition1 && condition2) || condition3)

{ instruction ;}

6) if (condition)
{
Instruction1 ;
}
else
{
Instruction2 ;
}

7) if (condition1)
{

3
 Instruction1 ;
}
else if (condition2)
{
Instruction2 ;
}
else
{
Instruction3 ;
}

Plusieurs syntaxes sont possibles avec la structure conditionnelle if. Nous allons expliquer les
7 cas :

1) Ce test comprend une condition qui si elle est vraie entraine l’exécution de
l’instruction du bloc.
2) Ce présent cas est identique au premier à la seule différence que les accolades sont
volontairement omises, car facultatives (une seule instruction dans le bloc).
3) Ici on a plus d’une instruction, donc les accolades sont obligatoires.
4) Dans ce cas on a 2 conditions reliées par l’opérateur logique &&, les instructions du
bloc ne seront exécutées que si les 2 conditions sont vraies.
5) Ici on a plusieurs conditions reliées par plusieurs opérateurs logiques, il faut donc
appliquer les règles de la table de vérité en tenant compte des priorités entre
parenthèses ().
6) Dans ce cas, on a un bloc de test if, si la condition est vraie, on exécute la 1ère
instruction, sinon on exécute la 2eme instruction.
7) Dans celui-ci, on a des tests avec plusieurs alternatives.

Test imbriqué :
if (condition1)
{
instruction 1;
if (condition2)
{
instruction 2;
else
{
instruction 3;
}
}
else
{
instruction 4;

4
}

L’opérateur ternaire
La syntaxe suivante : if (condition) instruction1 ; else instruction2 ;

Ceci peut être écrite comme suit : condition ? instruction1 : instruction2 ;

Cette forme est utilisée pour une affectation conditionnelle.

Application :

1- Ecrire un programme qui affiche le plus petit entre 3 réels saisis par l’utilisateur.
2- Ecrire un programme qui dit si oui ou non une année saisit par l’utilisateur est
bissextile (divisible par 4 ou par 100 et 400).
3- Ecrire un programme qui résout l’équation Ax + B = 0
4- Ecrire un programme qui résoud dans R : Ax2 + Bx + C = 0

La structure conditionnelle switch case

Comme la structure sélective if, la structure switch case permet d’évaluer et d’exécuter des
instructions sous condition.

La particularité de la structure switch case est que l’on ne peut évaluer qu’une variable de
type entier ou caractère.

Elle peut donc remplacer la structure if, si la variable de la condition du if est unique et
atomique entière ou caractère.

Syntaxe :

switch(variable)
{
case val 1 : instructions1 ;
case val 2 : instructions2 ;
...... ..
..... ...
case val N : instructionsN ;
default : instructionsX;
}

Exemple 1:

Ecrire un programme qui demande à l’utilisateur de saisir un entier i, puis informe si

l’utilisateur a saisi 0, 1 ou un autre nombre différent de 0 et 1.

5
Solution :

int i ;
printf(« saisir un nombre ») ;
scanf(« %d »,&i) ;
switch(i){
case 0 : printf(« Vous avez saisi zéro ») ;break ;
case 1 : printf(« Vous avez saisi 1 ») ; break ;
default : printf(« Vous avez saisi un nombre différent de 0 et de 1 ») ;
}
Exemple 2 :

Donner la valeur finale de la variable i, selon les scénarios proposés :

puts(« Saisir une valeur : ) ;

scanf(« %d »,&i) ;
switch(i)
{
case 0 : i++ ;
case 1 : i *= 2 ; break ;
case 2 :
case 3 : i-- ; i += 5 ;
case 4 : break ;
case 5 : --i ;
default : i =-1 ;
}
printf(« La valeur finale est = %d »,i) ;

Solution :

Si i = 0, à la sortie i =
Si i = 1, à la sortie i =
Si i = 2, à la sortie i =
Si i = 3, à la sortie i =
Si i = 4, à la sortie i =
Si i = 5, à la sortie i =
Si i est différent des valeurs du case, à la sortie i =

6
 Les structures répétitives : Boucles
Elles permettent de répéter une à plusieurs instructions selon une ou plusieurs conditions.

 La structure for
Syntaxe : for (initialisation ; condition ; incrémentation)

Exemple : for (i = 0 ; i<n ; i++)

Si la boucle for n’est suivie que d’une seule instruction, les accolades sont facultatives, dans
tous les autres cas, les accolades délimitent obligatoirement le bloc d’instruction de la boucle.

Exemple 1:
int i ;
for (i = 0 ; i<5 ; i++)
printf(« %d »,i) ;

Exemple 2 :
int i ;
for (i = 0 ; i<5 ; i++)
{
printf(« %d »,i) ;
}

Exemple 3 :
int i ;
for (i = 0 ; i<5 ; i++)
{
printf(« Affichage ») ;
printf(« %d »,i) ;
}

On peut avoir plusieurs initialisations, plusieurs conditions et plusieurs incrémentations.

Exemple :
int i, j ;
for (i = 0, j = 5 ; i<10, j>0 ; i++, j--)
//instructions

 La structure while
Syntaxe : while (condition)
Cette structure teste si la condition est vraie (tant que condition vraie), alors la ou les
instructions du bloc sont exécutées. La règle des accolades s’applique aussi dans ce cas.

7
Exemple 1 :
int i ;
i=0;
while (i < 5)
printf(« %d »,i) ; //boucle infinie

Exemple 2 :
int i ;
i=0;
while (i < 5)
{
printf(« %d »,i) ;
i++ ;
}

Exemple 3 :
int i, j ;
i=0;
j=5;
while (i < 5 && j > 0)
{
i++ ;
j-- ;
}
Pour ce cas, nous avons 2 conditions.

 La structure do….while

Cette structure signifie : « Faire les instructions tant que la condition est vraie ».
Exemple :
int i = 0 ;
do
{
printf (« %d »,i) ;
i++ ;
}
while(i < 5) ;

La règle des accolades est aussi respectée dans ce cas.

Les instructions break et continue dans les structures répétitives

 L’instruction break dans une boucle marque l’arrêt des instructions et la fin de la
boucle.
Exemple :
int i ;
for (i = 0 ; i < 10 ; i++)
{

8
 if (i == 5) break ;
printf (« %d »,i) ;//dès que i = 5 il sort de la boucle
}
Dans cet exemple, les chiffres seront affichés de 0 à 4, si i vaut 5, l’instruction break force la
sortie.

 L’instruction continue dans une boucle marque l’arrêt des instructions et le

branchement sur la prochaine étape de la boucle.
Exemple :
int i ;
for (i = 0 ; i < 10 ; i++)
{
If (i % 2 != 0) continue ;
printf (« %d »,i) ;
If (i == 8) break ;
}

Dans cet exemple les chiffres 0, 2, 4, 6, 8 seront affichés. Si un nombre impair est rencontré,
l’instruction continue est exécutée ; ce qui a comme conséquence l’arrêt des instructions et
le passage à la valeur suivante de i.

break et continue peuvent aussi être rencontrés dans les boucles while et do…while.