Vous êtes sur la page 1sur 174

Département d’Informatique

Module I132 :
Algorithmique et programmation 2

Pr. S. ANTER
antersamir@gmail.com

Parcours MIP (S3)


(2017/2018)

12 septembre 2018 1
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Introduction

2
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Introduction
Application informatique

La processus de résolution informatique d’un problème peut se sché-


matiser comme suit :

Exemple :

3
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Compilation

La compilation a pour objectif de convertir un fichier texte (code


source) en un fichier binaire (.exe par exemple) que l’on peut exécuter
comme n’importe quel autre programme. Cette opération se déroule
en 4 phases successives :
Préprocesseur : Appliquer chaque instruction passée au
préprocesseur (les lignes qui commencent par un #).
Compilation : Traduction du fichier engendré en langage
assembleur.
Assemblage : Transformer le code assembleur en un fichier
binaire compréhensibles par le processeur ⇒ fichier objet (.o)
Edition de liens : Lier entre les différents fichiers objets
constituants le programme ⇒ Fichier exécutable(.exe)

4
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Compilation

5
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Premier programme en langage C

Exemple : Le programme qui calcule le volume d’un cylindre.

Exemple :

6
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Outils de base d’un programme
en langage c

7
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Premier programme en langage C

Exemple : Le programme qui calcule le volume d’un cylindre.


Algorithme Langage C
Debut
# include < stdio .h >
var :
main () {
h , r , v : r é el
float h , r , v ;
const :
const float pi = 3.14;
pi = 3.14
scanf ( " % f " ,& h ) ;
lire ( h )
scanf ( " % f " ,& r ) ;
lire ( r )
v = h * pi * r * r ;
v <- h * pi * r * r
printf ( " % f " ,v ) ;
ecrire ( v )
}
Fin

8
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Structure d’un programme en langage C

 Structure générale d’un programme en langage C


Directives a destination du preprocesseur
main () {
Declaration des variables et constantes
Corps du programme
Actions
}
 Directives à destination du préprocesseur
# include < stdio .h >
# define N 20
⇒ Prises en compte avant la compilation du programme.
⇒ Doivent être écrites une par ligne.
⇒ Doivent obligatoirement commencer en début de ligne.

9
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Structure d’un programme en langage C
Directives à destination du préprocesseur

 La fonction main
main () {
Programme principal
}
⇒ Les instructions situées entre des accolades forment un «bloc».
⇒ Un bloc peut lui-même contenir d’autres blocs.
⇒ Le bloc délimité par les accolades de la fonction main (dont le
nom est imposé) constitue le programme principal.

10
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Structure d’un programme en langage C
Directives à destination du préprocesseur

 Déclaration des variables et constantes


float h , r , v ;
const float pi =3.14;
⇒ La première ligne précise que les variables nommées h, r et v
sont de type float, c’est-â-dire qu’elles sont destinées à contenir des
nombres réels.
⇒ La deuxième ligne précise que pi est constante initialisée par la
valeur 3.14.
⇒ Les déclarations des variables et constantes sont obligatoires et
doivent être regroupées au début du programme (au début de la
fonction main)

11
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Variables et constantes

⇒ Un objet peut être :


Variable : Peut changer de valeur au cours de l’éxécution du
programme.
Constant : Sa valeur ne peut pas être changé au cours de
l’éxécution du. Les objets constants sont précédés par le mot
clé const.
⇒ Un objet est défini par :
Un identificateur : C’est un nom symbolique que l’on attribue
à l’objet.
Un type : Le type d’un objet représente la nature de ce
dernier. Autrement-dit, l’ensemble de valeurs qui peuvent être
prises par cet objet.

12
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
L’identificateur d’un objet

L’identificateur d’un objet est représenté par une suite de caractères


et ne doit contenir que :
Lettres non accentuées (a ... z et A ... Z)
Chiffres (0 ... 9) mais à partir de la deuxième position.
Caractère soulignement ‘_’
Autrement-dit :
Il ne doit pas commencer par un chiffre.
Il ne doit pas contenir ni espace ni caractères spéciaux (#,
&,-, ...)
Il ne doit pas contenir de lettres accentuées.
Il ne doit pas être un mot-clé réservé par le langage (float,
break, do, for, double, char, else, if, const, int, return, etc).

13
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Le type d’un objet

Les types d’objets peuvent être divisés en trois grandes familles :


Les booléens : correspondent à un ensemble de deux états
logiques vrai, faux représentées en Langage C, repectivement,
par les valeurs ’1’ et ’0’.
Les numériques : correspondent à l’ensemble des entiers
positifs et négatifs (Z) et l’ensemble des nombres réels (R).
Les caractères : correspondent à l’ensemble des caractères
(lettres, chiffres, espace, caractères de ponctuation, caractères
spéciaux. . . ) écrits entre apostrophes (ou quotes).
Les chaînes de caractères : correspondent à des suites de
caractères écrites entre guillemets (Ex. "Bonjour ", "Je suis de
Casablanca").

14
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Les caractères

Remarque :
On distingue entre deux types de caractères :
Les caractères imprimables se notent toujours entre
apostrophes (ex. ’a’, ’A’, ’+’, ’$’, ’é’, «\\», «\’», «\"»)
Les caractères non-imprimables possèdent toujours
une notation conventionnelle utilisant le caractère antislash «\»
Notation en C Signification
\a Cloche ou bip
\b Retour arrière (Backspace)
\f Saut de page
\n Saut de ligne
\r Retour chariot
\t Tabulation horizontale
\v Tabulation verticale
15
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Les caractères (le code ASCII)

Comme la mémoire de l’ordinateur conserve toutes les données sous


forme numérique, chaque caractère possède son équivalent en code
numérique : c’est le code ASCII (American Standard Code for Infor-
mation Interchange)
Le code ASCII de base représentait les caractères sur 7 bits (128
caractères possibles) qui a été étendu sur 8 bits pour représenter
plus de caractères (256 caractères possibles).
Les codes 0 à 31 ne sont des caractères non imprimables.
Les codes de 48 à 57 représentent les caractères numériques.
Les codes 65 à 90 représentent les majuscules.
Les codes 97 à 122 représentent les minuscules.

16
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Les caractères (le code ASCII)

0 1 2 3 4 5 6 7 8 9
0
1
2
3 ! " # $ % & ’
4 ( ) * + , - . / 0 1
5 2 3 4 5 6 7 8 9 : ;
6 < = > ? @ A B C D E
7 F G H I J K L M N O
8 P Q R S T U V W X Y
9 Z a b c
10 d e f g h i j k l m
11 n o p q r s t u v w
12 x y z { | }
17
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Les différents types en langage C

Syntaxe Type Taille (octets)


void type générique
char caractère 1
short (short int) entier court signé 2
unsigned short entier court non signé 2
int entier signé 2 ou 4 (∗)

unsigned (unsigned int) entier non signé 2 ou 4 (∗)

long (long int) entier signé long 4


unsigned long entier non signé long 4
float réel 4
double réel double 8
long double réel long double 16
(∗)Le nombres d’octets de chaque type dépend du compilateur.
Remarque : La fonction sizeof retourne la taille en octets d’un type
donné (ex. sizeof(char) vaut 1 ).
18
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Types de base
Variables et constantes

Exemples :

Algorithme Langage C
var
n : entier int n ;
x : r é el float x ;
a : caract è re char a ;
const
pi =3.14 const float pi =3.14;

Remarque :
Noter que toutes les instructions en C doivent se terminer par un
point-virgule ’ ;’.

19
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Opérateurs de calcul

Algorithmique Langage C Désignation


+ + Addition
- - Soustraction
* * Multiplication
/ / Division
∧ pow (1) Elévation de puissance
DIV (2) Division entière
MOD % Reste de la division entière
(1) . pow est une fonction définie dans la bibliothèque math.h qu’elle

faut charger (#include<math.h>) avant de pouvoir l’utiliser.


(2) . En langage C,le quotient de deux entiers fournit un entier. Ainsi,

5/2 vaut 2 ; en revanche, le quotient de deux flottants est bien un


flottant (5.0/2.0 vaut bien 2.5).

20
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Opérateurs relationnels

Algorithmique Langage C Désignation


= == Egal à
<> != Différent de
< < Inférieur à
> > Supérieur à
<= <= Inférieur ou égal à
>= >= Supérieur ou égal à
Remarque :
Il est également possible d’appliquer ces opérateurs sur des carac-
tères, Ils comparent en faite leurs codes ASCII.

Exemple :
L’expression ’A’ < ’B’ est vrai car le code ASCII de ’A’ (65) est
inférieur au code ASCII de ’B’ (66). 21
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Opérateurs logiques

Algorithmique Langage C Désignation


ET && ET logique
OU || OU logique
NON ! NON logique

Remarque :
Il est important de constater que C ne disposant pas de type logique,
il représente vrai par 1 et faux par 0. C’est ainsi que ces opérateurs
logiques produisent un résultat numérique (de type int).

22
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Opérateurs logiques

Opérande 1 Operateur Opérande 2 Résultat


0 && 0 0
0 && non nul 0
non nul && 0 0
non nul && non nul 1
0 || 0 0
0 || non nul 1
non nul || 0 1
non nul || non nul 1
! 0 1
! non nul 0
Exemple :
3 && 0 vaut 0 , 6 && 5 vaut 1 , 7 || 0 vaut 1 ,
5 <6 && 9!=8 vaut 1 , (7 || 0) +1 vaut 2 ,
(4 && 0) *2 vaut 0
23
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les conversions d’ajustement de type

 Les opérateurs arithmétiques ne sont définis que lorsque leurs


deux opérandes sont de même type.
 Dans le cas des «expressions mixtes» où peut intervenir des opé-
randes de types différents comme dans n ∗ p + x où n est de type
int, p de type long tandis que x est de type float. Pour évaluer cette
opération le compilateur :
Commence par les opérations prioritaires en tenant compte des
règles de priorité.
Met en place des instructions de conversion : char 7−→ short
7−→ int 7−→ long 7−→ float 7−→ double 7−→ long double

24
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les conversions d’ajustement de type

Exemples :

Soient les déclarations suivantes :


char c1 , c2 ;
int n ;

25
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
L’affectation ordinaire

L’opération d’affectation permet d’assigner la valeur d’une expres-


sion à un objet variable. Elle est représentée en algorithmique par
’←−’ et en langage C par l’opérateur ’=’.

Syntaxe :
Algorithme Langage c
variable <-
variable = expression
expression

Exemples :
Algorithme Langage c
x <- 5 x = 5
y <- x + 3 y = x + 3
z <- x + y z = x + y

26
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
L’affectation ordinaire

Attention ! !
Il n’est pas possible de faire apparaitre une expression comme pre-
mier opérande de l’opérateur d’affectation. Ainsi, l’expression sui-
vante n’aurait aucun sens.
x + 3 = y
Remarque :
L’opérateur d’affectation possède une associativité de droite à gauche.
Ainsi, une expression telle que
x = y = 5
commence par l’évaluation de l’expression y = 5 avant d’en affecter
la valeur (5) à la variable x. Ainsi, la valeur finale de cette expression
est celle de y après affectation, c’est-à-dire 5.

27
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les conversions forcées par une affectation

Soient les déclarations suivantes :


float x =2.5;
int n ;
L’affectation
n = x + 5.3
entrainera tout d’abord l’évaluation de l’expression située à droite
(x + 5.3), ce qui fournira une valeur de type float ; cette dernière
sera ensuite convertie en int pour pouvoir être affectée à n.
Remarque : D’une manière générale, lors d’une affectation, toutes
les conversions (entre types numériques) sont acceptées par le com-
pilateur mais le résultat peut être insatisfaisant.
Exemple : La conversion float 7−→ int fournira un résultat insatis-
faisant (n prendra la valeur 7 et non 7.8)
28
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les opérateurs d’incrémentation et de décrémentation binaires

Operateur Exp Equivalence Effet


+= x += y x=x+y Affecte à x la valeur de x+y
-= x -= y x=x-y Affecte à x la valeur de x-y
*= x *= y x=x*y Affecte à x la valeur de x*y
/= x /= y x=x/y Affecte à x la valeur de x/y
%= x %= y x=x%y Affecte à x la valeur de x%y

29
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les opérateurs d’incrémentation et de décrémentation unaires

Operateur Exp Equivalence Effet


++ x++ x=x+1 Incrémente de 1 la valeur de x
–– x– – x=x-1 Décrémente de 1 la valeur de x
Remarque :
Les opérateurs ++ et – – peuvent être placées à gauche ou à droite
de la variable.

On dit que ++ (éventuellement – –) est :


Un opérateur de postincrémentation lorsqu’il est placé à
gauche de la variable sur laquelle il porte.
Un opérateur de préincrémentation lorsqu’il est placé à
droite de la variable sur laquelle il porte.

30
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les opérateurs d’incrémentation et de décrémentation unaires

 L’utilisation de l’opérateurs unaires ++ (– –) permet d’incrémen-


trer (décrémenter) la variable sur laquelle il porte.
 Son effet lorsqu’il est placé à gauche n’est pas le même que lors-
qu’il est placé à droite de la variable.

En effet,
 La valeur de l’expression x++ (x– –) est celle de x avant incré-
mentation (décrémentation).
 La valeur de l’expression ++x (– –x) est celle de x après incré-
mentation (décrémentation).

31
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
Les opérateurs d’incrémentation et de décrémentation unaires

Exemples :

Exemple 1 Exemple 2
int x , y ; int x , y ;
x =5; x =5;
y = x ++; y =++ x ;
x vaut 6 et y vaut 5 x vaut 6 et y vaut 6

⇒ Exemple 1 : la variable y reçoit la valeur de x avant l’incrémen-


tation.
⇒ Exemple 2 : la variable y reçoit la valeur de x après l’incrémen-
tation.
⇒ Dans les deux cas, la valeur de x est augementée de 1.

32
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
L’opérateur de cast

⇒ La converssion explicite (forcée) d’une expression quelconque dans


un type donné peut se faire à l’aide d’un opérateur un peu particulier
nommé en anglais «cast».
Exemple : soient les instructions suivantes :
int n , p ;
n =5;
p =2;
L’expression n/p vaut 2 (entier/entier ) quand à l’expression (float)n/p,
elle vaut 2.5.
En effet, l’expression (float)n/p conduirait d’abord à convertir n ex-
plicitement en float avant que les règles de conversions implicites
amèneraient à convertir p en float avant qu’ait lieu la division (float/-
float).

33
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les opérateurs
La priorités des opérateurs

Le tableau ci-après fournit la liste complète des opérateurs du lan-


gage C, classés par ordre de priorité décroissante, accompagnés de
leur mode d’associativité.

Catégorie Opérateur Associativité


Référence () [] -> . −→
Unaire + - ++ – – ! * & (cast) sizeof ←−
Arithmétique */% −→
Arithmétique +- −→
Relationnels < <= > >= −→
Relationnels == != −→
Logique && −→
Logique || −→
Conditionnel ?: −→
Logique = += -= *= /= %= ←−
34
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La fonction printf

La fonction printf permet l’écriture des données sur l’ecran comme


l’affichage d’une valeur, d’une expression ou d’un message à l’écran.
Syntaxe :

printf ( format , l is t e _d _ ex p re s s io n s )

Exemples :
float v =12.5;
int n =9;
printf ( " \% f " , v ) ; --> /* 12.500000 */
printf ( " v =\% f et n =\% d " ,v , n ) ; --> /* v =12.500000
et n =9 */
printf ( " Volume est \% f " ,v ) ; --> /* Volume est
12.500000 */
printf ( " Bonjour " ) ; --> /* Bonjour */
35
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La fonction printf

Le premier argument de printf est une chaîne de caractères qui spé-


cifie à la fois :
Des caractères à afficher tels quels,
Des codes de format repérés par % (tel que f , d ou f ) qui
précise le type de l’information à afficher.
Les principaux codes format :
Code Type
%c char (short ou à int compte tenu des conversions)
%d ou %i int
%u unsigned int (unsigned char ou unsigned short)
%ld ou %li long
%lu unsigned long
%f float
%lf double
%s chaîne de caractères dont on fournit l’adresse
36
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La fonction printf

 Le gabarit d’affichage
⇒ Par défaut, les entiers sont affichés avec le nombre de caractères
nécessaires (sans espaces avant ou après). Les flottants sont affichés
avec six chiffres après le point.

⇒Un nombre placé après % dans le code de format précise un gabarit


d’affichage, c’est-à-dire un nombre minimal de caractères à utiliser.

Exemple 1 :
printf ( " \%3 d " ,n ) ; /* entier avec 3 caract è res
minimum */
n = 20 --> ^20
n = 4 --> ^^4
n = 2358 --> 2358
n = -5200 --> -5200

37
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La fonction printf

Exemple 2 :
printf ( " % f " , x ) ; /* notation d é cimale -
gabarit par d é faut (6 chiffres apr è s point )
*/
x = 1.2345 --> 1.234500
x = 12.3456789 --> 12.345679
Exemple 3 :
printf ( " \%10 f " , x ) ; /* notation d é cimale -
gabarit mini 10 ( toujours 6 chiffres apr è s
point ) */
x = 1.2345 --> ^^1.234500
x = 12.345 --> ^12.345000
x = 1.2345 E5 --> 123450.000000

38
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La fonction printf

Exemple 4 :
printf ( " \% e " , x ) ; /* notation exponentielle -
gabarit par d é faut ( toujours 6 chiffres apr
è s point ) */
x = 1.2345 --> 1.234500 e +000
x = 123.45 --> 1.234500 e +002
x = 123.456789 E8 --> 1.234568 e +010
x = -123.456789 E8 --> -1.234568 e +010
Exemple 5 :
printf ( " \%10.3 f " , x ) ; /* notation
exponentielle - gabarit mini 10 ( et 3
chiffres apr è s point ) */
x = 1.2345 --> ^^^^^1.235
x = 1.2345 E3 --> ^^1234.500
x = 1.2345 E7 --> 12345000.000

39
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La macro putchar

L’expression :
char c ;
c = ’A ’;
putchar ( c ) --> A
joue le même rôle que :
char c ;
c = ’A ’;
printf ( " % c " , c ) ; --> A
tout en étant plus rapide puisque ne faisant pas appel au mécanisme
d’analyse d’un format.

⇒ putchar est une macro dont les instructions figurent dans stdio.h
qu’il faut charger avant de pouvoir l’utiliser.

40
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La fonction scanf

La fonction permet la lecture des données, il permet en fait d’affecter


à des variables, les valeurs lues au clavier.

Syntaxe :
scanf(codes format, liste d’adresses)

Exemples :
float x ;
int n , p ;
char c1 ;
scanf ( " % f " , & x ) ;
scanf ( " % f % d " , &x , & n ) ;
scanf ( " % d % d " , &p , & n ) ;
scanf ( " % c % d " , & c1 , & n ) ;

41
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
La macro getchar

L’expression :
char c ;
c = getchar () ;
joue le même rôle que :
scanf ( " % c " , & c )
tout en étant plus rapide puisque ne faisant pas appel au mécanisme
d’analyse d’un format.

⇒ getchar est une macro (comme putchar ) dont les instructions


figurent dans stdio.h.

42
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les entrées-sorties conversationnelles
Les commentaires

Le commentaire est un textes explicatifs destinés aux lecteurs du


programme.

⇒ Formé de caractères quelconques placés entre /* et */.


⇒ Peut apparaitre à n’importe quel endroit du programme où un
espace est autorisé.

Exemples :
int i ; /* compteur de boucles */
float x ; /* nombre dont on veut la racine carr é e
*/
float racx ; /* racine carr é e du nombre */

43
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle

44
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
Introduction

Le langage C dispose d’instructions permettant de réaliser :


Des choix : les instructions if...else et switch,
Des boucles : les instructions do...while, while et for.
Des instructions de branchement inconditionnel : break
et continue,

45
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions if...else

Syntaxe :

if ( expression ) if ( expression )
instruction_1 instruction_1
else
instruction_2

 Expression : expression quelconque


 Instruction_1 et instruction_2 : instructions quelconques et
peut être :
Simple (terminée par un point-virgule),
Bloc,
Instruction structurée.
46
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions if...else

Exemple 1 :
# include < stdio .h >
main () {
int x ;
printf ( " Donner x : " ) ;
scanf ( " % d " , & x ) ;
if (x <0)
| x=-x;
printf ( " La valeur absolue est % f " , x ) ;
}

Donner un entier : -342


La valeur absolue est 342
....................
Donner un entier : 20
La valeur absolue est 20

47
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions if...else

Exemple 2 :
# include < stdio .h >
main () {
int x ;
printf ( " Donner x : " ) ;
scanf ( " % d " , & x ) ;
if (x >=0)
| printf ( " % d est positif " , x ) ;
else
| printf ( " % d est n é gatif " , x ) ;
}

Donner un entier : -65


-65 est negatif
...............
Donner un entier : 0
0 est positif
48
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions if...else
Donner un entier : -342
-342 est negatif
Exemple 3 : ............
# include < stdio .h > Donner un entier : 0
main () { 0 est nul
int x ; ............
printf ( " Donner un entier : " ) ; Donner un entier : 20
scanf ( " % d " , & x ) ;
20 est positif
if (x >=0)
| if ( x ==0)
| | printf ( " % d est nul " , x ) ;
| else
| | printf ( " % d est positif " , x ) ;
else
| printf ( " % d est negatif " , x ) ;
}

49
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions switch

Syntaxe :

switch ( expression ) {
case valeur_1 : [ instructions_1 break ; ]
case valeur_2 : [ instructions_2 break ; ]
..............
case valeur_n : [ instructions_n break ; ]
[ default : instructions ]
}
Les crochets [ et ] signifient que leur contenu est facultatif

I Expression : expression entière quelconque,


I Valeur : valeur entière quelconque (char est accepté),
I Instructions : séquence d’instructions quelconques.

50
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions switch

Exemple :
# include < stdio .h >
main () {
int jour ;
printf ( " Donner un entier entre 1 et 7: ") ;
scanf ( " % d " , & jour ) ;
switch ( jour ) {
case 1 : printf ( " Lundi " ) ; break ;
case 2 : printf ( " Mardi " ) ; break ;
case 3 : printf ( " Mercredi " ) ; break ;
case 4 : printf ( " Jeudi " ) ; break ;
case 5 : printf ( " Vendredi " ) ; break ;
case 6 : printf ( " Samedi " ) ; break ;
case 7 : printf ( " Dimanche " ) ; break ;
default : printf ( " Erreur !! " ) ;
}
}
51
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions switch

Résultat :
Donner un entier entre 1 et 7: 1
Lundi
...............
Donner un entier entre 1 et 7: 3
Mercredi
...............
Donner un entier entre 1 et 7: 7
Dimanche
...............
Donner un entier entre 1 et 7: 9
Erreur!!

52
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions switch

Résultat :
Donner un entier entre 1 et 7: 1
Lundi
...............
Donner un entier entre 1 et 7: 3
Mercredi
...............
Donner un entier entre 1 et 7: 9
Erreur!!
Par exemple, quand jour vaut 3, on trouve une étiquette case 3 et
l’on exécute l’instruction correspondante, c’est-à-dire :
printf ( " Mercredi " ) ;
On passe ensuite à l’instruction suivante, à savoir :
break ;
Celle-ci demande en fait de sortir du bloc.
53
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions switch

Remarque : Notez bien le rôle fondamental de l’instruction break.


Exemple :
# include < stdio .h >
main () {
int jour ;
printf ( " Donner un entier entre 1 et 7: " ) ;
scanf ( " % d " , & jour ) ;
switch ( jour ) {
case 1 : printf ( " Lundi \ n " ) ; break ;
case 2 : printf ( " Mardi \ n " ) ; break ;
case 3 : printf ( " Mercredi \ n " ) ;
case 4 : printf ( " Jeudi \ n " ) ;
case 5 : printf ( " Vendredi \ n " ) ;
case 6 : printf ( " Samedi \ n " ) ; break ;
case 7 : printf ( " Dimanche \ n " ) ;
default : printf ( " Erreur !!\ n " ) ;
}
} 54
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions switch

Résultat :
Donner un entier entre 1 et 7: 1  Une fois le programme est
Lundi
branché à une étiquette, il
...............
Donner un entier entre 1 et 7: 3 continue à exécuter toutes les
Mercredi instructions qui suivent (même
Jeudi si leur etiquête non correspond
Vendredi pas) jusqu’à rencontrer une
Samedi
............... instruction break.
Donner un entier entre 1 et 7: 6
Samedi  Le mot-clé default est l’éti-
............... quette à laquelle le programme
Donner un entier entre 1 et 7: 7
Dimanche
se branchera dans le cas où au-
Erreur!! cune valeur satisfaisante n’aura
............... été rencontrée.
Donner un entier entre 1 et 7: 8
Erreur!!
55
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions do...while

Syntaxe :

do
instructions
while ( condition ) ;

 Noter le point-virgule ’ ;’ à la fin de l’instruction.


 L’instruction sera exécutée tant que lcondition est vraie.
 Le nombre de fois où une telle boucle sera répétée n’est pas connu
à l’avance. Toutefois elle est toujours parcourue au moins une fois.
En effet, la condition n’est examinée qu’à la fin de chaque itération.

56
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions do...while

Exemple :
# include < stdio .h >
main () {
int n ;
do {
printf ( " Donnez un nb >0 : " ) ;
scanf ( " % d " , & n ) ;
printf ( " Vous avez fourni % d \ n " , n ) ;
} while (n <=0) ;
printf ( " R é ponse correcte " ) ;
}
Donnez un nb >0 : -2  Répète l’instruction (ici un bloc) tant que
Vous avez fourni -2 la condition (n<=0) est vraie. Autrement
Donnez un nb >0 : -4
Vous avez fourni -4
dit, elle demande un nombre à l’utilisateur
Donnez un nb >0 : 8 (en affichant la valeur lue) tant qu’il ne
Vous avez fourni 8 fournit pas une valeur positive.
Réponse correcte
57
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions do...while

Exemple : Soit le programme suivant, qui calcule la somme des n


premiers termes de la série : 1 + 2 + 3 + . . . + n
# include < stdio .h >
main () {
int n , s , i ;
printf ( " Donnez un entier : " ) ;
scanf ( " % d " , & n ) ;
s =0;
i =1;
do {
s += i ;
i ++ ;
} while (i <= n ) ;
printf ( " Somme = % d " ,s ) ;
}

Donnez un entier :5
Somme = 15
58
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions while

Syntaxe :

while ( condition )
instructions

 L’instruction sera exécutée tant que la condition est vraie.


 La condition de poursuite, cette fois, est examinée avant chaque
parcours de la boucle et non après. Ainsi, contrairement à ce qui
se passait avec do... while, une telle boucle peut très bien n’être
éxecutée aucune fois si la condition est initialement fausse.

59
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions while

Exemple : Soit le programme suivant, qui calcule la somme des


nombres données par l’utilisateur tant que leur somme est <100.
# include < stdio .h >
main () {
int n , som ;
som = 0 ;
while ( som <100) {
printf ( " donnez un nombre : " ) ;
scanf ( " % d " , & n ) ;
som += n ;
}
printf ( " somme obtenue : % d " , som ) ;
}

Donnez un nombre : 35
Donnez un nombre : 60
Donnez un nombre : 23
Somme obtenue : 118
60
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions for

Syntaxe :

for ([ expression1 ];[ expression2 ];[ expression3 ])


instruction
Les crochets [ et ] signifient que leur contenu est facultatif

 La première expression est évaluée (une seule fois) avant d’entrer


dans la boucle. La deuxième conditionne la poursuite de la boucle.
Elle est eévaluée avant chaque parcours. La troisième, enfin, est éva-
luée à la fin de chaque parcours.

61
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions while

Exemple : Soit le programme suivant, qui affiche bonjour cinq fois.


# include < stdio .h >
main () {
int i ;
for ( i =1 ; i <=5 ; i ++ ) {
printf ( " Bonjour % d fois \ n " , i ) ;
}
}

Bonjour 1 fois
Bonjour 2 fois
Bonjour 3 fois
Bonjour 4 fois
Bonjour 5 fois

62
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instructions while

Exemple : Le programme précédent est équivalent à :


# include < stdio .h >
main () {
int i ; i =1 ;
while (i <=5) {
printf ( " Bonjour % d fois \ n " , i ) ;
i ++ ;
}
}

Bonjour 1 fois
Bonjour 2 fois
Bonjour 3 fois
Bonjour 4 fois
Bonjour 5 fois

63
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instruction break

L’instruction break sert à interrompre le déroulement d’une boucle,


en passant à l’instruction qui suit cette boucle.
main () {
int i ;
for ( i =1 ; i <=10 ; i ++) {
printf ( " D é but tour % d \ n " , i ) ;
printf ( " Bonjour \ n " ) ;
if ( i ==2) break ;
printf ( " Fin tour % d \ n " , i ) ;
}
printf ( " Suite du programme " ) ;
}
Début tour 1
Bonjour
Fin tour 1
Début tour 2
Bonjour
Suite du programme 64
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les instructions de contrôle
L’instruction continue

L’instruction continue, quant à elle, permet de passer prématurément


au tour de boucle suivant. En voici un premier exemple avec for :
# include < stdio .h >
main () {
int i ;
for ( i =1 ; i <=4 ; i ++ ) {
printf ( " D é but tour % d \ n " , i ) ;
if (i <3) continue ;
printf ( " Bonjour \ n " ) ;
}
}

Début tour 1
Début tour 2
Début tour 3
Bonjour
Début tour 4
Bonjour
65
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
La programmation modulaire
(les fonctions)

66
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Introduction

Comme tous les langages, C permet de découper un programme en


plusieurs parties nommées souvent modules qui se justifie pour de
multiples raisons :
Un programme écrit dans un seul bloc devient difficile à
comprendre dès qu’il dépasse une ou deux pages de code.
La programmation modulaire permet d’éviter des séquences
d’instructions répétitives.

67
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Introduction

Dans beaucoup de langages, on trouve deux sortes de "modules", à


savoir :
Les fonctions : assez proches de la notion mathématique.
Une fonction reçoit des arguments (paramètres) et elle fournit
un résultat.
Les procédures : qui élargissent la notion de fonction. Elles
ne possèdent pas de valeurs de retour mais elles peuvent
disposer d’arguments.
⇒ En langage C, il n’existe qu’une seule sorte de module, il s’agit
des fonctions. On parle ainsi des fonctions avec valeur de retour et
des fonctions sans valeur de retour.

68
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Exemples de définition et d’utilisation des fonctions

La fonction mathématique suivante


f : R × R −→ R
(x, y ) −→ x + y
est définie en langage c par :
main () {
float f ( float , float ) ; /* D é claration de f */
float z ;
z = f (5 ,4) ; /* Appel de la fonction f */
printf ( " % f " ,z ) ;
}
/* D é finition de la fonction f */
float f ( float x , float y ) {
float r ;
r = x+y;
return r ;
}
69
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Exemples de définition et d’utilisation des fonctions

Ce programme est divisé en deux modules (fonctions) :


 Le programme principal formé d’un bloc (la fonction main)
 La fonction f possèdant la structure voisine de celle de main :
float f ( float x , float y )
| | | |
type valeur nom de la 1 er arg 2 é me arg
de retour fonction ( float ) ( float )
I La déclaration de la fonction f dans main sert à prévenir le compila-
teur que f est une fonction et elle lui précise le type de ses arguments
ainsi que celui de sa valeur de retour.
 Cette déclaration n’est obligatoire que si elle est définie
après son appel.
I float r précise que, pour effectuer son travail, f a besoin d’une
variable locale de type float nommée r .
I return r précise la valeur que fournira la fonction.
70
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Exemples de définition et d’utilisation des fonctions

Soit la fonction absolue calculant la valeur absolue d’un réel :

absolue : R −→ R+
(
x si x ≥ 0
x −→
−x sinon

float absolue ( float x ) {


float r ;
if (x >=0)
r=x ;
else
r=-x ;
return r ;
}

71
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Exemples de définition et d’utilisation des fonctions

2ème méthode :
float absolue ( float x ) {
if (x >=0)
return x ;
else
return -x ;
}
 L’instruction return peut apparaître à plusieurs reprises dans une
fonction.
 L’instruction return peut mentionner n’importe quelle expression.
Exemple : la fonction f définie plus haut peut être définie comme
suit :
float f ( float x , float y ) {
return x + y ;
}
72
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Exemples de définition et d’utilisation des fonctions

En plus de retourner la valeur, return interrompt également l’exécu-


tion de la fonction en revenant dans la fonction qui l’a appelée.
float absolue ( float x ) {
if (x >=0)
return x ;
printf ( " Positif " ) ;
else
return -x ;
printf ( " N é gatif " ) ;
}
I Les instructions printf("Positif") et printf("Négatif") ne seront
jamais éxecutées. D’où la définition suivante :
float absolue ( float x ) {
if (x >=0)
return x ;
return -x ;
}
73
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Exemples de définition et d’utilisation des fonctions

 Fonction sans valeur de retour et sans arguments :


void Bienvenue () { /* Message de bienvenue */
printf ( " Bienvenue chers clients " ) ;
 Fonction avec arguments et sans valeur de retour :
void Bienvenue ( int n ) { /* Bienvenue n fois */
int i ;
for ( i =1; i <= n ; i ++)
printf ( " Bienvenue chers clients \ n " ) ;
}
 Fonction avec valeur de retour et sans arguments :
double pi () { /* Valeur approximative de pi */
return 3 ,141592653589793238462643383279;
}
Remarque : main est une fonction sans argument et sans valeur
de retour. Elle devrait donc avoir pour en-tête «void main(void)».
Certains compilateurs fournissent un « warning » sinon. 74
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les variables globales

Les variables globales sont des variables déclarées à l’extérieur de


toute fonction.
Elles ne sont connues que dans la partie du programme source
suivant leur déclaration.
Elles sont partagées par plusieurs fonctions.
Exemple :
int n ;
main () {
I La variable n peut être utilisée dans toutes
....
} les fonctions.
int p ; I La variable p ne peut être utilisée que dans
void f () { les fonctions f et g .
....
}
void g () {
....
}
75
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les variables locales

Les variables locales sont des variables déclarées au sein d’une fonc-
tion (qui pouvait être main).
Elles ne sont connues qu’à l’intérieur de la fonction où elles
sont déclarées.
I Leur portée est donc limitée à cette fonction.
Elles n’ont aucun lien avec d’autres variables locales d’autres
fonctions.
Exemple :
I La variable p de main n’a aucun rapport
int n ; avec la variable p de f .
main () {
I La variable n de f n’a aucun rapport avec
int p ;
.... la variable globale n.
} I Il impossible d’utiliser la variable n dans la
void f () { fonction main.
int p ; I Il impossible d’utiliser la variable global n
int n ; dans f .
}
76
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les variables locales statiques

 Les variables locales ont une durée de vie limitée à celle d’une
exécution de la fonction dans laquelle elles figurent.
 Un nouvel espace mémoire leur est alloué à chaque entrée dans la
fonction et libéré à chaque sortie.
⇒ Les valeurs des variables locales ne sont pas conservées d’un
appel au suivant. Classe d’allocation automatique

I Pour conserver la valeur d’une variable locale d’un appel au sui-


vant, il suffit de la déclarer à l’aide du mot-clé static.
⇒ Les variables locales de classe statique sont, par défaut,
initialisées à zéro.

77
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les variables locales statiques

Exemple d’utilisation de variable locale statique :


# include < stdio .h >
main () {
void fct ( void ) ;
fct () ;
fct () ;
fct () ;
}
void fct ( void ) {
static int i ;
i ++ ;
printf ( " Appel num é ro : % d \ n " , i ) ;
}

Appel numéro : 1
Appel numéro : 2
Appel numéro : 3
78
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les fonctions récursives

Le langage C autorise la récursivité des appels de fonctions. Celle-ci


peut prendre deux aspects :
Récursivité directe : une fonction comporte, dans sa
définition, au moins un appel à elle-même,
Récursivité croisée : l’appel d’une fonction entraîne celui
d’une autre fonction qui, à son tour, appelle la fonction initiale.
Exemple : la fonction factorielle récursive

f : N −→ long fact ( long n ) {


( N
1 si n = 0 if ( n ==0)
n −→ return 1;
n × fact(n − 1) sinon return n * fact (n -1) ;
}

79
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les fonctions récursives

Remarques :
 Chaque appel entraîne une allocation d’espace pour les variables
locales.
 Chaque nouvel appel de la fonction, "à l’intérieur" de la fonc-
tion elle même, provoque une allocation, sans que les emplacements
précédents soient libérés.
 Empilement des espaces alloués aux variables locales, parallèlement
à un "empilement" des appels de la fonction.
 On commence à "dépiler" les appels et les emplacements (libé-
ration de l’espace mémoire) à partir de l’exécution de la première
instruction return.
fact(0)
fact(1)
Pile des appels
fact(2)
fact(3)
80
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les fonctions récursives et itératives

Soit la suite suivante :


(
U0 = 2
Un = Un−1 + 3 si n 1
 Fonction itérative :
int u ( int n ) {
int i , s ;
s =2;
for ( i =1; i <= n ; i ++)
s = s +3 ;
return s ;
}

81
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les fonctions récursives et itératives

Soit la suite suivante :


(
U0 = 2
Un = Un−1 + 3 si n 1
 Fonction récursive :
int u ( int n ) {
if ( n ==0)
return 2 ;
return u (n -1) +3 ;
}

82
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les fonctions récursives et itératives

Soit la fonction puissance suivante :

p : R × N −→ R
(x, n) −→ x n
Fonction itérative :
float p ( float x , int n ) {
float p =1;
int i ;
for ( i =1; i <= n ; i ++)
p=p*x ;
return p ;
}
 Une fonction est dite itérative s’elle est définie en utilisant une
boucle.
83
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fonctions
Les fonctions récursives et itératives

Même fonction définie par une relation de récurrence :

p : R × N −→ R
(
1 si n = 0
(x, n) −→
x ∗ p(x, n − 1) sinon

float p ( float x , int n ) {


if ( n ==0)
return 1;
return x * p (x ,n -1) ;
}
 Une fonction est dite récursive s’elle est définie à base d’une rela-
tion de récurrence.

84
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs

85
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs

Un tableau est un ensemble d’éléments de même type désignés par


un identificateur unique et où chaque élément est repéré par un in-
dice précisant sa position au sein de l’ensemble.

Exemple :Soit T un tableau d’entiers suivant :


T[0] T[7]
↓ ↓
4 15 10 6 45 13 17 9

Un pointeurs est une variable destinée à contenir des adresses


d’autres objets (variables, fonctions...).
Exemple : Soit n un entier et adr la variable qui contient son
adresse :
0XA23 −→ 13
adr n
86
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux

Déclaration :
int t [20] ;
I Cette déclaration réserve l’emplacement pour 20 éléments de type
int dont chaque élément est repéré par sa position dans le tableau,
nommée indice.
I La première position porte le numéro 0. Ici, donc, les indices vont
de 0 à 19.
I Le premier élément du tableau sera désigné par t[0], le troisième
par t[2], le dernier par t[19].
I Attention au débordement d’indice : Désigner un indice au delà
du tableau implique un accès à un emplacement situé avant ou après
le tableau.

87
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux

 Régle No 1 : Les éléments de tableau


Un élément de tableau peut être traité comme n’importe quelle autre
variable. Ainsi les instructions suivantes sont correctes :
t [2] = 5;
t [3]++ ;
--t [ i ] ;
printf ( " % d " ,t [4]) ;
scanf ( " % d " ,& t [ i ]) ;
En revanche si t1 et t2 sont des tableaux d’entiers, il n’est pas
possible d’écrire :
t1 = t2 ;
en fait, le langage C n’offre aucune possibilité d’affectations globales
de tableaux.

88
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux

 Régle No 2 : Les indices


Un indice peut prendre la forme de n’importe quelle expression arith-
métique de type entier . Par exemple, si n, p, k et j sont de type int,
ces notations sont correctes :
t [n -3] ;
t [3* p -2* k + j % k ] ;
 Régle No 3 : La dimension d’un tableau
La dimension d’un tableau (son nombre d’éléments) ne peut être
qu’une constante ou une expression constante.
Exemples :
# define N 50 main () {
main () { const int N =50;
int t [ N ] ; int t [ N ] ;
float h [2* N -1] ; float h [2* N -1] ;
} }

89
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux

Exemple :
# include < stdio .h >
main () {
int i , som ;
float moy ;
int t [5] ;
/* Lecture des notes */
for ( i =0 ; i <5 ; i ++) {
printf ( " Note No % d : " , i +1) ;
scanf ( " % d " , & t [ i ]) ;
}
/* Calcul de la somme des notes */
for ( i =0 , som =0 ; i <5 ; i ++)
som += t [ i ] ;
moy = som /5 ; /* Calcul de la moyenne */
printf ( " Moyenne classe : %.2 f \ n " , moy ) ;
}
90
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux

Supposons que le nombre d’étudiant a changé ⇒ plusieurs modifi-


cations à faire, d’ou l’intérêt d’utiliser les constantes.
# include < stdio .h >
# define N 10
main () {
int i , som ;
float moy ;
int t [ N ] ;
/* Lecture des notes */
for ( i =0 ; i < N ; i ++) {
printf ( " Note No % d : " , i +1) ;
scanf ( " % d " , & t [ i ]) ;
}
/* Calcul de la somme des notes */
for ( i =0 , som =0 ; i < N ; i ++) som += t [ i ] ;
moy = som / N ; /* Calcul de la moyenne */
printf ( " Moyenne classe : % f \ n " , moy ) ;
} 91
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux à plusieurs indices (Les matrices)

Déclaration :
int M [4][3];
I Cette déclaration réserve un tableau de 12 (4 x 3) entiers.
I Un élément de ce tableau est repéré par deux indices comme dsuit :
M [ indice_ligne ][ indice_colonne ]
I Attention au débordement d’indice.
Exemples :
int i =2 , j =1;  
M [0][0] ; --> 12 12 3 43
 7 5 6 
M [ i + j ][0] ; --> 8  
M [ j ][ i ] ; --> 6  4 13 1 
M [ i + j ][ i ] ; --> 9 8 16 9

92
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Initialisation des tableaux à un indice

 Comme les variables scalaires, les tableaux peuvent être initialisés


au moment de la déclaration.
int T [5] = {10 , 20 , 5 , 0 , 3} ;
 Il est possible de ne mentionner que les premières valeurs :
int T [5] = {10 , 20} ;
int T [5] = {10 , 20 , 5} ;
⇒ Les valeurs manquantes seront, suivant la classe d’allocation
du tableau, initialisées à zéro (statique) ou aléatoires (automatique).

 Il est possible d’omettre la dimension du tableau, celle-ci est dé-


terminée par le compilateur par le nombre de valeurs énumérées dans
l’initialisation.
int T [] = {10 , 20 , 5 , 0 , 3} ;

93
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Initialisation des tableaux à deux indices

Soit la matrice suivante :


 
1 2 3 4
 5 6 7 8 
9 10 11 12

 Ces deux déclarations sont equivalentes :


int M [3][4]={{1 ,2 ,3 ,4} ,{5 ,6 ,7 ,8} ,{9 ,10 ,11 ,12}};
int M [3][4]={1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12};
⇒ La première forme revient à considérer le tableau comme formé
de trois tableaux de quatre éléments chacun. La seconde, elle, ex-
ploite la manière dont les éléments sont effectivement rangés en mé-
moire et elle se contente d’énumérer les valeurs du tableau suivant
cet ordre.

94
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les pointeurs : L’opérateur &

Nous avons déjà rencontré l’opérateur & dans la fonction scanf pour
désigner l’adresse d’une variable.
D’une manière générale, il est possible de manipuler des adresses par
l’intermédiaire de variables nommées pointeurs.
Exemple :
int * ad ; /* D é claration du pointeur ad */
int n ;
n = 20;
ad = & n ; /* Affectation de l ’ adresse de n à ad */

La variable (pointeur) ad contient l’adresse de n (&n ici 0XFA4)


signifie que ad est un pointeur sur la variable n. 95
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les pointeurs : L’opérateur ∗

L’opérateur ∗ désigne le contenu de l’adresse qui le suit, autrement-


dit la variable ou l’emplacement mémoire pointé par cette adresse.
Exemple :
Soient les déclarations suivantes :
int * ad ; /* D é claration du pointeur ad */
int n ;
ad = & n ; /* Affectation de l ’ adresse de n à ad */
Les instructions suivantes sont équivalentes :
n = 10 ;

* ad = 10 ;
Stocker la valeur 10 dans l’emplacement réservé pour n.

96
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les pointeurs

Exemples :
Soient les déclarations suivantes :
int * ad1 , * ad2 ;
int n = 10 , p = 20 ;
ad1 = &n ;
ad2 = &p ;
Les instructions suivantes sont équivalentes :
* ad1 = * ad2 + 2 ; ⇔ n = p + 2 ;
* ad1 ++ ; ⇔ n ++ ;
* ad1 = * ad2 ; ⇔ n = p ;
Affectation de pointeurs :
ad1 = ad2
* ad1 = 40 ; ⇔ p = 40 ;
* ad2 = 40 ; ⇔ p = 40 ;
97
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les pointeurs : Incrémentation de pointeurs

Il faut noter qu’un pointeur est défini à la fois par une adresse en
mémoire et par un type (nombre d’octets pointés).
Soit la déclaration suivante :
int * ad1 , * ad2 ;
int n ;
L’expression suivante à un sens en langage c :
ad1 = & n ;
ad2 = ad1 + 1;
En effet, ad1 est un pointeur sur un entier (4octets), l’expression
ad1 + 1 (ad2) représente l’adresse de l’entier suivant.

98
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les pointeurs : Incrémentation de pointeurs

Soit la déclaration suivante :


double * ad1 , * ad2 ;
double n ;
L’expression suivante à un sens en langage c :
ad1 = & n ;
ad2 = ad1 + 1;
En effet, ad1 est un pointeur sur un double (8octets), l’expression
ad1 + 1 (ad2) représente l’adresse de le double suivant.

99
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Transmission des arguments d’une fonction : transmission par valeur
1 main () {
2 void echange ( int , int ) ;
3 int n =10 , p =20 ;
4 printf ( " avant appel : n =% d p =% d \ n " , n , p ) ;
5 echange (n , p ) ;
6 printf ( " apr è s appel : n =% d p =% d " , n , p ) ;
7 }
8 void echange ( int a , int b ) {
9 int aux ;
10 printf ( " d é but echange : a =% d b =% d \ n " , a , b ) ;
11 aux = a ;
12 a = b ;
13 b = aux ;
14 printf ( " fin echange : a =% d b =% d \ n " , a , b ) ;
15 }
avant appel : n=10 p=20
début echange : a=10 b=20
fin echange : a=20 b=10
après appel : n=10 p=20 100
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Transmission des arguments d’une fonction : transmission par adresse

1 main () {
2 void echange ( int , int ) ;
3 int n =10 , p =20 ;
4 printf ( " avant appel n =% d p =% d \ n " , n , p ) ;
5 echange (& n , & p ) ;
6 printf ( " apr è s appel n =% d p =% d " , n , p ) ;
7 printf ( " \ n \ n " ) ;
8 }
9 void echange ( int * ad1 , int * ad2 ) {
10 int aux ;
11 aux = * ad1 ;
12 * ad1 = * ad2 ;
13 * ad2 = aux ;
14 }

avant appel n=10 p=20


après appel n=20 p=10
101
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à un indice

L’identificateur d’un tableau, lorsqu’il est employé seul (sans indices


à sa suite), est un pointeur constant sur le début du tableau.
Exemple :
int T [5] ;

T ⇔ & T [0] ⇒ 0X0


T +1 ⇔ & T [1] ⇒ 0X4
T+i ⇔ &T[i]
*( T + i ) ⇔ T[i]

102
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à un indice

Exemple : Initialiser toutes les cases d’un tableau par zéro.

# include < stdio .h >


# define N 5
main () {
int T [ N ] , i ;
for ( i =0; i < N ; i ++)
T[i] = 0 ;
}
103
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à un indice

Exemple : Initialiser toutes les cases d’un tableau par zéro.

# include < stdio .h > # include < stdio .h >


# define N 5 # define N 5
main () { main () {
int T [ N ] , i , * p ; int T [ N ] , i ;
p = T ; for ( i =0; i < N ; i ++)
for ( i =0; i < N ; i ++) *( T + i ) = 0 ;
*( p + i ) = 0 ; }
}
104
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à un indice

Exemple : Initialiser toutes les cases d’un tableau par zéro.

# include < stdio .h >


# define N 5
main () {
int T [ N ] , i ;
int * p ;
for ( p = T , i =0 ; i < N ; i ++ , p ++)
*p = 0 ;
}
NB : Nous avons recopié la valeur de T dans un pointeur variable
nommé p. En effet, T est une adresse constante (T++ est invalide). 105
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à deux indices

Soit la déclaration suivante :


int M [3][4]={{1 ,2 ,3 ,4} ,{5 ,6 ,7 ,8} ,{9 ,10 ,11 ,12}}
Vue logique (Abstraction) :

Vue physique (Au niveau de la mémoire) :

106
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à deux indices

 M est une matrice, ou encore un tableau de 3 tableaux (les lignes).


 M est l’adresse de la premiere case du tableau (ici M[0]). Or M[0]
est une ligne avec 4 cases où chacune est de taille d’un entier(4octets)
⇒ alors M est une adresse de type int [4]*. Autrement-dit, une
adresse de 4 entiers (16 octets). M=(0X0, 16)
⇒ M+1 est l’adresse de la deuxième ligne (ici M+1=(OX10, 16))
 M[0] par contre est une ligne, autrement dit un tableau de 4 entiers
⇒ alors M[0] est une adresse de type int*
⇒ M[0]+1 est l’adresse de la deuxième case de la première ligne
(ici M[0]+1=(OX4, 4)) M[0]=&M[0][0] et M[0]+1=&M[0][]

107
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à deux indices

108
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Le nom de tableau est un pointeur constant : cas des tableaux à deux indices

# include < stdio .h >


main () {
int M [3][4]={{1 ,2 ,3 ,4} ,{5 ,6 ,7 ,8} ,{9 ,10 ,11 ,12}};
int *p , i ;
for ( p = M [0] , i =0; i <12; i ++ , p ++)
printf ( " % d " ,* p ) ;
}
109
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
La comparaison de pointeurs

Il est possible, en C, de comparer des pointeurs de même type.


Exemple : Ces deux programmes sont équivalents.
# include < stdio .h >
main () {
int T []={1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10};
int i ;
for ( i =10 ; i <10; i ++)
printf ( " % d " ,T [ i ]) ;
}

# include < stdio .h >
main () {
int T []={1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10};
int * p ;
for ( p = T ; p < T +10; p ++)
printf ( " % d " ,* p ) ;
}
110
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux transmis en argument : cas des tableaux à un indice

Lorsque l’on place le nom d’un tableau en argument de la fonction,


on transmet finalement l’adresse du tableau à la fonction :
⇒ Les tableaux sont passés par adresse.
⇒ Il est donc possible de modifier leurs élements dans la fonction.
Exemple :
# include < stdio .h > main () {
# define N 5 int A []={1 ,2 ,3 ,4 ,5};
void raz ( int T [ N ]) { int B []={3 ,6 ,2 ,9 ,1};
int i ; raz ( A ) ;
for ( i =0; i < N ; i ++) afficher ( A ) ;
T [ i ]=0; raz ( B ) ;
} afficher ( B ) ;
void afficher ( int T [ N ]) { }
int i ;
for ( i =0 ; i < N ; i ++)
printf ( " % d " ,T [ i ]) ;
}
111
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux transmis en argument : cas des tableaux à un indice

 Tableau de taille fixe :


void raz ( int T [5]) {
int i ;
for ( i =0; i <5; i ++) T [ i ]=0;
}
⇒ Cette fonction ne peut être appliquée que sur des tableaux de
taille 5.
main () {
int A []={1 ,2 ,3 ,4 ,5} , B []={1 ,2 ,3 ,4 ,5 ,6 ,7} , i ;
raz ( A ) ;
for ( i =0; i <5; i ++) printf ( " % d " ,A [ i ]) ;
raz ( B ) ;
for ( i =0; i <7; i ++) printf ( " % d " ,B [ i ]) ;
}
Affichage du tableau A : 0 0 0 0 0
Affichage du tableau B : 0 0 0 0 0 6 7
112
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux transmis en argument : cas des tableaux à un indice

 Tableau de taille variable :


void raz ( int T [] , int N ) {
int i ;
for ( i =0; i < N ; i ++) T [ i ]=0;
}
⇒ Cette fonction peut être appliquée sur des tableaux de taille quel-
conque.
main () {
int A []={1 ,2 ,3 ,4 ,5} , B []={1 ,2 ,3 ,4 ,5 ,6 ,7} , i ;
raz (A ,5) ;
for ( i =0; i <5; i ++) printf ( " % d " ,A [ i ]) ;
raz (B ,7) ;
for ( i =0; i <7; i ++) printf ( " % d " ,B [ i ]) ;
}
Affichage du tableau A : 0 0 0 0 0
Affichage du tableau B : 0 0 0 0 0 0 0
113
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux transmis en argument : cas des tableaux à un indice

 L’en-tête de raz peut être indifféremment écrit de l’une des ma-


nières suivantes :
void raz ( int T [10])
void raz ( int * T )
void raz ( int T [])
 Quel que soit l’en-tête employé, on peut, dans la définition de la
fonction, utiliser indifféremment le formalisme tableau ou le forma-
lisme pointeur.
for ( i =0 ; i < N ; i ++) T [ i ] = 0 ;

for ( i =0 ; i < N ; i ++) *( T + i ) = 0 ;

for ( p = T ; p < T + N ; p ++) * p = 0 ;

for ( i =0 ; i < N ; i ++) T [ i ] = 0 ;


114
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux transmis en argument : cas des tableaux à plusieurs indices

# include < stdio .h >


void raz ( int M [2][3]) {
int i , j ;
for ( i =0; i <2; i ++)
for ( j =0; j <3; j ++)
M [ i ][ j ]=0;
}
void afficher ( int M [2][3]) {
int i , j ;
for ( i =0; i <2; i ++)
for ( j =0; j <3; j ++)
printf ( " % d " , M [ i ][ j ]) ;
}
main () {
int A [2][3]={{1 ,1 ,1} ,{2 ,2 ,2}};
raz ( A ) ;
afficher ( A ) ;
}
115
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les tableaux et les pointeurs
Les tableaux transmis en argument : cas des tableaux à plusieurs indices

Exemple : Somme de deux matrices :


# include < stdio .h >
# define N 3
# define M 4
void somme ( int A [ N ][ M ] , int B [ N ][ M ] , int C [ N ][ M ])
{
int i , j ;
for ( i =0; i < N ; i ++)
for ( j =0; j < M ; j ++)
C [ i ][ j ]= A [ i ][ j ]+ B [ i ][ j ];
}
main () {
int A [ N ][ M ]={{1 ,1 ,1 ,1} ,{2 ,2 ,2 ,2} ,{3 ,3 ,3 ,3}};
int B [ N ][ M ]={{4 ,4 ,4 ,4} ,{5 ,5 ,5 ,5} ,{6 ,6 ,6 ,6}};
int C [ N ][ M ];
somme (A ,B , C ) ;
}
116
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les algorithmes de tri et de
recherche

117
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les algorithmes de tri et de recherche
Recherche sequentielle

⇒ La recherche séquentielle consiste à parcourir un tableau jusqu’à


trouver la valeur cherchée ou atteindre la fin de la liste sans la trouver.
int rech_seq ( int * T , int x , int n ) {
int i =0;
for ( i =0; i < n ; i ++) {
if ( T [ i ]== x ) return 1;
}
return 0;
}
main () {
int x , T []={13 ,22 ,33 ,41 ,52 ,16 ,87 ,18 ,18 ,1};
printf ( " Donner la valeur recherch é e : " ) ;
scanf ( " % d " ,& x ) ;
if ( rech_seq (T ,x ,10) ) printf ( " % d exist \ n " ,x ) ;
else printf ( " % d n ’ exist pas \ n " ,x ) ;
}

118
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les algorithmes de tri et de recherche
Recherche dichotomique
⇒ La recherche dichotomique consiste à chercher en subdivisant le
tableau ordonnée (trié) en deux parties et vérifier dans quelle partie
figurerait la valeur recherchée, puis réitérer ce processus
int rech_dicho ( int * T , int x , int n ) {
int d =0 , f =n , m ;
while (d < f ) {
m =( d + f ) /2;
if ( T [ m ]== x ) return 1;
else if ( T [ m ] > x ) f = m ;
else d = m +1;
}
return 0;
}
main () {
int x , T []={1 ,13 ,16 ,18 ,18 ,22 ,33 ,41 ,52 ,87};
scanf ( " % d " ,& x ) ;
if ( rech_dicho (T ,x ,10) ) printf ( " % d exist " , x ) ;
else printf ( " % d n ’ exist pas " , x ) ;
} 119
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les algorithmes de tri et de recherche
Tri à bulles

⇒ Le principe du tri à bulles est de comparer deux à deux les éléments


adjacents et les permuter s’ils ne sont pas dans le bon ordre. On
répète le processus jusqu’à ce qu’il n’y ait plus de permutation.
void tri_bulle ( int * T , int n ) {
int i =0 , trie , aux , l = n ;
do { | 4 | 1 | 5 | 2 | 3 |
trie =1; | 1 | 4 | 5 | 2 | 3 |
for ( i =0; i <l -1; i ++) | 1 | 4 | 5 | 2 | 3 |
if ( T [ i ] > T [ i +1]) { | 1 | 4 | 2 | 5 | 3 |
aux = T [ i ]; | 1 | 4 | 2 | 3 | 5 |
T [ i ]= T [ i +1]; | 1 | 4 | 2 | 3 | 5 |
T [ i +1]= aux ; | 1 | 2 | 4 | 3 | 5 |
trie =0; | 1 | 2 | 3 | 4 | 5 |
}
l - -;
} while ( trie ==0) ;
}
120
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les algorithmes de tri et de recherche
Tri par sélection

⇒ Le principe de par sélection est que pour classer n valeurs, il faut


rechercher la plus petite valeur et la placer au début du tableau, puis
la plus petite valeur dans les valeurs restante et la placer dans la
deuxième position et ainsi de suite.
void tri_selection ( int * T , int n ) {
int i , j , k , aux ;
for ( i =0; i <n -1; i ++) { | 4 | 1 | 5 | 3 | 2 |
k=i; | 1 | 4 | 5 | 2 | 3 |
for ( j = i +1; j < n ; j ++) { | 1 | 2 | 5 | 4 | 3 |
if ( T [ j ] < T [ k ]) k = j ; | 1 | 2 | 3 | 4 | 5 |
}
aux = T [ i ];
T [ i ]= T [ k ];
T [ k ]= aux ;
afficher (T ,5) ;
}
}
121
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères

122
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères

En langage C, il n’existe pas de véritable type chaîne comme dans


les autres langages des programmation. En revanche, il existe une
convention de représentation des chaînes utilisant des tableaux de
caractères.
Une chaîne est ainsi représentée par une suite de caractères termi-
née par un caractère supplémentaire de code nul (\0). Cela signifie
qu’une chaîne de n caractères occupe en mémoire un emplacement
de n + 1 octets.

123
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
C’est cette convention qu’utilise le compilateur pour représenter les
« constantes chaîne » sous des notations de la forme :
" bonjour "
Une telle notation sera traduite par le compilateur en un pointeur
(de type char ∗) sur la zone mémoire correspondante.
Exemple :
# include < stdio .h >
main () {
char * adr ;
adr = " Bonjour " ;
while (* adr ) {
printf ( " % c " , * adr ) ;
adr ++ ;
}
}
Bonjour
124
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Tableaux de caractères

Il est possible en langage C de placer une chîne de caractères dans


un tableau de caractères.
Exemple :
char ch [20] = " Bonjour " ;
/* Ou encore */
char ch [] = " Bonjour " ;
Cela sera parfaitement équivalent à une initialisation de ch réalisée
par une énumération de caractères (sans oublier le caractère nul de
fin de chaîne (\0)) :
char ch [20]={ ’B ’ , ’o ’ , ’n ’ , ’j ’ , ’o ’ , ’u ’ , ’r ’ , ’ \0 ’ };
/* Ou encore */
char ch []={ ’B ’ , ’o ’ , ’n ’ , ’j ’ , ’o ’ , ’u ’ , ’r ’ , ’ \0 ’ };

125
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Tableaux de caractères

Remarque :
Comme pour les tableaux numériques, il n’est pas autorisé d’initialiser
une chaîne de caractères par une déclaration comme dans l’exemple
suivant :
char ch [20] ;
ch = " bonjour " ;
En effet, ch est une adresse constante.

126
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Tableaux de pointeurs sur des chaînes

Comme une chaîne de caractères est traduite par le compilateur en


un pointeur qui contient son adresse, il est possible de généraliser ce
principe à un tableau de pointeurs comme dans l’exemple suivant :
char * jour []={ " lundi " ," mardi " ," mercredi " ," jeudi
" ," vendredi " ," samedi " ," dimanche " };
Cette déclaration réalise donc à la fois la création des 7 chaînes
constantes correspondant aux 7 jours de la semaine et l’initialisation
du tableau jour avec les 7 adresses de ces 7 chaînes.

127
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Tableaux de pointeurs sur des chaîne

# include < stdio .h >


main () {
char * jour [7]={ " lundi " ," mardi " ," mercredi " ,"
jeudi " ," vendredi " ," samedi " ," dimanche " };
int i ;
printf ( " Donner un entier entre 1 et 7 : " ) ;
scanf ( " % d " , & i ) ;
printf ( " Le jour num é ro % d est % s " ,i , jour [i
-1]) ;
}

Donnez un entier entre 1 et 7 : 3


Le jour numéro 3 est mercredi
⇒ Remarquer le code format %s pour l’affichage des chaînes de ca-
ractères.

128
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Lecture et écriture de chaînes

Le langage C offre plusieurs possibilités de lecture ou d’écriture de


chaînes :
l’utilisation du code de format %s dans les fonctions printf et
scanf ,
les fonctions spécifiques de lecture gets ou d’affichage puts
d’une chaîne.
Remarque :
Les fonctions printf et scanf permettent de lire ou d’afficher simulta-
nément plusieurs informations de type quelconque. Par contre, gets
et puts ne traitent qu’une chaîne à la fois.

129
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Lecture et écriture de chaînes

# include < stdio .h >


main () {
char nom [20] , prenom [20] , ville [15] ;
printf ( " Quelle est votre ville : " ) ;
gets ( ville ) ;
printf ( " Donnez votre nom et votre pr é nom : " )
;
scanf ( " % s % s " , nom , prenom ) ;
printf ( " Bonjour % s %s , vous habitez à " ,
prenom , nom ) ;
puts ( ville ) ;
}

Quelle est votre ville : Mohammedia


Donnez votre nom et votre prénom : Naciri Karim
Bonjour Naciri Karim, vous habitez à Mohammedia
Remarque : Les identificateurs des tableaux n’ont pas besoin d’être
précédés par l’opérateur & puisqu’ils représentent déjà des adresses.
130
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions portant sur des chaînes

C dispose de plusieurs fonctions de manipulation de chaînes définies


dans la bibliothèque < strig .h >.
La fonction strlen

int strlen ( char * chaine ) ;

La fonction strlen fournit en résultat la longueur d’une chaîne dont


son adresse est passée en arguments (sans compter le caractère \0).
Exemples :
strlen ( " bonjour " ) ---> 7

char * adr = " salut " ;


strlen ( adr ) ---> 5

131
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions strcpy et strncpy

Les fonctions strcpy et strncpy

char * strcpy ( char * dest , char * src )

char * strncpy ( char * dest , char * src , int n )

I strcpy copie la chaîne src, y compris le caractère (\0) dans dest.


I strncpy est identique, sauf qu’au plus n octets de src sont copiés.
Remarques :
I Il faut que la chaîne dest soit assez grande pour accueillir la chaîne
src
I S’il n’y a pas de caractère nul dans les n premiers caractères de
src, la chaîne résultante dest ne disposera pas de caractère nul.

132
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions strcpy et strncpy

Exemple :
# include < stdio .h >
# include < string .h >
main () {
char ch1 []= " *************** " ;
char ch2 []= " Bonjour " ;
char ch3 []= " *************** " ;
char ch4 []= " Bonjour " ;

strcpy ( ch1 , ch2 ) ;


printf ( " % s \ n " , ch1 ) ; ---> Bonjour

strncpy ( ch3 , ch4 ,3) ;


printf ( " % s \ n " , ch3 ) ; ---> Bon ************

133
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions strcmp et strncmp

Les fonctions strcmp et strncmp

int strcmp ( char * s1 , char * s2 )

int strncmp ( char * s1 , char * s2 , int n )

I strcmp compare les deux chaînes s1 et s2 et renvoie un entier


négatif, nul, ou positif, si s1 est respectivement inférieure, égale ou
supérieure à s2.
I strncmp est identique à strcmp sauf qu’elle ne compare que les n
(au plus) premiers caractères de s1 et s2.

134
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions strcmp et strncmp

Exemple :
# include < stdio .h >
# include < string .h >
main () {
char * s1 , * s2 , * s3 ;
s1 = " ABCD " ;
s2 = " EFGHIJ " ;
s3 = " ABCDEFGHIJK " ;
printf ( " % d \ n " , strcmp ( s3 , s1 ) ) ; ---> 69
printf ( " % d \ n " , strcmp ( s1 , s3 ) ) ; ---> -69
printf ( " % d \ n " , strncmp ( s1 , s3 ,4) ) ; ---> 0
printf ( " % d \ n " , strcmp ( s1 , s1 ) ) ; ---> 0
}

135
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions strcat et strncat

Les fonctions strcat et strncat

char * strcat ( char * s1 , char * s2 )

char * strncat ( char * s1 , char * s2 , int n )

I strcat ajoute la chaîne src à la fin de la chaîne dest en écrasant le


caractère nul (\0) à la fin de dest, puis en ajoutant un nouveau ca-
ractère nul final. La chaîne dest doit être assez grande pour accueillir
le résultat.
I strncat est similaire, à la différence qu’elle ne prend en compte
que les n premiers caractères de src.
I strcat et strncat renvoient un pointeur sur la chaîne résultat dest.

136
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les chaînes de caractères
Les fonctions strcat et strncat

Exemple :
# include < stdio .h >
# include < string .h >
main () {
char ch1 [50] = " Bonjour " ;
char * ch2 = " Monsieur " ;
char ch3 [50] = " Bonjour " ;

strcat ( ch1 , ch2 ) ;


printf ( " % s \ n " , ch1 ) ; ---> Bonjour Monsieur

strncat ( ch3 , ch2 ,4) ;


printf ( " % s \ n " , ch3 ) ; ---> Bonjour Mon
}

137
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures

138
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Introduction

 Les tableaux permettent de désigner sous un seul nom un ensemble


de valeurs de même type, chacune repérée par un indice.
 Les structures permettent de désigner sous un seul nom un en-
semble de valeurs pouvant être de types différents. L’accès à chaque
élément de la structure (nommé champ) se fera, cette fois, non plus
par une indication de position comme dans un tableau, mais par son
nom au sein de la structure.

139
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Déclaration

Exemple :
struct complexe {
float re ;
float im ;
};
 Celle-ci définit un modèle de structure mais ne réserve pas de
variables correspondant à cette structure.
 Ce modèle s’appelle ici complexe et il précise le nom et le type de
chacun de ses "champs" (re, im).
Exemple de déclarations :
struct complexe z1 , z2 ;
Cette instruction réserve un emplacement nommé z1 et z2 de type
complexe.
Initialisation d’une structure :
struct complexe z = {2.3 , 5.4};
140
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Utilisation d’une structure

Il est possible d’utiliser une structure de deux manières :


en travaillant individuellement sur chacun de ses champs,
en travaillant de manière "globale" sur l’ensemble de la
structure.
 Utilisation des champs d’une structure.
⇒ Chaque champ d’une structure peut être manipulé comme n’im-
porte quelle autre variable.
⇒ La désignation d’un champ se note en faisant suivre le nom de la
variable structure de l’opérateur "point" (.) du nom de champ.
Exemple.
z1 . re = 2.3 ;
printf ( " % f " , z1 . re ) ;
scanf ( " % f " , & z1 . im ) ;
z1 . re ++ ;

141
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Utilisation d’une structure

 Utilisation globale d’une structure. Il est possible d’affecter à


une structure le contenu d’une structure définie à partir du même
modèle.
Exemple :
struct complexe z1 , z2 ;
z1 = z2 ;
Une telle affectation globale est équivalentes à :
struct complexe z1 , z2 ;
z1 . re = z2 . re ;
z1 . im = z2 . im ;
Remarque :
L’affectation globale n’est possible que si les structures ont été défi-
nies avec le même nom de modèle.
142
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Synonymes avec typdef

L’instruction typedef permet de définir des types synonymes et peut


s’appliquer à tous les types et non seulement aux structures.
Exemples :
typedef int entier ;
Cette déclaration signifie que entier est "synonyme" de int, de sorte
que les déclarations suivantes sont équivalentes :

int n , p ; ⇔ entier n , p ;

De même pour :
typedef int * pointeur ;
signifie que pointeur est synonyme de int∗. de sorte que les déclara-
tions suivantes sont équivalentes :

int * p1 , * p2 ; ⇔ pointeur p1 , p2 ;
143
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Synonymes avec typdef

En utilisant typedef , les déclarations des structures z1 et z2 peuvent


être réalisées comme suit :
struct nombrecomlexe {
float re ;
float im ;
} ;
typedef struct nombrecomlexe complexe ;
complexe z1 , z2 ;
Ou encore, plus simplement :
typedef struct nombrecomlexe { typedef struct {
float re ; float re ;
float im ; float im ;
} complexe ; } complexe ;
complexe z1 , z2 ; complexe z1 , z2 ;

144
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Structure comportant des tableaux

typedef struct {
char nom [30] ;
char prenom [30] ;
float notes [5] ; /* Notes d ’ un é tudiant */
int age ;
} Etudiant ;
Etudiant E1 , E2 ;
Cette déclaration réserve les emplacements pour deux structures
nommées E 1 et E 2. Ces dernières comportent trois champs :
nom qui est un tableau de 30 caractères,
pr nom qui est un tableau de 30 caractères,
notes qui est un tableau des 5 notes obtenues par l’étudiant.
age qui de type entier
Exemples d’utilisation :
E1 . notes [1]; /* deuxi è me note de E1 */
E2 . nom [4]; /* cinqi è me caract è re du nom de E2 */
145
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Tableau de structures

typedef struct {
int x ;
int y ;
} point ;
point courbe [50] ;
La structure point représente un point d’un plan et qui est défini par
ses deux coordonnées x et y .
la notation :
courbe [ i ]. x ;
désigne la valeur du champ x de l’élément de rang i du tableau
courbe.
Par ailleurs :
courbe [4] ;
représente la structure de type point correspondant au cinquième
élément du tableau courbe. 146
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Imbrication de structures

Supposons que dans les structures E 1 et E 2 définies précédemment,


nous voulons introduire la date de naissance au lieu de l’age. Si cette
date st elle-même une structure comportant trois champs correspon-
dant au jour, au mois et à l’année, nous pouvons alors procéder
comme suit :
typedef struct {
typedef struct {
char nom [30];
int jour ;
char prenom [20];
int mois ;
date naissance ;
int annee ;
} Etudiant ;
} date ;
Etudiant E1 , E2 ;
/* Date de naissance de E1 ( de type date ) */
E1 . naissance ;
/* Ann é e de niassance de E1 ( de type int ) */
E1 . naissance . annee ;

147
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Pointeur sur une structure : l’opérateur ->

Comme pour les autres types standards, il est possible de déclarer


des pointeurs sur des structures.
point p = {3.2 , 4.5};
point * adr ;
adr = & p ;
Pour accéder aux champs de la structure d’adresse adr , l’opérateur
point (.) ne convient plus. En effet, il suppose comme premier opé-
rande un nom de structure et non une adresse.
Deux solutions s’offrent :
I Adopter une notation telle que (∗adr ).x ou (∗adr ).y pour dé-
signer les champs de la structure d’adresse adr ,
I Faire appel à l’opérateur ->. Ainsi, adr->x ou adr->y désignent
les champs de la structure d’adresse adr .

148
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Exemples

# include < stdio .h >


typedef struct {
float x ;
float y ;
} point ;
void deplacer ( point * p , float dx , float dy ) {
p - > x += dx ;
p - > y += dy ;
}
void afficher ( point p ) {
printf ( " (%.2 f ,%.2 f ) " ,p .x , p . y ) ;
}
main () {
point p ={4 ,7};
afficher ( p ) ; --> (4.00 ,7.00)
deplacer (& p ,2 ,5) ;
afficher ( p ) ; --> (6.00 ,12.00)
}
149
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Exemples

typedef struct {
float re ;
float im ;
} complexe ;
complexe somme ( complexe z1 , complexe z2 ) {
complexe z ;
z . re = z1 . re + z2 . re ;
z . im = z1 . im + z2 . im ;
return z ;
}
void afficher ( complexe z ) {
printf ( " %.2 f + i %.2 f " ,z . re , z . im ) ;
}
main () {
complexe c1 ={3.5 ,6.5} , c2 ={4.2 ,7.9} , c ;
c = somme ( c1 , c2 ) ;
afficher ( c ) ; --> /* 7.70 + i 14.40 */
}
150
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les structures
Exemples

# include < stdio .h >


# include < math .h >
typedef struct {
float x ;
float y ;
} vecteur ;
float norme ( vecteur v ) {
return sqrt ( v . x * v . x + v . y * v . y ) ;
}
float p_scalaire ( vecteur u , vecteur v ) {
return u . x * v . x + u . y + v . y ;
}
main () {
vecteur w ={3.3 ,5.2} , v ={5.6 ,8.4};
printf ( " %.2 f \ n " , norme ( w ) ) ; /* 6.16 */
printf ( " %.2 f \ n " , p_scalaire (v , w ) ) ; /* 32.08 */
}
151
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers

152
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers
Introduction

Un fichier est un ensemble d’informations stockées sur une mémoire


de masse (disque dur, clé USB, disquette, CD-ROM, etc).
⇒ Types de fichiers :
Les fichiers textes : les informations sont stockées sous forme
de caractères lisibles par tout éditeur de texte.
Les fichiers binaires : les informations sont stockées en binaire
et ne peuvent être lues qu’avec le logiciel adéquat (image,
vidéo, son, etc).
⇒ Modes d’accès aux fichiers :
Accès séquentiel : consiste à traiter les informations
"séquentiellement", c’est-à-dire dans l’ordre où elles
apparaissent dans le fichier.
Accès direct : consiste à se placer immédiatement sur
l’information souhaitée, sans avoir à parcourir celles qui la
précèdent
153
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers
Introduction

Pour utiliser un fichier en C, il feut :


Ouvrir le fichier en appelant la fonction fopen qui renvoie un
pointeur de type FILE*.
Vérifier si l’ouverture a réussie. (le pointeur retourné est
différent de NULL).
Accéder au fichier (si l’ouverture a réussie) pour lire son
contenu et à écrire dedans.
Une fois que vous aurez fini de travailler avec le fichier, il
faudra le "fermer" en appelant la fonction fclose.

154
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte
Ouverture

Syntaxe : Ouverture d’un fichier texte

FILE * fopen ( char * nom , char * mode )

Cette fonction renvoie un pointeur sur le fichier ouvert. Elle est définie
dans le bibliothèque stdio.h.
nom : est une chaîne de caractères contenant le nom ou le
chemin du fichier.
mode : désigne le type de traitement des données
"r" (read) : lecture (si le fichier existe)
"w" (write) : écriture (le fichier est crée s’il n’existe pas, sinon
il est écrasé)
"a" (append) : écriture (le fichier est crée s’il n’existe pas) à la
fin d’un fichier existant.

155
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte
Ouverture

# include < stdio .h >


main () {
FILE * fichier ;
fichier = fopen ( " test . txt " , " w " ) ;
if ( fichier != NULL ) {
printf ( " L ’ ouverture a r é ussie " ) ;
}
else {
printf ( " L ’ ouverture a é chou é e " ) ;
}
}

156
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte
Fermeture

Il faut toujours fermer le fichier après l’avoir utilisé afin de libérer la


mémoire.
Syntaxe : Fermeture d’un fichier texte

int fclose ( FILE * fichier )

Cette fonction prend en paramètre le pointeur sur le fichier à


fermer.
Elle renvoie 0 si la fermeture a réussie.

157
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Ecriture dans un fichier
La fonction fputc

Syntaxe : fputc pour écrire un seul caractère

fputc ( char caract è re , FILE * fichier )

# include < stdio .h >


main () {
FILE * fichier ;
fichier = fopen ( " test . txt " , " w " ) ;
if ( fichier != NULL ) {
fputc ( ’A ’ , fichier ) ;
fclose ( fichier ) ;
}
else
printf ( " L ’ ouverture a é chou é e .. " ) ;
}

158
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Ecriture dans un fichier
La fonction fputs

Syntaxe : fputs pour écrire une chaîne

fputs ( char * chaine , FILE * fichier )

# include < stdio .h >


main () {
FILE * fichier ;
fichier = fopen ( " test . txt " , " w " ) ;
if ( fichier != NULL ) {
fputs ( " Bonjour , c ’ est un test " , fichier ) ;
fclose ( fichier ) ;
}
else
printf ( " L ’ ouverture a é chou é e " ) ;
}

159
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Ecriture dans un fichier
La fonction fprintf

Syntaxe : fprintf pour écrire une chaîne formatée

fprintf ( FILE * fichier , char * format , expressions )

# include < stdio .h >


main () {
FILE * fichier ;
int age = 0;
fichier = fopen ( " test . txt " , " w " ) ;
if ( fichier != NULL ) {
printf ( " Quel age avez - vous ? " ) ;
scanf ( " % d " , & age ) ;
fprintf ( fichier , " vous avez % d ans " , age ) ;
fclose ( fichier ) ;
}
else
printf ( " L ’ ouverture a é chou é e " ) ;
} 160
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Lecture d’un fichier
La fonction fgetc

Syntaxe : fgetc pour lire un seul caractère

char fgetc ( FILE * fichier )

⇒ Renvoie EOF quand elle arrive à la fin du fichier.


# include < stdio .h >
main () {
FILE * fichier ;
char c ;
fichier = fopen ( " test . txt " ," r " ) ;
c = fgetc ( fichier ) ;
while ( c != EOF ) {
printf ( " % c " , c ) ;
c = fgetc ( fichier ) ;
}
fclose ( fichier ) ;
}
161
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Lecture d’un fichier
La fonction fgets

Syntaxe : fgets pour lire une chaîne

char * fgets ( char * chaine , int nb_car , FILE * fich )

⇒ Renvoie NULL si la lecture a échouée.


⇒ Lit au maximum une ligne, elle sarrête au premier \n rencontré.
# include < stdio .h >
# define TAILLE_MAX 40
main () {
FILE * fichier ;
char chaine [ TAILLE_MAX ] ;
fichier = fopen ( " test . txt " , " r " ) ;
fgets ( chaine , TAILLE_MAX , fichier ) ;
printf ( " % s " , chaine ) ;
fclose ( fichier ) ;
}
162
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Lecture d’un fichier
La fonction fgets

Exemple : Lire toutes les lignes.


# include < stdio .h >
# define TAILLE_MAX 100
main () {
FILE * fichier ;
char chaine [ TAILLE_MAX ]= " " ;
char * test ;
fichier = fopen ( " / Users / anter / Desktop / test .
txt " , " r " ) ;
test = fgets ( chaine , TAILLE_MAX , fichier ) ;
do {
test = fgets ( chaine , TAILLE_MAX , fichier ) ;
printf ( " % s " , chaine ) ;
} while ( test != NULL ) ;
fclose ( fichier ) ;
}

163
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte : Lecture d’un fichier
La fonction fscanf

Syntaxe : fscanf pour lire une chaîne formatée

fscanf ( FILE * fichier , char * format , adresses )

⇒ Lit dans un fichier qui doit être écrit d’une manière bien précise.
⇒ Lit une suite de nombres séparés par des espaces.
# include < stdio .h >
main () {
FILE * fichier ;
int a ,b , c ;
fichier = fopen ( " test . txt " , " r " ) ;
fscanf ( fichier , " % d % d % d " , &a ,& b ,& c ) ;
printf ( " % d % d % d " ,a ,b , c ) ;
fclose ( fichier ) ;
}

164
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte
Positionnement dans un fichier : la fonction fseek

⇒ Les différentes fonctions d’entrées-sorties permettent d’accéder à


un fichier en mode séquentiel, autrement-dit, les données du fichier
sont lues ou écrites les unes à la suite des autres.
⇒ Il est possible d’accéder à un fichier en mode direct, c’est-à-dire
que l’on peut se positionner à un endroit précis du fichier.
Syntaxe : La fonction seek

fseek ( FILE * fichier , long deplacement , int


origine )

La variable deplacement détermine déplacement (en nombre d’oc-


tets) par rapport à l’origine qui peut prendre trois valeurs :
SEEK_SET (égale à 0) : début du fichier
SEEK_CUR (égale à 1) : position courante
SEEK_END (égale à 2) : fin du fichier.
165
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers texte
Positionnement dans un fichier

⇒ La fonction rewind permet de se positionner au début du fichier.


Syntaxe :

rewind ( FILE * fichier )


Elle est équivalente à :
fseek ( fichier , 0 , SEEK_SET )

⇒ La fonction ftell permet de retourner la position courante dans le


fichier (en nombre d’octets depuis l’origine).
Syntaxe :

long ftell ( FILE * fichier )

166
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers binaires
Ouverture

Les modes d’ouverture de fichiers binaires :


"rb" (read) : lecture
"wb" (write) : écriture (le fichier est écrasé s’il existe)
"ab" (append) : écriture à la fin d’un fichier existant

167
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers binaires
Lecture et Ecriture dans un bloc de données en binaire

Syntaxe : La fonction fwrite

fwrite ( void * source , int taille_type , int


nombre_blocs , FILE * fichier )

⇒ Ecrit un bloc de données en un seul appel


⇒ Retourne un entier, nombre d’éléments effectivement écrits
Syntaxe : La fonction fread

fread ( void * destination , int taille_type , int


nombre_blocs , FILE * fichier )

⇒ Lit un bloc de données en un seul appel


⇒ Retourne un entier, nombre d’éléments effectivement lus
168
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Les fichiers binaires
Lecture et Ecriture d’un bloc de données en binaire

# define N 100
void main () {
char * src = " test . bin " ;
int i , A [ N ] , B [ N ];
FILE * fichier ;
/* Remplissage du tableau */
for ( i =1; i < N ; i ++) A [ i ]= i ;
/* Ecriture du fichier au format binaire */
fichier = fopen ( src , " wb " ) ;
fwrite (A , sizeof ( int ) ,N , fichier ) ;
fclose ( fichier ) ;
/* Lecture du fichier */
fichier = fopen ( src , " rb " ) ;
fread (B , sizeof ( int ) ,N , fichier ) ;
fclose ( fichier ) ;
/* Affichage du tableau */
for ( i =0; i < N ; i ++) printf ( " % i " ,B [ i ]) ;
}
169
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
Gestion dynamique de la
mémoire

170
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
La gestion dynamique de la mémoire

Le langage C offre les possibilités d’allocation dynamique d’espace


mémoire. Autrement-dit, les données n’ont pas non plus de taille
définie à priori. Leur création ou leur libération dépend, des demandes
explicites faites lors de l’exécution du programme.

171
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
La gestion dynamique de la mémoire
La fonction malloc

Exemple 1 :
char * adr ;
.....
adr = malloc (50) ;
.....
for ( p = adr ; p < adr +50 ; p ++) * p = ’a ’ ;
L’appel :
malloc (50)
alloue un emplacement de 50 octets et en fournit l’adresse en retour.
Ici, cette dernière est placée dans le pointeur adr .

172
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
La gestion dynamique de la mémoire
La fonction malloc

Exemple 2 :
long * adr , * p ;
.....
adr = malloc (100 * sizeof ( long ) ) ;
.....
for ( p = adr , i =0 ; p < adr +100 ; p ++ , i ++) * p = i ;
Cette fois, nous avons alloué une zone de 100 * sizeof(long) octets.
Toutefois, nous l’avons considérée comme une suite de 100long . Pour
ce faire, on a placé le résultat de malloc dans un pointeur sur des
éléments de type long.
p ++
correspond à l’adresse contenue dans p, augmentée de sizeof (long ).

173
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2
La gestion dynamique de la mémoire
La fonction free définie dans <stdlib.h>

L’un des intérêts essentiels de la gestion dynamique est de pouvoir


récupérer des emplacements dont on n’a plus besoin. Le rôle de la
fonction free est de libérer un emplacement préalablement alloué.
Exemple :
# include < stdio .h >
# include < stdlib .h >
main () {
float * note ;
int N , k ;
float s =0;
printf ( " entrer le nombre de notes : " ) ;
scanf ( " % d " ,& N ) ;
note = malloc ( N * sizeof ( float ) ) ;
for ( k =0; k < N ; k ++) scanf ( " % f " , note + k ) ;
for ( k =0; k < N ; k ++) s = s +*( note + k ) ;
printf ( " somme des notes est :% f " ,s ) ;
free ( note ) ; /* Lib é ration de l ’é space m é moire */
} 174
Pr. S. ANTER antersamir@gmail.com Module I132 : Algorithmique et programmation 2