programmation Procédurale

Mounira Hmayda
E-mail: [Link]@[Link]

1
 Plan
Introduction
Notion de base
Lecture et écriture de données
Types de base, opérateurs, expressions
La structure alternative
La structure répétitive
Les tableaux
Les chaînes de caractères
Les pointeurs
Les fonctions
Les fichiers séquentiels

2
Qu'est-ce qu'un bon programme?
Un Bon Programme ? ? :

Il doit résoudre le PROBLEME !

Efficacité Rapidité?

INSTANTANE ! DUREE DE VIE ?

- Lisible
- Structuré

3
 Objectifs
 Être capable de bien programmer

 Comprendre les différentes constructions de

la programmation en C

 Savoir programmer de manière modulaire

4
Qualités attendues d'un
programme

 Clarté
 Simplicité
 Efficacité
 Modularité
 Extensibilité

5
Intoduction
 Historique
 Le langage C est un langage de programmation développé à partir de 1972
dans les laboratoires Bell, dans le but d’écrire le système d’exploitation
Unix8. Sa paternité est attribuée à Dennis Ritchie et Ken Thompson, tandis
que Brian Kernighan est intervenu plus tard dans son évolution. L’un des
objectifs était de définir un langage portable.
 Portabilité : un langage de programmation est dit portable s’il peut être
compilé sur des machines et de systèmes différents, sans avoir besoin d’être
modifié.

6
 Intoduction
 Cependant, on ne peut pas vraiment considérer que cet objectif a été atteint,
car différentes versions du C sont apparues, qui ne sont pas complètement
compatibles entre elles. Les principales sont les suivantes :
 La version originale s’est stabilisée en 1978 et est appelée Kernighan &
Ritchie ou C K&R ;
 L’ANSI9 a défini sa propre version en 1989, basée sur le C K&R et appelée
C89 ou C ANSI ;
 L’ISO10 a défini sa version basée sur le C ANSI en 1999, qui est appelée
C99
Dans ce cours, nous nous concentrerons sur la version C89, qui est d’après
nous la plus répandue. Nous indiquerons occasionnellement les points traités
différemment dans les versions ultérieures.
On qualifie parfois le C de langage bas niveau car il est relativement proche de
l’assembleur. Toutefois, il est de plus haut niveau que ce dernier. Il s’agit du
langage le plus utilisé au monde11, ou du moins figure-t-il parmi les trois
premiers, en fonction du classement considéré.
7
Intoduction

 Sa syntaxe a fortement influencé d’autres langages de plus haut niveau

apparus plus tard, tels que C++, Java, C#, JavaScript ou PHP. Un grand
nombre de systèmes d’exploitation et de jeux vidéo sont encore
(complètement ou partiellement) écrits en C aujourd’hui.

8
Intoduction
 Le C est un langage compilé (par opposition aux langages interprétés). Cela
signifie qu’un programme C est d´écrit par un fichier texte, appelé fichier
source. Ce fichier n’´etant évidemment pas exécutable par le
microprocesseur, il faut le traduire en langage machine. Cette opération est
effectuée par un programme appelé compilateur. La compilation se
décompose en fait en 4 phases successives :
1. Le traitement par le préprocesseur : le fichier source est analysé par le
préprocesseur qui effectue des transformations purement textuelles
(remplacement de chaines de caractères, inclusion d’autres fichiers source .
. . ).
2. La compilation : la compilation proprement dite traduit le fichier généré
par le préprocesseur en assembleur, c’est-`a-dire en une suite d’instructions
du microprocesseur qui utilisent des mnémoniques rendant la lecture
possible.

9
Intoduction
3. L’assemblage : cette opération transforme le code assembleur en un
fichier binaire, c’est-`a-dire en instructions directement compréhensibles
par le processeur. Généralement, la compilation et l’assemblage se font
dans la foulée, sauf si l’on spécifie explicitement que l’on veut le code
assembleur. Le fichier produit par l’assemblage est appel´e fichier objet.
4. L’´edition de liens : un programme est souvent séparé en plusieurs
fichiers source, pour des raisons de clarté mais aussi parce qu’il fait
généralement appel à des librairies de fonctions standard déjà écrites. Une
fois chaque code source assemblé, il faut donc lier entre eux les différents
fichiers objets. L’´edition de liens produit alors un fichier dit exécutable.

10
 Compilateur C
C
fichier

La compilation

Code
assembleur
L’assemblage

Assembleur

Code
objet
Linker
Code
executable L’´edition de liens
11
Caractéristique de C
 Structuré
 Modulaire: peut être découpé en modules qui peuvent être compilés
séparément
 Universel: n'est pas orienté vers un domaine d'application particulier
 Typé: tout objet C doit être déclaré avant d’être utilisé
 Portable: sur n'importe quel système en possession d'un compilateur C

12
Notion de base
Programme typique en C

include
Main() toujours la
1ere fonction appelée
main()

fonction a() instructions

fonction b() instructions

instructions
13
 La pratique du C exige l'utilisation de bibliothèques de fonctions. Ces
bibliothèques sont disponibles sous forme précompilées (.lib). Afin de
pouvoir les utiliser, il faut inclure des fichiers en-tête (.h) dans nos
programmes. Ces fichiers contiennent les prototypes des fonctions
prédéfinies dans les bibliothèques et créent un lien entre les fonctions
précompilées et nos programmes.
Pour inclure les fichiers en-tête:
#include <fichier.h>

14
 TYPE de la valeur de retour

"main" : Cela signifie "principale",

ses instructions sont exécutées.

int main(void)
{
void main(void): La fonction main ne prend
/* corps du programme*/
begin aucun paramètre et ne retourne pas de valeur.
declaration des Cstes et Var ;
instruction1 ; int main(void): La fonction main retourne une
valeur entière à l'aide de l'instruction return (0
instruction2 ; si pas d’erreur).
….
int main(int argc, char *argv[]): On obtient
}
alors des programmes auxquels on peut
end adresser des arguments au moment où on lance
le programme.
Entre accolades "{" et "}" on
mettra la succession d'actions à
réaliser.(Bloc)

15
 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(int x);
int fonc2(int x); Déclaration des fonctions

void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions des
}
fonctions
int fonc2(int x) {
return (x * x);
}
16
 /* exemple de programme C :
- somme des nb de 1 à 10 et affichage de la
valeur*/ En C le programme principal
s'appelle toujours main
1
#include <stdio.h> 0
int main (void) 1 déclarations de variables de 2
{ type entier (cases mémoire
int somme; int i; 2 pouvant contenir un entier)
somme = 0; 3
for (i = 1; i <= 10; i++) instruction d'affectation de 3
{ valeur à la variable somme
somme = somme + i; 4 instructions exécutées
} en séquence
printf ("%d\n", somme); 5 4
somme = 0; l'instruction entre accolades
est exécutée pour les valeurs
} de i allant de 1 à 10
affiche à l'écran la valeur de 5
l'entier contenu dans somme

17 17
Types de base
4 types de base, les autres types seront dérivés de ceux-ci.

Type Exemples de valeur Codage en Peut être

Signification
mémoire
'a' 'A' 'z' 'Z' '\n' 'a' 'A'
1 octet signed,
char Caractère unique 'z' 'Z' '\n'
unsigned
Varie de –128 à 127
Short, long,
0 1 -1 4589 32000
int Nombre entier 2 ou 4 octets signed,
-231 à 231 +1
unsigned
Nombre réel 0.0 1.0 3.14 5.32
float 4 octets
simple -1.23

Nombre réel 0.0 1.0E–10 1.0 -

double 8 octets long
double précision 1.34567896

18
 Indenter = lisibilté #include <Lib1.h>
#include <Lib2.h>
Prenez l'habitude de respecter (au moins au début) les #define X 0;
règles :
int fonc1(int x);
- une accolade est seule sur sa ligne, float fonc2(char a);
- { est alignée sur le caractère de gauche de la ligne
précédente, int main(void)

- } est alignée avec l'accolade ouvrante correspondante, { /*main*/

instruction;
- après { , on commence à écrire deux caractères plus à
droite. instruction;
{
Fonctionnement : instruction;
{
- Taper et sauvegarder le programme,
instruction;
- Compiler le programme,
- Exécuter le programme. }
}
instruction;
} /* fin main*/ 19
 Préprocesseur
Le préprocesseur effectue un prétraitement du programme source avant qu'il soit compilé.
Ce préprocesseur exécute des instructions particulières appelées directives.
Ces directives sont identifiées par le caractère # en tête.

Inclusion de fichiers
#include <nom-de-fichier> /* répertoire standard */
#include "nom-de-fichier" /* répertoire courant */

La gestion des fichiers (stdio.h) /* Entrees-sorties standard */

Les fonctions mathématiques (math.h)
Taille des type entiers (limits.h)
Limites des type réels (float.h)
Traitement de chaînes de caractères (string.h)
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h)
Date et heure (time.h)

20
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{

printf(" 1AGC "); 1AGC

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */

21
 Notion de fonction
Par définition, un programme est une séquence d’instructions. À noter qu’en
langage C, chaque instruction se termine par un point-virgule (i.e. ;). Pour
améliorer la lisibilité du code source et sa gestion, il peut être pratique de
découper un programme en plusieurs parties relativement indépendantes.
Cela se fait grâce à la notion de bloc.
Bloc d’instructions : sous-séquence d’instructions, délimitée par des
accolades (i.e. { et }).

exemple : les instructions 2, 3 et 4 suivantes sont contenues dans un bloc

distinct
instruction 1;
{ instruction 2;
instruction 3;
instruction 4;
}
instruction 2;
22
 Il est aussi possible de définir un bloc à l’intérieur d’un autre bloc, et de
répéter cela récursivement. On peut alors parler de sous-bloc.
exemple : les instructions 3 et 4 sont maintenant dans un sous-bloc :

instruction 1;
{ instruction 2;
{ instruction 3;
instruction 4;
}
}
instruction 2;

Lorsqu’on a besoin d’utiliser plusieurs fois un bloc donné, on peut lui donner
un nom, afin de le désigner facilement. On obtient alors ce qu’on appelle une
fonction. Outre son nom, une fonction est aussi caractérisée par ses
entrées/sorties, i.e. les informations qu’elle reçoit pour effectuer son
traitement (entrées), et celles qu’elle renvoie à la fin de ce traitement (sorties).

23
Fonction : bloc d’instructions identifié par un nom, des entrées et des sorties.

Le nom de la fonction est aussi appelé identificateur. Le bloc d’instructions qui

décrit le traitement effectué par la fonction est appelé corps de la fonction,
alors que son identificateur et ses entrées-sorties sont décrits sous la forme
d’un en-tête.

Corps de fonction : bloc d’instructions implémentant le traitement réalisé

par la fonction.

En-tête de fonction : type de retour, identificateur (nom) et paramètres de la

fonction.

24
Le type de retour décrit quel genre d’information la fonction calcule : cela peut
être rien du tout (noté void) si la fonction ne renvoie rien, ou bien une valeur
entière, une valeur réelle, ou encore d’autres données. Les paramètres de la
fonction sont des variables que la fonction reçoit et sur lesquelles elle peut
travailler. Elles sont indiquées entre parenthèses (i.e. ( et )) et séparées par des
virgules. Pour chacune, on doit préciser son type (comme pour le type de retour)
et son identificateur (i.e. son nom). Le nombre de paramètres n’est pas limité, il
peut même ne pas y avoir de paramètre du tout, et on a alors des parenthèses
vides : ().
exemple: une fonction appelée ma_fonction, dont le type de retour est type_r et
qui possède trois paramètres p1 à p3 de types respectifs type_p1 à type_p3.

type_r ma_fonction(type_1 p1, type_2 p2, type_3 p3)

{ instruction_1;
instruction_2;
...
}

25
Commentaires et lisibilité
Comme dans la
Commentaire plupart
: un texte des langages
exprimé de programmation,
en langage il est possible
naturel (par exemple de ou en
en français
définir des
anglais) commentaires
et dont le but estend’expliquer
langage [Link] fonctionnement du programme à un
programmeur.

En C, un commentaire est délimité par /* et */, et peut occuper plusieurs lignes.

On peut aussi faire des commentaires d’une seule ligne en insérant // en début
de ligne.
exemples :
• Commentaire de plusieurs lignes :
/*
Bla bla bla bla
bla bla bla bla
bla bla
*/

26
 Commentaire d’une seule ligne :

// Bla bla bla bla bla bla

De manière générale, il est très important de mettre des commentaires

lorsqu’on programme, car cela améliore la lisibilité du code.
Lisibilité du code source : propriété d’un code source à être facilement
compris par une personne qui ne l’a pas forcément écrit.

27
Premier programme en C
Le classique "bonjour" (affiche bonjour à l'écran). Pour le faire, il faut:
- Inclure les bibliothèques
- Inclure le main
main()
{
déclaration des variables: aucune
instruction: écrire "bonjour"
}
La fonction prédéfinie qui permet d'écrire à l'écran est printf, elle est
contenue dans le fichier en-tête stdio.h; sa syntaxe est: printf("ce que l'on
veut écrire");
Voici donc notre premier programme:
#include <stdio.h>
main()
{
printf("bonjour\n"); /*toute instruction se termine par un point
virgule*/
} 28
 La fonction printf() :
Librairie : stdio.h. #include <stdio.h>

Description : Permet printf(): cette fonction est utilisée pour transférer du

texte, des valeurs de variables ou des résultats d'expression vers le fichier de
sortie standard stdout (par défaut l'écran)..

Syntaxe : printf("format", expr_1, expr_2);

Format de Expressions ou variables dont les

Représentation valeurs sont à représenter
"format" est une chaîne de caractère qui peut contenir:
- du texte
- des séquences d'échappement
- des spécificateurs de format (un spécificateur pour chaque expression)
Exemple :
printf("Qu'il est agreable d’utiliser printf "
"en\t C,\nlorsqu'on l'utilise \"proprement\".\n");

Résultat sur la sortie :

Qu'il est agreable d’utiliser printf en C,
lorsqu'on l'utilise "proprement". 29
Les caractères précédés de \ sont interprétés comme suit :
\\ : caractère \
\n : retour à la ligne
\t : tabulateur.
\" : caractère "
\r : retour chariot

30
La fonction scanf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int scanf(const char *format [argument, ...]);

Description : Lit à partir de stdin (clavier en principe), les différents

arguments en appliquant le format spécifié.
Exemple : scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
!
Format des paramètres passés en lecture et écriture.

"%c" : lecture d'un caractère.

"%d" ou "%i" : entier signé.
"%e" : réel avec un exposant.
"%f" : réel sans exposant.
"%g" : réel avec ou sans exposant suivant les besoins.
"%G" : identique à g sauf un E à la place de e.
"%o" : le nombre est écrit en base 8.
"%s" : chaîne de caractère.
"%u" : entier non signé.
"%x" ou "%X" : entier base 16 avec respect majuscule/minuscule.
31
 ! scanf
Exemples entrées résultats

char c1, c2, c3;

abc c1=a c2=<espace> c3=b
scanf(‘’%c %c %c‘’,&c1,&c2,&c3);

scanf(‘’ %c %c %c‘’,&c1,&c2,&c3); c1=a c2=b c3=c

char c;
int i;
float x;

scanf(‘’%2d %5f %c‘’,&i,&x,&c); 12 123.567 r i=12 x=123.5 c=6

32
 scanf(): fonction symétrique de printf().

scanf("format", adr_var_1, adr_var_2)

Format de Adresses des variables auxquelles les données

sont attribuées
lecture des données (adresse d'une variable= nom de la variable
précédé de &)

La fonction scanf reçoit ses données à partir du fichier standard stdin (le clavier)
- La chaîne de format détermine comment les données reçues doivent être interprétées
- Les données reçues correctement sont mémorisées aux adresses indiquées par
adr_var_1, adr_var_2, …

33
Ecriture d'un caractère

La fonction putchar(caractere) :

putchar transfère le caractère "caractere" vers le fichier de sortie standard stdout (l'écran),
les
arguments de putchar sont des caractères (type char, i.e. des nombres entiers entre 0 et
255).

Exemples: Affichage
putchar('x'); x
putchar('?'); ?
putchar(65); A (65 est le code ASCII de A)
putchar('\n'); retour à la ligne
putchar(A); valeur de la variable A si c'est un char

34
Lecture d'un caractère

La fonction getchar () :

Les valeurs retournées par getchar() sont des caractères. Le type du résultat de getchar est
int.
Exemple:
int C;
C=getchar();

getchar lit les données de la zone tampon stdin (clavier) et fournit les données
seulement après confirmation par "Enter".
Il existe dans la bibliothèque <conio.h> une fonction getch() qui fournit immédiatement
le prochain caractère entré au clavier (sans validation).

35
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Je te souhaite le bon"
L’utilisation de & est indispensable avec
"jour aux TP\nEt je t"
scanf (valeur lue et donc modifiée), pas avec
"e souhaite bon trav"
printf (valeur écrite et donc non modifiée).
"ail\n");
!
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\nAlors ton age est de %d ans!\n",age);

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
Quel est ton âge ? 18
Alors ton age est de 18 ans!
36
 Variables : déclarations
Syntaxe : Type identificateur1, identificateur2, …,…. ;

Exemple: char c1, c2, c3;

int i, j, var_ent;

Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A';
int i,j, k;
c = 'A'; int i=50,j, k;
i = 50; j=k=10;
j =10; = opérateur d’affectation
K=10;

Cette règle s'applique à tous : char, int, float ... 37

 Affichages et saisies
Librairie : stdio.h
Fonction Syntaxe Description

printf printf( const char *format [, arg [, Écriture formatée

arg]...]); : sortie standard

scanf scanf( const char *format [, arg [, Lecture formatée

arg]...]); 7 entrée standard

putchar putchar(int c); Écrire le caractère c

:

getchar getchar(); Lecture d'un caractère

getch(); <conio.h> 7
getch
puts *puts(char *s); Ecriture/Lecture d'une
*gets(char *s); chaîne de caractères,
gets terminée par \n
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne
d'adresse s.

sscanf sscanf(char *s, char *format, pointer Lit la chaîne d'adresse s.

...);

38
 LES DECLARATIONS DE CONSTANTES

1ere méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Le compilateur ne réserve pas

Exemple: #define PI 3.14159 de place en mémoire
void main()
{
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
....
}

Syntaxe : #define identificateur texte(valeur) !

Les identificateurs s'écrivent
#define TAILLE 100 traditionnellement en
#define MAXI (3 * TAILLE + 5) majuscules, mais ce n'est pas
#define nom_macro(identif_p1 , ... ) texte une obligation.
#define SOMME(X,Y) X+Y
#define MULTIP(A,B) (A)*(B)

39
 LES DECLARATIONS DE CONSTANTES

2eme méthode: déclaration d'une variable, dont la valeur sera constante pour tout le programme.

Exemple:
void main() Le compilateur réserve de la
{ place en mémoire (ici 4 octets).
const float PI = 3.14159;
const int JOURS = 5;
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
.... /*ERREUR !*/ On ne peut
JOURS = 3; changer la valeur d’une const.
.... !
}

40
 Identificateurs
Les identificateurs nomment les objets C (fonctions, variables ... )

C'est une suite de lettres ou de chiffres.

Le premier caractère est obligatoirement une lettre.
Le caractère _ (souligné) est considéré comme une lettre.
Reconnaissance suivant les 31 premiers caractères.

Le C distingue les minuscules des majuscules.

Exemples :
abc, Abc, ABC sont des identificateurs valides et tous différents.

Identificateurs valides :
xx y1 somme_5 _position
Noms surface fin_de_fichier VECTEUR

Identificateurs invalides :
3eme commence par un chiffre
x#y caractère non autorisé (#)
no-commande caractère non autorisé (-)
taux change caractère non autorisé (espace)
41
Un identificateur ne peut pas être un mot réservé du langage :

auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

RQ : Les mots réservés du langage C

doivent être écrits en minuscules.

42
 Les opérateurs arithmétiques
 Le C propose les opérateurs suivants :

+ addition
- soustraction
* multiplication
/ division
% modulo (reste de la division entière )

% ne peut être utilisé qu'avec des entiers

7/2 3

7.0/2
7/2.0
7.0/2.0
 3.5

43
 Utiliser des opérateurs arithmétiques

Le compilateur considère le type des opérandes

pour savoir comment effectuer les opérations
k= 5/4 = 1 void main(void)
{
int i = 5, j = 4, k;
h = 5.0/4.0 = 1.25 double f = 5.0, g = 4.0, h;

k = i / j;
h = f / g;
h = 5/4 = 1.0000 h = i / j;
}

44
Les opérateurs de comparaison
< plus petit Le type booléen
<= plus petit ou égal n'existe pas. Le
résultat d'une
> plus grand
expression logique
>= plus grand ou égal vaut 1 si elle est
! == égal vraie et 0 sinon.
!= différent
Réciproquement,
Les opérateurs logiques toute valeur non
nulle est considérée !
&& et comme vraie et la
|| ou (non exclusif) valeur nulle
comme fausse.
! non

45
 int i;
Exemple
float f;
char c;

i = 7; f = 5.5; c = 'w';

f>5 ====> vrai (1)

(i + f) <= 1 ====> faux (0)
c == 'w‘ ====> vrai (1)
c != 'w' ====> faux (0)
c >= 10*(i + f) ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1)
(i >= 6) || (c == 119) ====> vrai (1)

!expr1 est vrai si expr1 est faux et faux si expr1 est vrai ;
expr1&&expr2 est vrai si les deux expressions expr1 et expr2 sont vraies et
faux sinon. L'expression expr2 n'est évaluée que dans le cas où l'expression
expr1 est vraie ;

expr1 || expr2 = (1) si expr1=(1) ou expr2=(1) et faux sinon.

L'expression expr2 n'est évaluée que dans le cas où l'expression expr1
est fausse.
46
 Contractions d'opérateurs
 Il y a une famille d’opérateurs
+= -= *= /= %=
&= |= ^=
<<= >>=
 Pour chacun d’entre eux
expression1 op= expression2
est équivalent à:
(expression1) = (expression1) op (expression2)
a += 32; f /= 9.2; i *= j + 5;
a = a + 32; f = f / 9.2; i = i * (j + 5);
47
 Incrément et décrement

 C a deux opérateurs spéciaux pour incrémenter (ajouter 1)

et décrémenter (retirer 1) des variables entières
++ increment : i++ ou ++i est équivalent à i += 1 ou i = i + 1
-- decrement
 Ces opérateurs peuvent être préfixés (avant la variable) ou
postfixés (après)
int i = 5, j = 4;
“i” vaudra 6
i++;
“j” vaudra 3 --j;
++i;
“i” vaudra 7
48
 Préfixe et Postfixe

#include <stdio.h>

int main(void)
{
équivalent à:
int i, j = 5;
1. j++;
i = ++j;
2. i = j; !
printf("i=%d, j=%d\n", i, j);

j = 5; équivalent à:
i = j++; 1. i = j;
printf("i=%d, j=%d\n", i, j); 2. j++; !
return 0;
} i=6, j=6
i=5, j=6
49
 Les structures de contrôle en C

Alternative: if-else
Itérations: for, while, do-while
Choix Multiple: switch-case
Rupture de Contrôle: break, continue, return …
goto

50
Les structures de contrôle définissent l'ordre dans lequel les instructions sont effectuées.
Particularité des instructions de contrôle en C: les "conditions" peuvent être des expressions qui
fournissent un résultat numérique.
On rappelle que: valeur 0 -> FAUX et toute valeur ≠ 0 -> VRAI

Les décisions - if then else

Structure:

if(condition) si condition est vrai (≠0)

{ on exécute
bloc d'instructions 1; bloc d'instructions 1
}
else sinon
{ on exécute
bloc d'instructions 2; bloc d'instructions 2
}

51
 Remarques :
 S'il n'y a qu'une seule instruction, les accolades sont inutiles.
 "condition" peut être:
 une variable de type numérique
 une expression fournissant un résultat numérique
La partie else est facultative
 On peut imbriquer plusieurs if-else

Exemple 1 :
if(a>b) si a est plus grand que b
max=a; on affecte à max la valeur de a
else sinon
max=b; on affecte à max la valeur de b
Exemple 2 :
if(A-B) si A-B est vrai, si A-B est différent de 0, si A est différent de B
printf("A est différent de B\n");
else
printf("A est différent de B\n");
Remarque sur les exemples: Comme une seule instruction suit le if et le else,
les accolades ne sont pas obligatoires.
52
 if-else imbriqués
Il est possible d'imbriquer plusieurs structures if-else, cela permet de prendre des décisions
entre plusieurs alternatives. Mais, afin de gagner en lisibilité, on conseille d'adopter une
écriture tabulée.

Exemple :
if(N>0) if(A>B) MAX=A; else MAX=B;
Que fait ce programme? A quel if est rattaché le else?
La première remarque est qu’un else est toujours rattaché au dernier if qui ne possède
pas de else, dans cet exemple, le else est donc rattaché au if (A>B). La seconde est
qu'en adoptant une écriture lisible, c’est-à-dire tabulée, on verra tout de suite et
beaucoup plus facilement l'imbrication des if-else.

if(N>0) if(N>0)
if(A>B) {
MAX=A; if(A>B)
else MAX=A;
MAX=B; }
else MAX=B; 53
Exemple 1 :
int A,B ; Affichage:
printf("Entrer deux nombres entiers:\n") ; Entrer deux nombres entiers:
scanf("%d %d",&A,&B); 3
if(A>B) 12
printf("%d est plus grand que %d\n",A,B); 3 est plus petit que 12
else
if(A<B)
printf("%d est plus petit que %d\n",A,B);
else
printf("%d est égal à %d\n",A,B);
Exemple 2 :
printf("Continuer (O)ui / (N)on?\n") ; Affichage:
C=getchar(); Continuer (O)ui / (N)on?
if(C=='O') N
{… Au revoir…
}
else
if(C=='N')
printf("Au revoir…\n");
else
printf("Erreur d'entrée\n"); 54
if (expression booléenne vraie) if (a<b)
{ {
BLOC 1 D'INSTRUCTIONS min=a;

} }
else else
{ {
BLOC 2 D'INSTRUCTIONS min=b;

} }

* Tout ce qui est 0 ( ‘\0’ 0 0.0000 NULL ) est faux

* Tout ce qui est != de 0 ( 1 ‘0’ 0.0001 1.34 ) est vrai

if(32)
printf("ceci sera toujours affiche\n");
if(0)
printf("ceci ne sera jamais affiche\n");

55
Exemples :
if (i < 10) i++;
La variable i ne sera incrémentée que si elle a une valeur inférieure à 10.

if (i == 10) i++; == et pas =

La variable i ne sera incrémentée que si elle est égale à 10.

if (!recu) printf ("rien reçu\n");

Le message "rien reçu" est affiché si recu vaut zéro.

if ((!recu) && (i < 10)) i++;

i ne sera incrémentée que si recu vaut zéro et i<10.

Si plusieurs instructions, il faut les mettre entre accolades.

if ((!recu) && (i < 10) && (n!=0) ){

i++; if(delta != 0) = if(delta)
moy = som/n;
printf(" la valeur de i =%d et moy=%f\n", i,moy) ;
} if(delta == 0) = if(!delta)
else {
printf ("erreur \n");
i = i +2; // i +=2 ;
} !
56
 ! Attention!
 Ne pas confondre = = (opérateur logique d’égalité)
et = (opérateur d’affectation)
#include <stdio.h>

int main(void)
{
int i = 0;

if(i = 0) /* ici affectation */

printf("i = zero\n");
else
printf(“Quand i != de zero\n");

return 0;
}
Quand i != de zero

57
 Structure répétitive
Les itérations – for

structure: int i,j;

i=0
for(expr1;expr2;expr3) for (i = 0; i <3; i++) { i=1
{ printf ( "i = %d\n", i); i = 2
bloc d'instructions ; } j=5
} for(j = 5; j > 0; j- -) j=4
printf("j = %d\n", j); j = 3
j=2
j=1
Expr1: elle est utilisée pour initialiser les données de la boucle.
Expr2: est évaluée à chaque passage de la boucle, elle est utilisée pour savoir si la boucle
est répétée ou non (c'est une condition de répétition, et non d'arrêt).
Expr3: est évaluée à la fin de chaque passage de la boucle, elle est utilisée pour
réinitialiser les données de la boucle.

for(init;cond_repetition;compteur)
{
bloc d'instructions ;
}
58
Remarque :
Les parties expr1 et expr2 peuvent contenir plusieurs initialisations ou
réinitialisations, séparées par des virgules.

int n,tot;
for(tot=0, n=1;n<101;n++)
tot+=n;
printf("La somme des nombres de 1 à 100 est égale
à: %d\n",tot);

int i, j, k;

for(i = 0, j = 2, k = -1; (i < 20) &&(j==2); i++, k--)

59