Les principes de l Algorithmique et de la Programmation

(1)

AHMED-NACER Messaoud – Enseignant à l’université de Boumerdès – 2016

Université M’Hamed Bougara – Boumerdès (UMBB) Faculté des sciences - Département informatique

Introduction à l’algorithmique

Les principes de l’Algorithmique et de la Programmation

Fonctions et procédures

Décembre 2015

(2)

Table des matières

1. Fonctions et procédures. ... 3

2. Les sous-programmes ... 3

2.1. Les fonctions... 4

2.1.1. Structure d’une fonction ... 4

2.1.2. Utilisation des fonctions ... 5

2.1.2.1.Fonctions SANS paramètres ... 5

2.1.2.2.Fonctions AVEC paramètres ... 8

2.1.2.3.Fonctions imbriquées ... 11

2.2. Les procédures ... 11

2.2.1. Structure d’une procédure ... 12

2.2.2. Utilisation des procédures... 12

2.2.2.1.Procédures SANS paramètres... 12

2.2.2.2.Procédures AVEC paramètres... 13

2.3. Portée des variables ... 14

2.3.1. Variables globales ... 14

2.3.2. Variables locales ... 15

2.4. Mode de passage des paramètres ... 16

2.4.1. Passage par valeur ... 16

2.4.2. Passage par adresse ... 17

(3)

1. Fonctions et procédures.

Tous les algorithmes que nous avons étudiés jusqu’à présent étaient constitués d’un seul bloc de traitement.

Au fur et à mesure que les exigences, d’un problème, progressent, la taille de l’algorithme augmente en conséquence. Ce qui augmente aussi la complexité de sa gestion et de sa compréhension.

Face à un algorithme complexe, le programmeur décompose le problème en mini-blocs ayant chacun un rôle bien précis. Ces mini-blocs sont des sous-programmes (sous algorithmes) appelés Fonction ou procédure.

Par exemple, le programme, de la gestion de la scolarité, est divisé en plusieurs sous- programmes de gestions.

2. Les sous-programmes

Un programme relativement long doit être découpé en plusieurs petits programmes, appelés

« sous-programmes ». L’utilisation de ces derniers, permet de faciliter l’écriture du programme et de comprendre son fonctionnement. De plus, ces sous-programmes permettent d’éviter de répéter l’écriture d’un même traitement dans plusieurs endroits du programme.

Les sous-programmes sont identifiés en décomposant un problème en plusieurs sous- problèmes. La solution à un sous problème donne lieu à un sous programme.

En résumé, l’utilisation des sous-programmes permet de : 1. d’améliorer la clarté des programmes

2. d’optimiser le nombre d’instructions

3. de faciliter la mise à jour et la correction des erreurs.

(4)

1. Les sous-programmes ne font pas partie du corps de l’algorithme principal.

2. A l’appel du sous-programme, l’algorithme se branche à la première instruction de celui-ci puis commence par l’exécuter.

3. A la fin de l’exécution du sous-programme, l’algorithme revient à l’instruction qui vient tout de suite après le point d’appel.

On distingue deux types de sous-programmes : 1. Les fonctions

2. Les procédures

2.1. Les fonctions

Une fonction est un algorithme, écrit en dehors du corps de l’algorithme principal d’où, le nom de sous-algorithme (sous-programme). Elle possède :

1. Un en-tête, pour préciser le nom de la fonction ;

2. Une zone de déclaration des variables, propres à la fonction (partie déclaration) ; 3. Une zone d’exécution des instructions (partie traitement).

A l’instar de toutes les fonctions mathématiques, en algorithmique, le rôle de la fonction est d’effectuer un traitement spécifique pour renvoyer un résultat.

2.1.1. Structure d’une fonction

Le rôle de la fonction est d’effectuer un calcul et de renvoyer un et seulement un résultat.

La structure d’une fonction diffère légèrement de celle du programme principal.

(5)

Fonction nomf (<paramètres>): type

Var

Listes de variables Début

instructions

nomf expression ou bien retourne ( expression )

Fin ;

C’est un sous-programme qui :

• a un nom : « nomf »

• peut avoir des paramètres : « paramètres »

• retourne une valeur d’un certain type : « type ». Comme une fonction ne retourne qu’une seule valeur, il est obligatoire d’indiquer le type de la valeur retournée.

• peut avoir besoin de variables propres à la procédure

• possède la partie traitement.

• renvoie un résultat : « nomf expression » ou bien « retourne ( expression ) »

2.1.2. Utilisation des fonctions

Les fonctions sont utilisées lorsque l’on a besoin d’écrire un sous-programme qui renvoi un seul résultat. Donc, une fonction a pour but principal d’effectuer un calcul puis de renvoyer un résultat.

Suivant la nature du problème, l’utilisation de la fonction peut se faire avec ou sans paramètres.

2.1.2.1. Fonctions SANS paramètres

Les paramètres (que nous expliquerons leurs utilisations, plus loin dans ce chapitre) permettent, à la fonction, de recevoir des éléments de calcul à partir du point d’appel de la fonction.

Les paramètres sont facultatifs. La fonction suivante permet de définir la variable « pi () ».

Cette fonction ne possède pas de paramètres. S’il n'y a pas de paramètre, les parenthèses doivent rester présentes et vides.

fonction pi(): réel ; fonction pi(): réel ;

début début

pi 3.1415926535897931 ; retourner (3.1415926535897931) ;

fin ; fin ;

1. pi : indique le nom de la fonction

2. réel : indique le type du résultat que doit retourner la fonction 3. pi 3.1415926535897931: indique le résultat qui est retourné au programme

principal

(6)

C’est deux fonctions donnent le même résultat quoiqu’elles diffèrent dans la manière de retourner le résultat.

• Le résultat, de la fonction de gauche, est retourné dans la variable-fonction

« pi », dont le nom doit être le même que celui de la fonction « pi ».

• Le résultat, de la deuxième fonction, est retourné sans passer par la variable- fonction « pi ».

Dans le corps de l’algorithme principal, l’appel à la fonction peut apparaître :

• dans une expression : circonférence 2 * pi * r

• dans une comparaison : Si x > pi alors

• à la droite d'une affectation : N pi

• etc.

L’exemple suivant montre de quelle manière on fait appel à une fonction, à partir du corps d’un algorithme. Ce dernier permet de calculer la surface et la circonférence d’un cercle.

Algorithme UtiliserUneFonction ; Var

r , circonf , surface : réel ;

// Déclaration de la fonction « pi »

fonction pi(): réel ; 1

début

pi 3.1415926535897931 ; fin ;

debut

ecrire ( ‘ Donnez la valeur du rayon ‘ ) ; 2

lire ( r ) ;

surface pi * r * r ; 3

circonf 2 * pi * r ;

ecrire ( ‘ la surface = ‘ , surface) ; ecrire ( ‘ la circonférence = ‘ , cirdonf ) ; fin .

Voyons maintenant son exécution, ligne par ligne :

1. La fonction « pi » se trouve dans la partie des déclarations. A ce moment, elle n’est pas exécutable.

2. Après la partie des déclarations, l’algorithme commence l’exécution

3. Le calcul, de la surface et de la circonférence, fait appel à la fonction pi. C'est-à-dire que « pi » sera remplacé par la valeur « 3.1415926535897931 » dans les deux expressions.

La fonction suivante permet de calculer la somme des N premiers entiers naturels et de retourner le résultat, sans recevoir des paramètres.

(7)

fonction Somme( ) : entier ; ^{1 - 2}

var

s , n , i : entier ; debut

Ecrire ( ‘ Donner la valeur de N ’ ) ; Lire ( N ) ;

s 0 ;

pour i 1 à n faire s s + I ;

Somme s ; 3

fin ;

1. Somme ( ) : indique le nom de la fonction

2. entier : indique le type du résultat que doit retourner la fonction 3. Somme s : indique le résultat qui est retourné au programme principal

En algorithmique, les fonctions et les procédures apparaissent dans la partie des déclarations, du programme principal

Algorithme UtiliserUneFonction ;

fonction Somme ( ) : entier ; 1 - 3

var

s , n , i : entier ; 4

debut

Ecrire ( ‘ Donner la valeur de n ’ ) ; 5

Lire ( n ) ; s 0 ;

pour i 1 à n faire 6

s s + i ;

Somme s ; 7

fin ; debut

ecrire(‘la somme = ‘, somme) ; 2 - 8

fin .

Voyons maintenant son exécution, ligne par ligne :

1. La fonction se trouve dans la partie des déclarations. A ce moment elle n’est pas exécutable, puisqu’elle se trouve dans la partie des déclarations.

2. Après la partie des déclarations, l’algorithme commence l’exécution à l’instruction suivante :

écrire(‘la somme = ‘, somme) ;

C’est la seule instruction de l’algorithme. Cette instruction contient l’affichage d’un commentaire « la somme = » suivie du nom de la fonction « somme ». Donc, elle fait appel à la fonction « somme ( ) ».

3. La fonction « somme ( ) » n’a pas de paramètre et elle est de type « entier ».

4. Les variables, « n, s et i », sont déclarées dans la fonction. Ce sont des variables locales appartenant à la fonction (nous allons expliquer plus loin ce qu’est une variable locale)

5. La fonction nous demande de lui donner la valeur « n », concernée par la somme 6. La boucle « i » exécute le calcul de la somme « s s + i » des N premiers entiers

naturels

(8)

7. Ce point est très important et il faut bien le comprendre. Dans ce cas, le résultat, de la fonction, est retourné dans une variable, dont le nom est obligatoirement le même que celui de la fonction.

Somme s ;

8. L’affectation du résultat dans la variable qui porte le même nom que la fonction, termine, automatiquement, l’exécution de cette dernière et retourne au point d’appel.

C'est-à-dire à l’instruction « écrire(‘la somme = ‘, somme) ; » pour afficher le résultat final

2.1.2.2. Fonctions AVEC paramètres

Les paramètres permettent au programme principal d’envoyer, à la fonction, des données et des informations. Ces paramètres sont nécessaires à la fonction pour qu’elle effectue un calcul et renvoie un résultat.

On distingue deux types de paramètres :

• Les paramètres formels : Ce sont les variables déclarées pendant la déclaration du sous-programme.

• Les paramètres effectifs : Ce sont les valeurs des variables envoyées au sous- programme durant l’appel de celui-ci.

L’exemple suivant montre comment utiliser des paramètres avec la fonction qui calcule le carré d’un nombre quelconque.

Fonction carrée(n : entier): entier ; Début

Carrée n * n fin ;

La fonction « carrée » reçoit une valeur dans le paramètre formel « n » de type « entier ».

Bien sûr, la valeur retournée par la fonction « carré » est aussi de type « entier ».

La valeur reçue, par le paramètre formel « n », est envoyée, à partir du programme principal, lors de l’appel de la fonction.

Algorithme param ; Var

x, y : entier ;

Fonction fcarrée(n : entier): entier ; Début

fcarrée n * n ; fin ;

Début

Ecrire ( ‘ Donnez une valeur ’ ) ; Lire (x)

Ecrire( ‘ le carré de ‘ , x , ‘ = ‘ , fcarrée ( x ) ) ; 1

y fcarrée ( x ) 2

Ecrire( ‘ le carré de ‘ , x , ‘ = ‘ , y ) ; Fin

(9)

Une fonction est manipulée comme une variable simple. Cet algorithme fait appel à la fonction « fcarrée » à deux reprises :

1. L’instruction d’affichage fait appel à la fonction « fcarrée » en lui envoyant la valeur du paramètre effectif « x ». La fonction :

• reçoit la valeur de « x » dans son paramètre formel « n »,

• calcule le carré de « n »

• renvoie le résultat à l’instruction d’affichage du programme principal pour l’afficher. Le résultat est renvoyé dans le nom de la fonction

• « fcarrée n * n ; »

2. Le nom de la fonction apparaît, toujours et une seule fois, dans la fonction pour recevoir le résultat final.

3. L’instruction d’affectation fait appel à la fonction « fcarrée » en lui envoyant la valeur du paramètre effectif « x ». La fonction :

• reçoit la valeur de « x » dans son paramètre formel « n »,

• calcule le carré de « n »

• renvoie le résultat à l’instruction d’affectation du programme principal pour l’affecter à la variable « y ». Le résultat est renvoyé dans le nom de la fonction

« fcarrée n * n ; ».

La fonction est utilisée comme une variable par les instructions :

• d’affectation « …….» (partie expression, à droite du signe d’affectation),

• d’affichage ( écrire ),

• de test ( si, tant que, répéter ).

La fonction ne peut pas être utilisée par les instructions :

• de lecture ( lire ),

• d’affectation « …….. » (partie variable, à gauche du signe d’affectation).

Une fonction est un sous-programme qui retourne toujours un et seulement un seul résultat.

L’exemple suivant montre comment faire appel à une fonction qui renvoie la valeur absolue d’un réel.

(10)

Algorithme absolue ; Var

x, y : réel ;

Fonction fabs( a : réel ) : réel ; z : réel ;

Début

si z >= 0 alors z a sinon

z - a ; fabs z ; fin ;

Début

Ecrire ( ‘ Donnez une valeur ’ ) ; Lire (x)

y fabs ( x )

Ecrire( ‘ la valeur absolue de ‘ , x , ‘ = ‘ , y ) ; Fin

L’exemple suivant montre une fonction qui reçoit, comme paramètre, un vecteur et le vérifie s’il est trié par ordre croissant.

Pour faire, la fonction va comparer chaque élément du vecteur qui devrait être inférieur à l’élément suivant.

Algorithme vecteur ; Var

V : tableau [ 1 .. 50 ] de entier ; i , n : entier ;

Fonction fvectrié ( T: Tableau [ 1 .. 50 ] de entier): Booléen Var

rep : booléen Début

rep Vrai

pour i 1 à n faire Si T[ i ] > T[ i + 1 ] alors

début

rep Faux

i n /* Pour sortir de la boucle. « i = n » ensuite il deviendra « i = n + 1 » */

fin ; fvectrié rep ; Fin ;

Début

…………

Ecrire ( ‘ Donnez la taille du vecteur ‘ ) ; Lire ( n ) ;

Pour i 1 à n faire Debut

Ecrire ( ‘ donnez le ‘ , i , ‘ ème élément du vecteur ‘ ) ; Lire( V [ i ] ) ;

Fin ;

Si fvectrié ( V ) = Vrai Alors Ecrire( ‘ Le vecteur V est triè ‘ ) Sinon

Ecrire( ‘ Le vecteur V est non-triè ‘ ) ; Fin ;

Fin.

(11)

Ce que l’on remarque dans cet algorithme :

• L’appel de la fonction se fait dans une action de test.

• Le type du paramètre formel « T: Tableau [ 1 .. 50 ] » est « entier », alors que celui de la fonction est « booléen ».

2.1.2.3. Fonctions imbriquées

En algorithmique, il est possible qu’une fonction fasse appel à une fonction. On parle alors de fonctions imbriquées.

L’exemple suivant montre comment une fonction fait appel à une autre fonction pour lui demander de faire un calcul et de lui retourner un résultat pour qu’elle fasse, elle aussi, un autre calcul et retourner un autre résultat.

Soit la fonction qui détermine le maximum entre deux valeurs :

fonction maxi_2 (x , y : réel) : réel ; var

max : réel ; début

si x >= y alors max x sinon

max y ; maxi_2 max ; fin ;

Pour trouver le maximum entre trois variables, il n’est pas nécessaire d’écrire une autre fonction « maxi_3 » qui ressemble à la fonction « maxi_2 » en utilisant trois valeurs.

Pour faire, la fonction « maxi_3 » fera appel, à deux reprises, à la fonction « maxi_2 ».

fonction maxi_3 (x , y, z : réel) : réel ; début

max_3 max_2 ( x , max_2 ( y , z ) ) ; fin ;

De quelle manière le maximum, entre trois valeurs, sera calculé ?

• La première fonction qui sera exécutée est celle qui se trouve dans la parenthèse

« max_2(y , z) ». Elle renvoie le maximum « max » entre les deux variables « y et z ».

• Ensuite, la deuxième fonction « max_2(x , max_2(y , z)) » sera transformée en la fonction « max_2 ( x , max ) » pour renvoyer le maximum final.

2.2. Les procédures

Une procédure est aussi un sous-programme, au même titre que la fonction. La différence est qu’une procédure peut retourner plusieurs résultats comme elle peut ne pas retourner un résultat.

Une procédure peut retourner un résultat. Dans ce cas, on peut la transformer en une fonction.

La déclaration et le corps de la procédure sont identiques à celle de la fonction. Elle possède :

(12)

1. Un en-tête, pour préciser le nom de la procédure ;

2. Une zone de déclaration des variables, propres à la procédure (partie déclaration) ; 3. Une zone d’exécution des instructions (partie traitement).

2.2.1. Structure d’une procédure

Le rôle de la procédure est d’effectuer un traitement spécifique et, peut-être, de retourner plusieurs résultats.

La structure d’une procédure diffère légèrement de celle d’une fonction.

Procédure nomp (<paramètres>) ; Var

Listes de variables ; Début

Instructions ; Fin ;

C’est un sous-programme qui : 1. a un nom : « nomp »

2. peut avoir des paramètres : « paramètres »

3. peut ne pas retourner une valeur comme elle peut retourner plusieurs résultats de types différents. il n’est donc pas nécessaire d’indiquer le type des résultats retournés.

4. peut avoir besoin de variables propres à la procédure 5. possède la partie traitement.

2.2.2. Utilisation des procédures

Les procédures sont utilisées lorsque l’on a besoin d’écrire un sous-programme qui ne retourne aucun résultat ou bien qui retourne plusieurs résultats.

Suivant la nature du problème, l’utilisation de la procédure peut se faire avec ou sans paramètres.

2.2.2.1. Procédures SANS paramètres

Les paramètres sont facultatifs. S’il n'y a pas de paramètre, les parenthèses doivent rester présentes et vides.

L’exemple suivant montre comment la fonction, vue en section 2.1.2.1, peut-être écrite sous forme d’une procédure. Cette procédure ne possède pas de paramètres.

(13)

Algorithme UtiliserUneprocédure ; var

s , n , i : entier ;

procedure Somme ( ) ; debut

Ecrire ( ‘ Donner la valeur de n ’ ) ; Lire ( n ) ;

s 0 ;

pour i 1 à n faire s s + i ;

ecrire(‘la somme = ‘, somme) ; fin ;

debut

somme ( ) ; fin .

L’appel de la procédure est différent de celui de la fonction. La procédure ne peut pas être utilisée comme une variable. Pour cela, l’appel à la procédure se fait directement, par son nom « somme ( ) ».

• Une procédure ne retourne pas de valeur dans le nom de la procédure, comme le fait la fonction

• Il est donc faux de la considérer comme une variable. Il est faux d’écrire, par exemple, j somme ( ).

• elle ne peut pas être utilisée dans les instructions : - De lecture

- D’écriture - De test - D’affectation

L’algorithme suivant fait appel à une procédure qui souligne un titre, donné par l’utilisateur.

Cette procédure ne possède pas de paramètres.

Algorithme psansp var

titre : chaine ; i : entier ;

procedure souligne( ) ; début

pour i 1 à 20 faire écrire ( " --- " ) ; fin ;

début

ecrire ( ‘ Donnez le titre : ‘ ) ; lire (titre) ;

souligne( ) ; 1

fin ;

2.2.2.2. Procédures AVEC paramètres

Les paramètres peuvent être utilisés avec des paramètres (effectifs et formels).

L’exemple suivant montre une procédure qui utilise un paramètre de type « chaîne » pour afficher des messages d’erreurs.

(14)

Algorithme pavecp var

i : entier ;

procedure souligne( ) ; début

pour i 1 à 20 faire debut

ecrire ( ‘ Le programme a rencontré une erreur : ‘ ) ; écrire ( " --- " ) ;

fin ; fin ;

procedure aff_err ( messg: chaine) debut

souligne ( ) ; ecrire ( messg ) ; fin ;

debut ... ;

aff_err ( ‘ Entier trop grand ‘ ) ; ... ;

aff_err ( ‘ Mémoire insuffisante ‘ ) ; ... ;

aff_err ( ‘ Fin de fichier rencontré ‘ ) ; ... ;

Fin.

Cet algorithme fait appel à la procédure « aff_err » qui reçoit comme paramètre, une chaine de caractère pour l’afficher. la procédure « aff_err » fait appel, aussi, à une autre procédure

« souligne » pour afficher le titre du message et le souligne en même temps.

2.3. Portée des variables

L’échange d’informations entre le programme principal et les sous-programmes peut se faire sans avoir à utiliser des paramètres. Il s’agit de déclarer des variables pour qu’elles soient utilisées directement dans un sous-programme sans avoir besoin de les transmettre sous forme de paramètres.

La portée d'une variable montre jusqu’où cette variable est connue par les sous- programmes. C'est-à-dire, qu’elles sont les sous-programmes qui peuvent l’utiliser sans qu’elle soit transmise sous forme de paramètre.

Il existe deux types de portées des variables : 1. variables globales

2. variables locales

2.3.1. Variables globales

Toute variable déclarée dans le programme principal est dite globale et elle est lisible et utilisable par tous les sous-programmes. Toute variable globale peut être utilisée par un sous-programme sans qu’elle soit déclarée dans celui-ci.

L’exemple suivant, qui vérifie si un tableau est trié (section 2.1.2.2.), montre comment la procédure « fvectrié » utilise les deux variables globales « i et n » dans la boucle « pour » sans les envoyer dans les paramètres d’appel :

(15)

V : tableau [ 1 .. 50 ] de entier ; i , n : entier ;

Fonction fvectrié ( T: Tableau [ 1 .. 50 ] de entier): Booléen Var

rep : booléen Début

rep Vrai

pour i 1 à n faire Si T[ i ] > T[ i + 1 ] alors

début

rep Faux

i n /* Pour sortir de la boucle. « i = n » ensuite il deviendra « i = n + 1 » */

fin ; fvectrié rep ; Fin ;

Début

…………

Ecrire ( ‘ Donnez la taille du vecteur ‘ ) ; Lire ( n ) ;

Pour i 1 à n faire Debut

Ecrire ( ‘ donnez le ‘ , i , ‘ ème élément du vecteur ‘ ) ; Lire( V [ i ] ) ;

Fin ;

Si fvectrié ( V ) = Vrai Alors Ecrire( ‘ Le vecteur V est triè ‘ ) Sinon

Ecrire( ‘ Le vecteur V est non-triè ‘ ) ; Fin ;

Fin.

Puisque les variables « i et n » sont globales, il n’est pas nécessaire de les transmettre sous forme de paramètres effectifs à la procédure ou de les déclarer dans celle-ci.

On peut se poser la question suivante : pourquoi ne pas déclarer toutes les variables globales et d’un coup on n’a pas besoin d’utiliser les paramètres ?,

Les variables globales sont gourmandes en ressources mémoire. Elles restent présentes dans la mémoire centrale jusqu’à la fin de l’exécution de tout le programme.

Pour économiser de la ressource mémoire, il faut déclarer le minimum possible de variables globales. Pour les variables utilisables que dans des sous-programmes, on fait appel à des variables locales.

2.3.2. Variables locales

Toute variable déclarée dans un sous-programme est dite locale à celui-ci. Elle n’est lisible et utilisable que dans le bloc (sous-programme) où elle est déclarée.

Par contre, la variable locale devient globale pour les sous-programmes appelés par le sous- programme où elle est déclarée.

Elle reste présente dans la mémoire centrale jusqu’à la fin de l’exécution du sous- programme où elle est déclarée.

Remarque : Si on déclare, dans un sous-programme, une variable locale (par exemple :

« x » ) dont le nom est identique à une variable globale (par exemple : « x » ), cette dernière devient invisible dans le sous-programme. C’est la variable locale qui devient lisible et utilisable dans le sous-programme où elle est déclarée.

(16)

2.4. Mode de passage des paramètres

Il existe deux modes de passage des paramètres aux sous-programmes : 1. Passage par valeur

2. Passage par référence

2.4.1. Passage par valeur

Le passage par valeur est le passage par défaut. Lorsqu’on fait appel à une procédure avec des paramètres effectifs, la procédure appelée reçoit une copie des valeurs et les affecte aux paramètres formels. Ces derniers n’utiliseront, dans le sous-programme, que la valeur de la variable correspondante.

Si, dans le sous-programme, on modifie la valeur du paramètre formel, la valeur du paramètre effectif correspondant reste inchangée. À la fin de l’exécution du sous- programme, la variable conservera sa valeur initiale.

L’exemple suivant illustre le passage par valeur :

a , b : entier ;

procédure calcul ( x , y : entier ) Var

z : entier ; Début

Ecrire ( ‘ Donnez la valeur de z ‘ ) ; Lire ( z ) ;

Si z >= 0 alors debut

x z + y ; y z * z ; fin

Sinon debut

y z – x ; x y * y ; fin ;

Ecrire ( ‘ Dans le sous-programme « calcul » ‘ ) ; Ecrire ( ‘ x = ‘ , x , ‘ et y = ‘ , y ) ;

fin ; Début

Ecrire ( ‘ Donnez la valeur de a ‘ ) ; Lire ( a ) ;

Ecrire ( ‘ Donnez la valeur de b ‘ ) ; Lire ( b ) ;

Ecrire ( ‘ Avant de faire appel au sous-programme « calcul » ‘ ) ; Ecrie ( ‘ a = ‘ , a , ‘ et b = ‘ , b ) ;

Calcul ( a , b ) ;

Ecrire ( ‘ Au retour du sous-programme « calcul » ‘ ) ; Ecrie ( ‘ a = ‘ , a , ‘ et b = ‘ , b ) ;

Fin.

(17)

Si on exécute le programme avec les valeurs suivantes:

a = 10 b = 20 z = 5

Les variables se comporteront, dans la mémoire centrale, comme suit :

- La modification de la valeur des paramètres formels « x et y » n’affecte pas la valeur des paramètres effectifs « a et b ».

- A la fin (au retour) du sous- programme « calcul », les variables locales, « x, y et z », sont supprimées de la mémoire centrale.

Si on veut qu'un sous-programme modifie les paramètres effectifs, il faut utiliser le « passage par adresse ».

2.4.2. Passage par adresse

Le passage par adresse consiste à envoyer aux sous-programmes l’adresse (l’emplacement dans la mémoire centrale) du paramètre effectif, où, le paramètre formel, peut manipuler directement sa valeur.

Si, dans le sous-programme, on modifie la valeur du paramètre formel, la valeur du paramètre effectif changera aussi. C’est-à-dire que le paramètre formel du sous-programme accède directement à l’adresse du paramètre effectif.

Pour préciser qu’un paramètre est envoyé par adresse, on place, avant le nom du paramètre formel, le mot-clé « var ».

Soit l’exemple précédent où le passage se fait par adresse pour la variable « a » : Avant l’appel du

Sous-programme

« calcul »

a b 10 20

A l’exécution du Sous-programme

« calcul »

a b 10 20 5 z 25 x 25 y

Au retour du Sous-programme

« calcul »

a b 10 20 A l’appel du

Sous-programme

« calcul »

a b 10 20 10 x 20 y

Le programme affichera sur l’écran Donnez la valeur de a

10

Donnez la valeur de b 20

Avant de faire appel au sous-programme « calcul » a = 10 et b = 20

Donnez la valeur de z 5

Dans le sous-programme « calcul » x = 25 et y = 25

Au retour du sous-programme « calcul » a = 10 et b = 20

(18)

a , b : entier ;

procédure calcul (

var

x : entier , y : entier ) Var

z : entier ; Début

Ecrire ( ‘ Donnez la valeur de z ‘ ) ; Lire ( z ) ;

Si z >= 0 alors debut

x z + y ; y z * z ; fin

Sinon debut

y z – x ; x y * y ; fin ;

Ecrire ( ‘ Dans le sous-programme « calcul » ‘ ) ; Ecrire ( ‘ x = ‘ , x , ‘ et y = ‘ , y ) ;

fin ; Début

Ecrire ( ‘ Donnez la valeur de a ‘ ) ; Lire ( a ) ;

Ecrire ( ‘ Donnez la valeur de b ‘ ) ; Lire ( b ) ;

Ecrire ( ‘ Avant de faire appel au sous-programme « calcul » ‘ ) ; Ecrie ( ‘ a = ‘ , a , ‘ et b = ‘ , b ) ;

Calcul ( a , b ) ;

Ecrire ( ‘ Au retour du sous-programme « calcul » ‘ ) ; Ecrie ( ‘ a = ‘ , a , ‘ et b = ‘ , b ) ;

Fin.

Si on exécute le programme avec les valeurs suivantes:

a = 10 b = 20 z = 5

Les variables se comporteront, dans la mémoire centrale, comme suit :

Avant l’appel du Sous-programme

« calcul »

a b 10 20

A l’exécution du Sous-programme

« calcul »

b 25 20 5 z 25 y

Au retour du Sous-programme

« calcul »

a b 25 20 A l’appel du

Sous-programme

« calcul »

a b 10 20

x

20 y

a x

(19)

Le schéma ci-dessus montre que le paramètre formel « x » s’est substitué au paramètre effectif « a » durant l’exécution du sous-programme.

- La modification de la valeur du paramètre formel « y » n’affecte pas la valeur du paramètre effectif « b ».

- Comme le passage paramètre effectif « x » s’est fait par adresse, la modification de la valeur du paramètre formel correspondant « x

» affecte directement la valeur de

« a ».

- A la fin (au retour) du sous- programme « calcul », les variables locales, « x, y et z », sont supprimées de la mémoire centrale.

Note :

Les tableaux, les fichiers et les listes (voir plus loin dans ce cours) sont toujours passés par adresse (par défaut).

Le programme affichera sur l’écran Donnez la valeur de a

10

Donnez la valeur de b 20

Avant de faire appel au sous-programme « calcul » a = 10 et b = 20

Donnez la valeur de z 5

Dans le sous-programme « calcul » x = 25 et y = 25

Au retour du sous-programme « calcul » a =

25

et b = 20

(20)

Introduction à l’algorithmique

Les principes de l’Algorithmique et de la Programmation

Les enregistrements

Décembre 2015

(21)

1. Les enregistrements : ... 3

2. Utilisation d'un enregistrement ... 3

3. L'imbrication d'enregistrements ... 5

4. Les tableaux d’enregistrement ... 7

(22)

1. Les enregistrements :

Comme les tableaux, un enregistrement est défini comme une structure de données permettant de faciliter la manipulation des données. Les éléments d’un enregistrement, peuvent être de type différent, contrairement à ceux d’un tableau, qui doivent être de même type.

Un enregistrement est un « type-utilisateur ». C'est l’utilisateur qui le définit avec le mot

« type ». Pour utiliser cet enregistrement, les variables de type « enregistrement » sont déclarées de la même manière que les variables de type prédéfinis (entier, reel, chaine,…).

2. Utilisation d'un enregistrement

Un enregistrement est subdivisé en plusieurs champs. Il est exploité à travers la variable de type « enregistrement » et ses champs. Le rôle d’un champ est de véhiculer une partie de l’information contenue dans un enregistrement. Il est défini par un « nom » et son « type ».

L’exemple suivant montre la déclaration d’un type enregistrement dont le nom est

« etudiant » et d’une variable « e » de type enregistrement Algorithme test ;

type

etudiant = enregistrement matricule : chaîne ; nom : chaîne ; prenom : chaîne ; groupe : entier ; note : Réel ; Fin ;

Var

e : etudiant ; Debut

……..

Fin.

La figure ci-dessous illustre l’enregistrement « etudiant ».

- L’enregistrement « etudiant » est composé de cinq champs, de différents types.

- La variable « e » est de type « etudiant ».

Donc, l’ordinateur va déclarer cinq (5) variables. Il va réserver, dans la RAM, cinq (5) cases mémoires pour la variable « e ».

Si l’accès à un élément d’un tableau se fait à travers son indice ( V [ 2 ] ), l’accès à un élément d’un enregistrement se fait à travers le nom du champ. Le nom d’une variable sera composé du nom de la variable « e » et d’un champ de l’enregistrement « etudiant », séparés par un point.

La variable « e » de type enregistrement « etudiant » se présentera dans la RAM comme suit :

Nom Prenom Groupe Note

Etudiant

Matricule

(23)

Exemple :

- e1.matricule = ‘ Z102312 ’ - e1.nom = ‘ BENKACI ’ - e1.prenom = ‘ Kaci ’ - e1.groupe = 5 - e1.note = 12.50

Le type enregistrement doit être déclaré avant la déclaration des variables. Dans la partie

« déclaration », un algorithme doit suivre la structure suivante.

Algorithme nom ; constantes types variables

procédures et fonctions début

traitements ; fin.

L’algorithme suivant permet de saisir les informations de deux étudiants puis, d’afficher celui qui possède la meilleure note.

Algorithme MeilleureNote ; Type

etudiant : enregistrement matricule : chaîne ; nom : chaîne ; prenom : chaîne ; groupe : entier ; note : réel ; Fin ;

Var

e1, e2 : etudiant Début

Ecrire ( ‘ Donner les informations du 1er étudiant ’ ) ;

Lire ( e1.matricule, e1.nom, e1.prenom, e1.groupe, e1.note ) ; Ecrire ( ‘ Donner les informations du 2ème étudiant ’ ) ; Lire ( e2.matricule e2.nom, e2.prenom, e2.groupe, e2.note ) ;

e.matricule e.nom e.prenom e.groupe e.note R A M

Les 5 cases mémoires de la variable « e » de type « etudiant »

(24)

Ecrire ( ‘ La plus grande note est celle de l’étudiant : ‘ ) ; Ecrire (e1.matricule, e1.nom , e1.prenom, e1.groupe ) Sinon

Si ( e1.note < e2.note ) alors

Ecrire ( ‘ La plus grande note est celle de l’étudiant : ‘ ) ; Ecrire (e2.matricule, e2.nom , e2.prenom, e2.groupe ) Sinon

Ecrire ( ‘ Les deux notes sont égales ‘ ) ; Fin.

Les champs sont manipulés de la même manière que les variables ou les éléments d’un tableau.

3. L'imbrication d'enregistrements

Il est possible d’ajouter un autre champ dans l’enregistrement « etudiant » pour indiquer la date de naissance de l’étudiant. Ce dernier champ peut être lui-même de type d’un autre enregistrement.

La date de naissance est composée de trois informations : - Le jour

- Le mois - L’année

Donc, il va falloir définir un autre enregistrement « date » composé des trois champs :

Type

Date = enregistrement jour : entier ; mois : entier ; annee : entier ; fin ;

etudiant : enregistrement matricule : chaîne ; nom : chaîne ; prenom : chaîne ; d_n : date ; groupe : entier ; note : réel ; Fin ;

Var

e : etudiant ;

Dans ce cas, l’enregistrement « etudiant » aura la configuration suivante :

Etudiant

Matricule

d_n

Mois Annee Date

Jour

(25)

Le nom d’une variable, de la date de naissance, sera composé du nom de la variable « e », du champ « d_n » de l’enregistrement « etudiant » et d’un champ de l’enregistrement

« date », séparés par des points.

Autrement dit, pour accéder à un champ de la date de naissance « d_n » d’un étudiant, on doit faire appel, deux fois, à l’opérateur « . ». Le premier « . » lie la variable « e1 » avec le champ « d_n » de la structure « etudiant » et le deuxième point « . » lie le tous avec le champ de la structure « date ».

- e . d_n . jour - e . d_n . mois - e . d_n . annee

Pour accéder à un champ de la date de naissance « d_n » d’un étudiant, on doit faire appel, deux fois, à l’opérateur « . ». Le premier point unit la variable « e » avec le champ « d_n » de la structure « etudiant » et le deuxième point unit, à son tour, avec le champ de la structure

« date ».

Astuce :

Pour s’assurer que l’écriture, du nom de la variable, est correcte, lisez-le de droite à gauche : - e . d_n . jour : le jour de la date de naissance de l’étudiant e

- e . d_n . mois : le mois de la date de naissance de l’étudiant e - e . d_n . annee : l’année de la date de naissance de l’étudiant e

Les enregistrements peuvent être imbriqués sans limites. On peut, par exemple, ajouter : - Un autre champ dans l’enregistrement « etudiant » pour indiquer l’adresse de

l’étudiant.

- Un autre champ dans l’enregistrement « date » pour indiquer le lieu de naissance e . matricule

e . nom e . prenom e . groupe e . note R A M

Les 8 cases mémoires de la variable « e » de

type « etudiant » e . d_n . jour

e . d_n . mois e . d_n . annee

Les 3 cases mémoires du champ « d_n » de

type « date »

(26)

L’adresse et le lieu de naissance sont, tous les deux, composés des mêmes champs suivants :

- le numéro - la rue

- le code postal - la ville

- le numéro de la wilaya

Donc, il va falloir définir un autre enregistrement « adresse » composé des cinq champs : Type

Adresse = enregistrement numero : entier ; rue : chaîne ; code_post : chaîne ; ville : chaîne ; wilaya : entier ; fin ;

Date = enregistrement jour : entier ; mois : entier ; annee : entier ; lieu_n : chaîne ; fin ;

etudiant : enregistrement matricule : chaîne ; nom : chaîne ; prenom : chaîne ; d_n : date ; adrs : chaîne ; groupe : entier ; note : réel ; Fin ;

Var

e : etudiant ;

Pour utiliser la variable qui indique la ville du lieu de naissance de l’étudiant « e », on utilise trois points « . », tout en paraphrasant comme suit:

La ville « ville » du lieu « lieu_n » de naissance « d_n » de l’étudiant « e » - E . d_n . lieu_n . ville

4. Les tableaux d’enregistrement

La manipulation de plusieurs variables, de type enregistrement, devient pénible lorsqu’il s’agit de traiter plusieurs étudiants à la fois. L’utilisation des tableaux rendra plus facile cette manipulation.

Comme les éléments, d’un tableau, doivent être tous de même type, ils seront déclarés, dans ce cas, comme type « enregistrement ». Les éléments, du tableau, auront tous, le même type « etudiant » où, les champs peuvent être de types différents.

(27)

Exemple : Type

Var

e : tableau [ 1 .. 50 ] de etudiant

Ceci donnera un tableau où les lignes représentent les enregistrements et les colonnes représentent les champs, comme le montre la figure suivante :

ATTENTION : à ne pas confondre avec une matrice.

- Le tableau est un vecteur composé de 50 éléments - L’enregistrement « etudiant » est composé de 5 champs.

La déclaration de la variable « e » va donc, créer, dans la RAM, 50 x 5 cases de mémoires.

Soit 250 cases mémoires.

Matricule 1

2 3 4 5 6 7 8

Enregistrements

Champs

(28)

De la même manière que la variable simple, pour accéder à un champ du tableau, on utilise un point entre le nom de l’élément du tableau et le nom du champ concerné.

Exemple : Remplir un tableau avec les renseignements et la note des étudiants : Algorithme note ;

Type

Var

e : tableau [ 1 .. 50 ] de etudiant Début

Ecrire ( ‘ Donner le nombre des étudiants ‘ ) ; Lire ( N ) ;

Pour i 1 à N faire Début

Ecrire ( ‘ Donner les informations du ‘ , i , ‘ étudiant ’ ) ;

Lire ( T[ i ].matricule, T[ i ].nom, T[ i ].prenom, T[ i ].groupe, T[ i ].note ) ; Fin ;

Fin.

e [ 0 ] . matricule R A M

Les 250 cases mémoires de la variable « e » de type

« etudiant » e [ 0 ] . nom

e [ 0 ] . prenom e [ 0 ] . groupe e [ 0 ] . note e [ 1 ] . matricule e [ 1 ] . nom e [ 1 ] . prenom

…………..

e [ 49 ] . groupe e [ 49 ] . note

(29)

Introduction à l’algorithmique

Les principes de l’Algorithmique et de la Programmation

Les fichiers

Décembre 2015

(30)

1. Les fichiers. ... 3 1.1. Définition d’un fichier ... 3 1.2. Structuration d’un fichier ... 3 1.2.1. Fichier de données ... 3 1.2.2. Fichier texte ... 3 1.2.3. Fichier binaire ... 4 1.3. Organisation et accès ... 4 1.3.1. Accès séquentiel ... 4 1.3.1.1.Mode « écriture » ... 5 1.3.1.2.Mode « lecture » ... 6 1.3.1.3.Mode « ajout » ... 7 1.4. Utilisation des fichiers ... 9 1.4.1. Fichier texte ... 9 1.4.1.1.Mode « ECRITURE » : saisie d’une donnée simple. ... 10 1.4.1.2.Mode « LECTURE » : lecture et affichage d’une donnée simple. ... 11 1.4.1.3.Mode « AJOUT » : ajout d’une donnée simple. ... 11 1.4.1.4.Modification d’une donnée ... 12 1.4.2. Fichier structuré ... 14 1.4.2.1.Saisie dans un fichier structuré ... 14 1.4.2.2.Saisie de plusieurs variables-chaines ... 15 1.4.2.3.Saisie d’une donnée de type « enregistrement » ... 16

(31)

1. Les fichiers.

Jusqu’à présent nous n’avons utilisé que des variables et des tableaux pour manipuler les données. Comme ils sont créés au niveau de la mémoire vive (RAM : mémoire de travail), ils sont volatils. Donc, les données et les informations, qu’ils contiennent, disparaissent à la fin de l’exécution du programme. De plus, la RAM s’efface totalement après avoir éteint l’ordinateur.

Des fois, dans certaines applications, on a besoin de conserver des informations, d’une manière pérenne, après l’exécution du programme. Par exemple sur des supports externes, tel que le disque dur, le CD-Rom et autres.

Supposons que l’on veuille enregistrer les notes des étudiants, ainsi que leur nom, prénom, date de naissance, etc. dans des tableaux. Allons-nous saisir au clavier ces données à chaque exécution du programme ? Bien sûr que non. De plus, avec ce type de stockage, il est impossible de procéder à des consultations puisque les données seront supprimées de la mémoire à la fin de l’exécution du programme.

Le fichier est la structure de données, qui permet d’enregistrer les données, d’une manière permanente, afin de permettre une réutilisation ultérieure des informations qu’il contient.

1.1. Définition d’un fichier

Un fichier est une entité, constituée d’un ensemble d’informations stockées sous forme d’enregistrements de même type. Il permet de résoudre le problème de sauvegarde des données, d’une façon permanente, même après l’exécution du programme.

Les données, enregistrées dans un fichier, sont stockées sur des mémoires externes à la mémoire centrale (RAM), tel que le disque dur, la bande magnétique, le CD-ROM etc. Ces données sont persistantes, car elles ne s’effacent pas après exécution du programme ou après avoir éteint l’ordinateur. Elles peuvent être réutilisées à tout moment par les programmes informatiques (ajout, modification, suppression, consultation).

Etant sauvegardé sur des supports externes, la capacité de stockage du fichier est beaucoup plus importante que celle des structures de données qui sont créées dans la mémoire de travail ; la RAM.

1.2. Structuration d’un fichier

En général, on distingue trois types de rangement des données dans un fichier :

• Les fichiers de données

• Les fichiers textes

• Les fichiers binaires 1.2.1. Fichier de données

Ce sont des fichiers binaires typés, qui sont basés sur des structures de données (voir base de données).

1.2.2. Fichier texte

Ce type de fichier, dit structuré, contient des informations structurées sous forme d’enregistrements, où il ne peut contenir que des données de type « texte ».

Les données sont enregistrées, ligne par ligne, sous forme d’une suite de caractères représentés par leur code ASCII. Chaque ligne se termine par le caractère « fin de ligne ».

Chaque octet représente un caractère. Même les chiffres numériques sont représentés par le code ASCII.

(32)

Par exemple, le mot « Ecrire » sera enregistré dans un fichier texte comme suit : Texte : E c r i r e

Données enregistrées : 069 099 114 105 114 101

Ce type de fichier est dit lisible car vous pouvez écrire et lire un fichier texte avec n’importe quel éditeur de texte, ce qui n’est pas possible avec les fichiers binaires.

1.2.3. Fichier binaire

Ce type de fichier contient des données, non textuelles, sous forme d’une suite d’octets non structurés. C'est-à-dire, qu’il n’est pas organisé sous forme d’enregistrement. Il ne possède aucune donnée élémentaire.

Exemple de fichier : son (.mp3), image (.jpg), exécutable (.exe),….

Ces fichiers ne peuvent être lus qu’avec l’aide d’une application spécifique :

• Lecteur mp3 pour les fichiers « son »

• Le MS-Paint pour ouvrir les images

• Le MS-Wword pour les fichiers .doc…

1.3. Organisation et accès

Le seul inconvénient avec les fichiers, les données sont enregistrées sur des supports externes à la mémoire centrale. On ne peut accéder aux données directement comme on le fait avec les variables et les tableaux.

L’accès aux données, stockées dans un fichier, est déterminé suivant la manière dont sont organisées ces données dans le fichier. On distingue trois types d’accès aux données qui permettent de lire les données stockées dans les fichiers.

• Accès séquentiel

• Accès direct

• Accès séquentiel indexé 1.3.1. Accès séquentiel

Dans un ordinateur, les entrées/sorties entre la mémoire centrale et les différents périphériques se font en utilisant les fichiers de type séquentiel. Ces fichiers renferment des données de type identique.

L’accès séquentiel, comme son nom l’indique, permet de traiter les données séquentiellement, dans l’ordre de leur stockage dans le fichier. C’est-à-dire que :

- Les données sont enregistrées, consécutivement, dans l’ordre de leur stockage - Pour lire une information, il faut d’abord avoir lu toutes les informations qui la

précèdent. Pour lire l’enregistrement « N » il faut d’abord lire les « N-1 » enregistrements qui le précèdent.

Par exemple, tous les fichiers enregistrés sur des bandes magnétiques ou, anciennement, les cassettes sont des fichiers de type séquentiel.

Pour travailler avec un fichier, il faut d’abord l’ouvrir. L’ouverture d’un fichier veut dire charger le fichier physique, enregistré sur un support auxiliaire, dans la mémoire centrale pour l’utiliser.

(33)

Un fichier séquentiel ne peut pas être ouvert en lecture et en écriture en même temps. Il ne peut être ouvert que dans l’un de ces trois modes:

• Mode écriture

• Mode lecture

• Mode ajout

1.3.1.1. Mode « écriture »

Le « mode écriture » permet de stocker des données et des informations dans un fichier.

L’ouverture d’un fichier séquentiel en « mode écriture » s’apparente à la création d’un fichier :

• Si le fichier n’existe pas, il sera automatiquement créé.

• Si le fichier existe, il sera vidé de son contenu et deviendra un nouveau fichier.

• Tout fichier se termine par un octet qui représente la marque de « fin de fichier (End Of File – EOF) ». Ce caractère est transparent pour le programmeur.

A l’ouverture du fichier :

- Le fichier sera chargé dans la mémoire centrale et l’ordinateur lui attribuera un pointeur qui se positionne automatiquement au début (fichier vide). Le rôle du pointeur est d’indiquer la position de la prochaine écriture (stockage) dans le fichier. Il représente la tête d’écriture.

- En « mode écriture » le pointeur se positionne toujours sur la marque de « fin du fichier ».

- Chaque ligne enregistrée dans le fichier se termine par un octet qui représente la marque de « fin de ligne (End Of Line – EOL)»

- On ne peut qu’écrire dans un fichier ouvert en « mode écriture ».

Schématisons maintenant comment se comporte le fichier ouvert en « mode écriture » 1. Ouvrir le fichier en « mode écriture » donnera la configuration suivante :

2. Ecrire la phrase « Je suis au début du fichier » dans le fichier fera avancer la marque de « fin de fichier » vers le bas :

Lorsque l’ordinateur écrit une donnée dans le fichier, il ajoute, à la fin de la donnée, la marque de « fin de ligne ».

Je suis au début du fichier

EOF

EOL

Une information

La marque de « fin de ligne » Début du fichier représenté par la marque de « fin de fichier » Le pointeur

EOF

(34)

Ensuite, la marque de « fin de fichier » se déplace vers le bas en entrainant avec elle le pointeur. C’est-à-dire, dès que la donnée est enregistrée, le pointeur se déplace, automatiquement, vers le bas.

3. Ecrire la phrase « Nous sommes 5 » dans le fichier donnera le fichier suivant :

4. Ecrire la lettre le nom, prénom, et la date de naissance dans le fichier donnera le fichier suivant :

A la fermeture du fichier, on aura le fichier suivant :

Ce qu’on doit retenir du « mode écriture » :

- Ouvrir un fichier en « mode écriture » permet de créer un nouveau fichier. Si le fichier existe déjà, il devient vide, donc nouveau.

- Un pointeur est, automatiquement, alloué au fichier et qui pointe au début du fichier, sur la marque de « fin de fichier ». Le pointeur indique la position (la ligne) où sera enregistrée la prochaine information.

- A chaque écriture d’une information, cette dernière est enregistrée sur une ligne qui sera terminée par la marque de « fin de ligne ». Ensuite, la marque de « fin de fichier » se déplace vers le bas en entraînant avec elle le pointeur.

- Il est impossible au pointeur de revenir en arrière à une ancienne position.

- Impossible de lire les données contenues dans le fichier ouvert en « mode écriture ».

On ne peut qu’écrire dans ce fichier.

1.3.1.2. Mode « lecture »

Le « mode lecture » permet de lire les données et les informations, préalablement, stockées dans un fichier.

A l’ouverture du fichier en mode « lecture » :

- Si le fichier n’existe pas, un message d’erreur sera affiché

- Le fichier sera chargé dans la mémoire centrale et l’ordinateur lui attribuera un pointeur qui se positionne automatiquement au début. Le rôle du pointeur est d’indiquer la position de la prochaine lecture dans le fichier. Il représente la tête de lecture.

EOF

EOL

Une deuxième information Nous sommes 5 ^EOL

EOF

EOL

Nous sommes 5 ^EOL

Une troisième information

BENHALIMA Halima 01/14/1989 Boumerdès Chef de bureau ^EOL

EOF

Nous sommes 5

BENHALIMA Halima 01/14/1989 Boumerdès Chef de bureau

(35)

- En « mode lecture » le pointeur se positionne toujours au début du fichier et non pas sur la « fin du fichier » comme dans le « mode écriture ».

- On ne peut que lire dans un fichier ouvert en « mode lecture ».

Schématisons maintenant comment se comporte le fichier ouvert en « mode lecture » 1. Ouvrir le fichier en « mode lecture » donnera la configuration suivante :

2. La lecture de la première ligne du fichier fera avancer automatiquement le pointeur sur la deuxième ligne :

3. A chaque lecture d’une donnée du fichier, l’ordinateur déplace automatiquement le pointeur sur la position de la prochaine donnée à lire et ce jusqu’à la « fin du fichier ».

Ce qu’on doit retenir du « mode lecture » :

- A l’ouverture d’un fichier en « mode lecture », le pointeur se positionnera, automatiquement, au début du fichier. Le pointeur indique la position (la ligne) où se trouve la donnée ou l’information à lire.

- A chaque lecture d’une information, le pointeur se déplace vers le bas - Il est impossible au pointeur de revenir en arrière à une ancienne position.

- Impossible d’écrire des données dans un fichier ouvert en « mode lecture ». On ne peut que lire le contenu du fichier.

- La lecture se termine lorsque le pointeur se trouve sur la marque de « fin de fichier - EOF ».

1.3.1.3. Mode « ajout »

Le « mode ajout » permet de stocker ou d’ajouter des données et des informations à la fin d’un fichier. Le traitement d’un fichier ouvert en « mode ajout » est identique à celui ouvert en « mode écriture », avec quelques différences importantes.

EOF

EOL

Nous sommes 5 ^EOL

BENHALIMA Halima 01/14/1989 Boumerdès Chef de bureau ^EOL Je suis au début du fichier

EOF

EOL

Nous sommes 5 ^EOL

BENHALIMA Halima 01/14/1989 Boumerdès Chef de bureau ^EOL Je suis au début du fichier

EOF

EOL

Nous sommes 5 ^EOL

Le pointeur

(36)

A l’ouverture du fichier :

- Si le fichier n’existe pas, un message d’erreur s’affiche - Si le fichier existe, il ne sera pas vidé de son contenu

- Le fichier est chargé dans la mémoire centrale et l’ordinateur lui attribue un pointeur qui se positionne automatiquement à la « fin du fichier ». Le rôle du pointeur est d’indiquer la position de la prochaine écriture (stockage) dans le fichier. Il représente la tête d’écriture.

- En « mode ajout » le pointeur se positionne toujours, à la fin, sur la marque de « fin du fichier ».

- On ne peut qu’écrire dans un fichier ouvert en « mode ajout ».

Schématisons maintenant comment se comporte le fichier ouvert en « mode ajout » 1. Ouvrir le fichier en « mode ajout » donnera la configuration suivante :

2. L’ajout d’une information fera avancer, automatiquement, la marque de « fin de fichier » et le pointeur vers le bas (voir « mode écriture ») :

Ce qu’on doit retenir du « mode ajout » :

- Ouvrir un fichier en « mode ajout » permet d’ajouter des données dans un fichier existant.

- Les données sont ajoutées à la fin du fichier.

- Un pointeur est, automatiquement, alloué au fichier et qui pointe vers la fin, sur la marque de « fin de fichier ». Le pointeur indique la position (la ligne) où sera enregistrée la prochaine information.

EOF

EOL

Nous sommes 5 ^EOL

Le pointeur

EOF

EOL

Nous sommes 5 ^EOL

BENKACI Kaci 01/14/1989 Corso Tecnicien supérieur en informatique ^EOL 1^er ajout

EOF

EOL

Nous sommes 5 ^EOL

BENKACI Kaci 07/05/1991 Corso Tecnicien supérieur en informatique ^EOL BENOMAR Omar 13/03/1986 Thénia Gardien ^EOL

2^ème ajout

(37)

- A chaque ajout d’une information, cette dernière est enregistrée sur une ligne qui sera terminée par la marque de « fin de ligne ». Ensuite, la marque de « fin de fichier » se déplace vers le bas en entraînant avec elle le pointeur.

- Il est impossible au pointeur de revenir en arrière à une ancienne position.

- Impossible de lire les données contenues dans le fichier ouvert en « mode ajout ».

On ne peut qu’écrire dans ce fichier.

1.4. Utilisation des fichiers

Dans un algorithme, le fichier est identifié par une variable. La variable est déclarée suivant trois types d’utilisation des fichiers :

• Fichier texte

• Fichier Structuré

• Fichier simple 1.4.1. Fichier texte

En algorithmique, un fichier texte est déclaré comme étant une variable de type texte.

Var

f : Texte ;

« f » est la variable de travail qui sera associé à un fichier physique. Elle représente le canal par lequel vont transiter les données à partir ou vers le fichier.

Pour simplifier la compréhension, on apparente « f » au pointeur associé au fichier.

Toutes les données écrites dans un fichier texte doivent être de type « chaîne ». Toutes les variables dont le type est différent du type « chaîne » doivent être converties en type

« chaîne » avant d’être enregistrées dans le fichier texte.

Avant d’ouvrir un fichier, il faut l’associer à la variable de travail :

Var

f : Texte ; nomf : chaine ; Début

Ecrire ( ‘ Donnez le nom de votre fichier ‘ ) ; Lire ( nomf ) ;

Associer (f, nomf);

Tout fichier a un nom physique (nomf) qui l’identifie de façon unique. Pour reconnaître le type du fichier, on lui ajoute, à la fin du nom, une extension précédée d’un point (.txt : pour le fichier texte, .exe : pour un fichier exécutable, .doc pour un fichier Word etc..)

Pour utiliser un fichier, après lui avoir associé la variable de travail, il faut l’ouvrir en indiquant le mode d’ouverture :

(38)

Var

f : Texte ; nomf : chaine ; Début

Associer (f, nomf);

Ouvrir ( f , écriture ) ;

L’écriture des données dans un fichier se fait au moyen de l’instruction write, où on doit préciser la variable-fichier et la donnée à écrire :

Var

f : Texte ; nomf : chaine ;

x : chaine ; Début

Associer (f, nomf);

Ecrire ( ‘ Donnez une information ‘ ) ; Lire ( x ) ;

Write ( f , x ) ;

La valeur de la variable « x » sera écrite dans le fichier « nomf » en transitant par le canal

« f ».

Il est toujours recommandé de fermer un fichier si on a terminé de travailler avec :

Var

f : Texte ; nomf : chaine ;

x : chaine ; Début

Associer (f, nomf);

Ecrire ( ‘ Donnez votre information ‘ ) ; Lire ( x ) ;

Write ( f , x ) ; Fermer ( f ) ; Fin.

1.4.1.1. Mode « ECRITURE » : saisie d’une donnée simple.

Ecrire un algorithme qui permet d’enregistrer dans un fichier le nom des daïra de la wilaya de boumerdes :

Pour faire, on utilisera une boucle « tant que » jusqu’à ce que le nom de la daïra soit

« Alger ».