chapitre 6 structures de données les tableaux · chapitre 6 structures de données les tableaux :...

CHAPITRE 6

Structures de données

Les Tableaux :

Les tableaux à une dimension « Les Vecteurs » :

Un tableau est un ensemble d'objets informatiques de même type enregistrés en

mémoire les uns à la suite des autres. Les tableaux à une dimension sont parfois appelés

« vecteurs ».

indice 1 2 3 4 5 6 7 8 9 10 NomVecteur

valeur e1 e2 e3 e4 e5 e6 e7 e8 e9 e10

Déclaration d'un Tableau à une dimension :

La déclaration d'un tableau à une dimension se fait en suivant la syntaxe suivante :

TYPE

NomTypeTableau = TABLEAU [1..NombreElements] DE type ;

VAR

NomTableau : NomTypeTableau ;

Syntaxe en langage C :

type NomTableau [NombreElements];

o type : type commun à tous les éléments du tableau.

o NombreElements : nombre d'éléments du tableau, entier positif.

Exemple :

Voici comment on déclare un tableau de 5 variables de type caractères.

En algorithme :

TYPE

MonPremierTypeTableau = TABLEAU [1..5] DE caractères ;

VAR

MonPremierTableau : MonPremierTypeTableau ;

En langage C :

char MonPremierTableau [5] ;

L’Accès aux éléments d’un tableau :

Pour accéder à un élément du tableau, le nom que l'on a donné à celui-ci ne suffit

pas car il comporte plusieurs éléments. Ainsi, on définit un nombre appelé indice (en

anglais index) qui, combiné avec le nom du tableau, permet de décrire exactement

chaque élément.

Pour accéder à un élément du tableau, il suffit donc de donner le nom du tableau,

suivi de l'indice de l'élément entre crochets :

Nom_du_tableau [indice]

o L'indice du premier élément du tableau est 0 (ou 1).

o Un indice est toujours positif.

o L'indice du dernier élément du tableau est égal au nombre d'éléments – 1

(ou au nombre d'éléments).

o Ainsi, on accédera au 5ème élément du tableau en écrivant : Nom_du_tableau [4]

(ou Nom_du_tableau [4]).

Manipulation des éléments d’un tableau :

Un élément du tableau (repéré par le nom du tableau et son indice) peut être

manipulé exactement comme une variable, on peut donc effectuer des opérations avec

(ou sur) des éléments de tableau.

Définissons un tableau de 10 entiers :

En algorithme :

TYPE

TypeTableau = TABLEAU [1..10] DE entiers ;

VAR

Tab : TypeTableau ;

En langage C :

int Tab [10] ;

Pour affecter la valeur 6 au huitième élément on écrira : Tab [7] = 6 ; (ou Tab [8] = 6 ;)

Pour affecter au 10éme élément le résultat de l’addition des éléments 1 et 2, on écrira :

Tab [9] = Tab [0] + Tab [1] ; (ou Tab [10] = Tab [1] + Tab [2]).

Initialisation des éléments d’un tableau :

Initialisation d’un tableau à une dimension par 0 :

Utilisation des tableaux avec la boucle Pour :

La manipulation d’un tableau se fait aisément à l’aide de boucles Pour…. La

boucle nous permet de parcourir le tableau dans son intégralité afin de le remplir ou

d’effectuer des calculs sur chacun de ses éléments.

Exemple :

Supposons que l’on possède un tableau contenant les notes d’un groupe de 24

étudiants :

indice 1 2 3 4 ……. 24 NoteEtu

valeur 11.5 13 9.25 14 …….. 12.75

Si on veut écrire un algorithme qui nous permet de calculer la moyenne générale,

on procède de la manière suivante:

Les tableaux à deux dimensions « Les Matrices » :

Il est possible de créer des tableaux à deux dimensions, c'est-à-dire où les cases

sont organisées sous la forme d'un certain nombre de lignes et de colonnes. Il est en fait

possible de créer des tableaux avec autant de dimensions que l'on souhaite, même si la

plupart du temps, on se limitera à deux ou trois.

indice 1 2 3 4

1 e11 e12 e13 e14

2 e21 e22 e23 e24 NomMatrice

3 e31 e32 e33 e34

Déclaration d'un Tableau à deux dimensions :

La déclaration d'un tableau à deux dimensions se fait en suivant la syntaxe

suivante :

TYPE

NomTypeTableau = TABLEAU [1..N] [1..M] DE type ;

VAR

NomTableau : NomTypeTableau ;

Syntaxe en langage C :

type NomTableau [N][M];

Pour déclarer une variable comme étant un tableau à plusieurs dimensions, on

généralise le principe de la déclaration à une dimension, en plaçant entre crochets, après

l'identifiant, le nombre de cases dans chaque dimension.

<TypeSimple> <NomTabl>[<DimLigne>][<DimCol>];

Exemple :

Voici par exemple comment déclarer un tableau de 3 lignes par 2 colonnes, contenant

des entiers :

En algorithme :

TYPE

TypeTableau = TABLEAU [1..3][1..2] DE entiers ;

VAR

Tab : TypeTableau ;

En langage C :

int tableau2D [3][2] ;

Les tableaux à deux dimensions sont aussi appelés « Matrices ».

Initialisation des éléments d’une matrice :

Initialisation d’un tableau à deux dimensions par 0 :

L’Accès aux éléments d’une matrice :

On peut accéder en lecture ou en écriture aux cases d’une matrice, en plaçant

entre crochets, après l'identifiant, les coordonnées de la case à laquelle on veut accéder.

Si l'on veut modifier une case du tableau, on peut écrire :

Remarque :

o Une matrice est dite carrée si le nombre de lignes = nombre de colonnes.

o Dans ce cas les éléments de la diagonale est tout élément dont le numéro de ligne =

numéro de colonne.

Les Chaînes de Caractères :

Une chaîne de caractères est représentée par une suite d'octets correspondant à

chacun de ses caractères, le tout étant terminé par un octet supplémentaire de code nul.

Cela signifie que, d'une manière générale, une chaîne de n caractères occupe en mémoire

un emplacement de n+1 octets.

Une chaîne de caractères est un tableau de caractères dont la fin est indiquée par

le caractère nul.

Déclarations des chaînes :

En algorithme :

machine : chaine de caractères ;

En langage C :

char machine [n] ;

o En langage C on ne peut pas transférer une chaîne constante dans machaine, en

écrivant une affectation du genre :

machaine= "bonjour";

o Le langage C autorise l'initialisation d'un tableau de caractères à l'aide d'une chaîne

constante. Ainsi, on pourra écrire :

char b[]= "bonjour" ;

Pour initialiser avec une chaîne de caractères, il faut utiliser les guillemets.

b est une chaîne de caractères à 8 caractères (il faut prendre en compte le caractère

de fin de la chaîne)

Les types structurés et les enregistrements :

Contrairement aux tableaux qui sont des structures de données dont tous les

éléments sont de même type, les enregistrements sont des structures de données dont

les éléments peuvent être de type différent et qui se rapportent à la même entité.

Les éléments qui composent un enregistrement sont appelés champs. Avant de

déclarer une variable enregistrement, il faut avoir au préalable définit son type, c'est à

dire le nom et le type des champs qui le compose. Le type d'un enregistrement est

appelé type structuré. (Les enregistrements sont parfois appelé structures, en analogie

avec le langage C).

Déclaration d'un type structuré :

Jusqu'à présent, nous n'avons utilisé que des types primitifs (caractères, entiers,

réels, chaînes) et des tableaux de types primitifs. Mais nous pouvons créer nos propres

types puis déclarer des variables ou des tableaux d'éléments de ce type.

Pour créer des enregistrements, il faut déclarer un nouveau type, basé sur

d'autres types existants, qu'on appelle type structuré. Après avoir défini un type

structuré, on peut l'utiliser comme un type normal en déclarant une ou plusieurs

variables de ce type. Les variables de type structuré sont appelées enregistrements.

La déclaration des types structurés se fait dans une section spéciale des

algorithmes appelée Type, qui précède la section des variables (et succède à la section

des constantes).

Syntaxes :

TYPE

Nom_type = ENREGISTREMENT

Nom_champ1 : type_champ1 ;

…

Nom_champ1 : type_champ1 ;

FIN

Exemple :

TYPE

tpersonne = ENREGISTREMENT

nom : chaine de caractères ;

prénom : chaine de caractères ;

âge : entier ;

FIN

Déclaration d'un enregistrement à partir d'un type structuré :

Une fois qu'on a défini un type structuré, on peut déclarer des variables

enregistrements exactement de la même façon que l'on déclare des variables d'un type

primitif.

Syntaxe :

VAR

nom_var : nom_type ;

Exemple:

VAR

pers1, pers2, pers3 : tpersonne ;

Représentation :

Les enregistrements sont composés de plusieurs zones de données,

correspondant aux champs

pers1.nom pers1.prénom pers1.age

pers1

pers2.nom pers2.prénom pers2.age

pers2

Exemple :

Soit l'entité suivante:

Légende : code: code alphanumérique du produit lib: libéllé paht: prix d'achat hors taxes pvht: prix de vente hors taxes txtva: taux de TVA applicable

Voici comment déclarer deux occurrences (variables enregistrements) du type

structuré correspondant à cette entité.

/* Il faut d'abord définir le type structuré correspondant */

TYPE

produit = ENREGISTREMENT

code : chaine de caractère ;

lib : chaine de caractère ;

paht : réel ;

pvht : réel ;

txtva : réel ;

FIN

/* Ensuite il est possible de déclarer deux variables de ce type */

VAR

prod1, prod2 : produit ;

Manipulation d'un enregistrement :

La manipulation d'un enregistrement se fait au travers de ses champs. Comme

pour les tableaux, il n'est pas possible de manipuler un enregistrement globalement,

sauf pour affecter un enregistrement à un autre de même type. Par exemple, pour

afficher un enregistrement il faut afficher tous ses champs uns par uns.

Accès aux champs d'un enregistrement :

Alors que les éléments d'un tableau sont accessibles au travers de leur indice, les

champs d'un enregistrement sont accessibles à travers leur nom, grâce à l'opérateur '.'

nom_enregistrement.nom_champ

Par exemple, pour accéder à l'âge de la variable pers2, on utilise l'expression:

pers2.âge

Remarque :

Le nom d'un champ est TOUJOURS précédé du nom de l'enregistrement auquel il

appartient. On ne peut pas trouver un nom de champ tout seul, sans indication de

l'enregistrement.

Les champs d'un enregistrement, tout comme les éléments d'un tableau, sont des

variables à qui on peut faire subir les mêmes opérations (affectation, saisie, affichage,…).

Exemple :

Programme de saisie des données concernant les personnes pers1 et pers2, puis

affichage de la différence d'âge entre ces deux personnes

ALGO Exemple

TYPE




âge : entier ;

FIN

VAR

pers1, pers2 : tpersonne ;

DEBUT

Ecrire ("Entrez le nom puis l'âge de la personne 1") ;

Lire (pers1.nom, pers1.age) ; // il est impossible d'écrire Saisir pers1

Ecrire ("Entrez le nom puis l'âge de la personne 2") ;

Lire (pers2.nom, pers2.age) ;

Ecrire ("La différence d'âge entre ", pers1.nom, " et ", pers2.nom, " est de ") ;

SI (pers1.age > pers2.age)

ALORS Ecrire (pers1.age – pers2.age, " ans ") ;

SINON Ecrire (pers2.age – pers1.age, " ans ") ;

FINSI

FIN

Passage d'un enregistrement en paramètre d'un sous-programme :

Il est possible de passer tout un enregistrement en paramètre d'une fonction ou

d'une procédure (on n'est pas obligé de passer tous les champs uns à uns, ce qui permet

de diminuer le nombre de paramètres à passer), exactement comme pour les tableaux.

Exemple :

Voilà une fonction qui renvoie la différence d'âge entre deux personnes :

FONCTION différence (p1, p2 : tpersonne) : entier

DEBUT

SI pers1.age > pers2.age ALORS

RETOURNE (pers1.age – pers2.age) ;

SINON

RETOURNE (pers2.age – pers1.age) ;

FINSI

FIN

Exemple :

Voilà une procédure qui permet de modifier le prix de vente hors taxes d'un

produit passé en paramètre. Cette procédure commence par afficher le libellé et l'ancien

prix de vente hors taxes du produit puis saisit le nouveau prix de vente entré par

l'utilisateur.

PROCEDURE modpvht (donnée-resultat x: produit)

DEBUT

Ecrire ("produit: ", x.lib) ;

Ecrire ("prix de vente hors taxe actuel: ", x.pvht) ;

Ecrire ("Entrez le nouveau prix de vente: ") ;

Lire (x.pvht) ;

Ecrire ("le nouveau prix de vente est: ", x.pvht) ;

FIN

L'imbrication d'enregistrements :

Supposons que dans le type personne, nous ne voulions plus l'âge de la personne,

mais sa date de naissance. Une date est composée de trois variables (jour, mois, année)

indissociables. Une date correspond donc à une entité du monde réel qu'on doit

représenter par un type enregistrement à 3 champs.

Si on déclare le type date au préalable, on peut l'utiliser dans la déclaration du

type personne pour le type de la date de naissance.

Un type structuré peut être utilisé comme type pour des champs d'un autre type

structuré.

TYPE

date = ENREGISTREMENT

jour : entier ;

mois : entier ;

année : entier ;

FIN




ddn : date ;

FIN

Pour accéder à l'année de naissance d'une personne, il faut utiliser deux fois

l'opérateur '.'

pers1.ddn.année

Il faut lire une telle variable de droite à gauche : l'année de la date de naissance de

la personne 1.

Les tableaux d'enregistrement (ou tables) :

Il arrive souvent que l’on veuille traiter non pas un seul enregistrement mais

plusieurs. Par exemple, on veut pouvoir traiter un groupe de personne. On ne va donc

pas créer autant de variables du type personne qu’il y a de personnes. On va créer un

tableau regroupant toutes les personnes du groupe. Il s’agit alors d’un tableau

d’enregistrements.

CONST

NP = 20 // nombre de personnes du groupe

TYPE

personne = ENREGISTREMENT

nom: chaine de caractères ;

age: entier ;

FIN

typ_groupe = tableau[1..NP] de personnes ;

VAR

groupe : typ_groupe ;

nom âge Nom des champs

1

2

3

4

5

Indices du tableau

Chaque élément du tableau est un enregistrement, contenant plusieurs variables

de type différent. On accède à un enregistrement par son indice dans le tableau.

groupe[2] représente la deuxième personne du groupe

groupe[2].nom représente le nom de la deuxième personne du groupe

Remarque :

groupe.nom[3] n'est pas valide.

Pour accéder au nom de la troisième personne du tableau, il faut écrire

groupe[3].nom

Les fichiers :

Toutes les informations que nous avons jusqu'à présent traitées étaient saisies à

partir du clavier et stockées en mémoire (la RAM).

Or la mémoire centrale est volatile : les informations qui y sont stockées sont

détruites à la fin de l'exécution du programme et ne peuvent donc pas être réutilisées

ultérieurement. A la fin de l'exécution du programme, il ne reste aucune trace de cette

exécution et des résultats générés.

Par ailleurs, la mémoire centrale a l'inconvénient d'être bien plus chère que la

mémoire non volatile des disques durs, disquettes ou bandes magnétiques. La taille de la

mémoire centrale est par conséquent très inférieure à la taille de la mémoire non

volatile. Pour mémoriser de gros volumes d'information, la mémoire centrale ne suffit

pas.

Ainsi, dans la plupart des applications d'entreprises pour lesquelles un gros

volume d'informations doit être mémorisé plus longtemps que la durée de vie du

programme, les informations sont récupérées et mémorisées sur un support non volatile

(disques, disquettes, bandes magnétiques…). Les informations y sont enregistrées de

manière permanente dans des fichiers.

Les informations ne sont plus seulement communiquées via le clavier et l'écran,

mais aussi via des fichiers de support non volatiles. Il est alors possible qu'un

programme ne communique avec son environnement qu'au travers des fichiers et

n'utilise ni la saisie, ni l'affichage.

Un fichier est un regroupement d'informations sur un support non volatile tel que

le disque

Il existe de nombreux types de fichiers, qui différent en outre selon les langages.

Nous distinguerons les fichiers de type « texte » et les fichiers structurés.

Les fichiers structurés permettent d’enregistrer des données de même nature.

Ils sont composés d’enregistrements (ou articles) contenant les mêmes champs

(ou rubrique). Généralement, chaque enregistrement correspond à une ligne, et

les rubriques sont séparées par un séparateur qui peut être par exemple un

point-virgule (format csv).

Les fichiers non structurés permettent quant à eux d’entasser des informations

de natures diverses. Ils ne sont pas obligatoirement structurés en

enregistrements, mais ils ne peuvent être lus que de manière séquentielle. Ex : un

fichier word.

Il existe deux grandes familles de supports pour les fichiers :

Les supports adressables, sont capables de fournir l'adresse d'un emplacement

de stockage. C'est le cas des disques et les disquettes. Ils permettent un accès

direct (non séquentiel) à leur contenu.

Les supports non adressables qui ne peuvent être accédés que de manière

séquentielle. C'est le cas des bandes magnétiques, qui sont encore utilisées pour

stocker les données très volumineuses (les archives) car elles sont peu chères.

On appelle mode d'accès à un fichier la façon de retrouver une donnée dans ce

fichier. Il existe deux modes d'accès principaux:

L'accès séquentiel : possible sur tous les types de support et avec tous les types

de fichiers. Pour accéder à un article particulier, on doit avoir parcouru tous les

articles précédents sur le support.

L'accès direct : possible seulement sur support adressable avec des fichiers

structurés. On peut se positionner directement sur l'enregistrement voulu à

partir de son emplacement sur le support (ou à partir d’une clé). Un fichier à

accès direct peut être vu en quelque sorte comme un énorme tableau stocké sur

support non volatile.

Les fichiers à accès séquentiel :

Un fichier séquentiel est un fichier dont les données ne sont accessibles que de

manière consécutive sur le support. Leur accès est donc séquentiel. Contrairement aux

éléments d'un tableau ou aux champs d'un enregistrement, les données d'un fichier

séquentiel ne sont pas accessibles directement, ni par un indice, ni par un nom. Pour

accéder à un enregistrement particulier, il faut parcourir le fichier séquentiel depuis le

début jusqu'à trouver l'enregistrement recherché.

On peut se représenter un fichier séquentiel comme une bande de papier

contenant des articles cotes à cotes. Cette bande défile sous une tête de lecture qui ne

peut lire qu’un seul article à la fois. Pour accéder à un article, on est obligé de

positionner la tête de lecture sur cet article, en faisant défiler la bande en dessous.

Sens du défilement Tête de lecture

Déclaration :

Dans un programme, un fichier est désigné par une variable, qu'on déclare dans

la section des variables. C'est une variable particulière qui ne représente pas un espace

de la mémoire mais qui représente un espace dans un périphérique de stockage.

Pour déclarer un fichier séquentiel structuré, il faut indiquer le type des articles

(enregistrements) qui composent ce fichier. Le plus souvent les articles sont de type

enregistrement, déclaré au préalable.

VAR

nom_fichier : FICHIER de type_articles ;

Exemple :

TYPE

temployé = ENREGISTREMENT

nom: chaine ;

prénom: chaine ;

fonction: chaine ;

salaire: entier ;

FIN

VAR

personnel : FICHIER SEQUENTIEL de temployé ;

Association (à l’assignation) :

Un fichier doit avoir deux noms: un nom logique (appelé encore nom interne) qui

servira à désigner le fichier tout le long du programme et nom physique (appelé aussi

nom externe) qui servira à la représenter sur le support de stockage. La commande

associer permet d'établir une correspondance entre ces deux noms.

Associer (nom_logique,"nom_physique") ;

Au encore

Assigner (nom_logique,"nom_physique") ;

Exemple :

Associer (fp,"c:\archive\liste_patient.dat") ;

Remarque:

Si le nom physique comporte des dossiers, ces derniers doivent être crée, au

niveau du système d'exploitation par le programmeur ou l'utilisateur sinon lors

d'exécution, le programme affiche se message d'erreur de type ("runtime errer").

Ouverture et fermeture :

Comme un fichier ne se trouve pas en mémoire centrale (mais en périphérique), il

n'est pas accessible directement par le programme (seule la mémoire centrale est

accessible directement). Il est nécessaire de l'ouvrir avant de pouvoir l'utiliser

(l'ouverture permet d'effectuer la liaison entre le fichier logique (la variable du

programme) et le fichier physique manipulé par le système d'exploitation. En

programmation, notamment en C++, c'est à l'ouverture qu'on indique à quel fichier

physique correspond le fichier logique).

L'ouverture permet la réservation d'une mémoire tampon en mémoire centrale

pour les échanges entre le disque et la mémoire centrale (les transferts d'articles entre

le support et la mémoire s'effectuent par blocs. Un bloc est l'ensemble des octets

transférés par le système d'exploitation lors d'une opération d'entrée-sortie).

Il existe 4 modes principaux d'ouverture d'un fichier:

en lecture pour récupérer des données du fichier dans des variables de la

mémoire centrale.

en écriture pour créer un fichier dans lequel enregistrer des résultats. Si fichier

existe déjà, son ancien contenu est détruit.

en mode ajout pour pouvoir ajouter des articles à la fin d'un fichier déjà existant

(dans un fichier séquentiel, il est impossible d'ajouter un article ailleurs qu'à la

fin).

Ouvrir (nom_fichier, mode_ouverture) ;

Exemple :

Ouvrir (personnel, lecture) ;

Après utilisation, un fichier doit être fermé, de façon à libérer la mémoire tampon

allouée lors de l'ouverture et ainsi enregistrer les dernières données du tampon non

encore transférées.

Fermer (nom_fichier) ;

Remarque :

Dans les fichiers à accès direct, il existe un autre mode d’ouverture : le mode mise à

jour. Il permet de modifier un article existant, ou même d’ajouter un nouvel article au

milieu du fichier. Ces opérations sont impossibles directement avec les fichiers à

organisation séquentielle.

Lecture et Ecriture :

La communication entre la mémoire centrale et le fichier peut se faire dans les deux

sens:

De la mémoire au fichier : c'est l'écriture.

Du fichier vers la mémoire : c'est la lecture.

En algorithmique, toute opération de communication (écriture ou lecture) s'effectue

sur un article entier, et se fait par l'intermédiaire d’une variable enregistrement en

mémoire centrale (le plus souvent un enregistrement).

ECRITURE:

copie ENREGISTREMENT EN RAM ARTICLE DU FICHIER

LECTURE:

copie ARTICLE DU FICHIER ENREGISTREMENT EN RAM

Supposons que le clavier et l'écran soient comme des fichiers.

Lire :

L'instruction Lire permet de transférer des articles d'un fichier existant dans une

(ou plusieurs) variable du programme. La variable lue doit obligatoirement être de

même structure (c'est-à-dire du même type) que les articles du fichier. Le fichier lu doit

obligatoirement exister.

Lire (nom_fichier, nom_variable1) ;

Exemple :

Recopier dans la variable ouvrier les informations contenues dans l'article suivant.

/* ouvrier est un enregistrement de type temployé*/

Lire (Personnel, ouvrier) ;

Si on essaye de lire après la fin du fichier, il va y avoir une erreur d'exécution.

Pour éviter cela, il existe une fonction booléenne appelée EOF (nom_fichier) (pour end

of file) qui renvoie vrai lorsque la tête de lecture est en face une marque de fin de fichier.

EOF (nom_fichier) devient Vrai lorsqu'on lit après le dernier article.

Donc avant toute opération de lecture, il faut s'assurer que la fin du fichier n'est

pas atteinte.

SI non EOF (Personnel) ALORS


SINON

Ecrire (Fin de fichier atteinte) ;

FINSI

TANTQUE non EOF (Personnel) FAIRE


FINTANTQUE

Ecrire :

L'instruction Ecrire permet de recopier le contenu d'une variable (contenue en

mémoire centrale) à la fin du fichier (au premier article vide). Ecrire permet donc soit de

créer un nouveau fichier (en mode écriture), soit d'agrandir un fichier en lui ajoutant un

article à la fin (en mode ajout).

L'écriture se fait article par article. Donc la variable écrite dans le fichier doit

obligatoirement être du type des articles.

Ecrire (nom_fichier, nom_variable2) ;

1 La variable est du même type que les articles. 2 La variable est du type des articles.

Mise à jour d’un fichier séquentiel :

Dans un fichier séquentiel, il est impossible de modifier directement un article,

encore moins d’ajouter un nouvel article ailleurs qu’à la fin, et non plus de supprimer

physiquement un article. Ces opérations de mise à jour ne peuvent se faire qu’en

réécrivant complètement le fichier. La mise à jour directe n’est possible qu’avec les

fichiers à accès direct.

Pour les fichiers de petite taille, voilà comment procéder :

1. Copier tout son contenu en mémoire centrale, par exemple dans un tableau

d’enregistrement. C’est le chargement.

2. Faire les mises à jour désirées sur les données ainsi chargées en mémoire

centrale.

3. Recopier ces données mises à jour dans le fichier initial (en écrasant ainsi les

anciennes données). C’est la sauvegarde.

Pour mettre à jour des fichiers plus volumineux qui ne peuvent être

intégralement chargés en mémoire centrale, on passe par l’intermédiaire d’un autre

fichier.

Les fichiers à accès direct :

Un fichier est dit à accès direct si on peut accéder directement à un

enregistrement voulu en connaissant son numéro d’ordre dans le fichier.

On peut placer directement le pointeur de fichier sur l’enregistrement voulu

grâce à la procédure pointer qui nécessite deux paramètres : le nom logique du fichier

et le numéro d’ordre voulu.

Remarque :

Le numéro du premier élément d’un fichier est 0, donc pour accéder à nième

élément du fichier il faut pointer l’élément n-1.

Pointer (nom_logique, numéro) ;

Remarque :

On doit contrôler le dépassement de la fin de fichier par la fonction taille_fichier qui

renvoie le numéro d’éléments contenus dans le fichier.

Taille_fichier (nom_logique) ;

Exemple :

Pour déplacer le pointeur de fichier sur l’inducteur de fin de fichier :

Pointer (nom_logique, Taille_fichier (nom_logique)) ;

Autres fonctions et procédure prédéfinis :

Fonction position_fichier :

Cette fonction renvoie la position du pointeur de fichier, c'est-à-dire le numéro de

l’élément courant et elle ne peut pas s’appliquer à un fichier texte.

Position_fichier (nom_logique) ;

Procédure effacer :

Cette procédure détruite le fichier externe (physique) associé au fichier logique,

que permet être indifféremment ouvert ou fermé avant son effacement.

effacer (nom_logique) ;

Procédure renommer :

Cette procédure permet de changer le nom d’un fichier ce dernier doit être fermé

avant le renommer.

renommer (ancien nom_logique, nouveau nom_physique) ;

Procédure tranquer :

Cette procédure permet de supprimer tous ce qui se trouve après la position

courante du pointeur.

tranquer (nom_logique) ;

Remarque : Ces fonctions et ces procédures sont valables aussi bien pour l’accès direct

que pour l’accès séquentielle.

chapitre 6 structures de données les tableaux · chapitre 6 structures de données les tableaux :...

Documents