Chapitre 5 - Les tableaux

Chapitre 5 - Les tableaux

1. Introduction

Supposons que l’on a besoin de stocker et de manipuler les notes de 100 étudiants. On doit,
par conséquent, déclarer 100 variables : n1, n2,…, n100. Vous pouvez remarquer que c’est
un peu lourd de manipuler une centaine de variables (avec 100 fois de lecture/écriture…).
Imaginons maintenant le cas pour une promotion de 1000 étudiants, alors là devient notre
cas un vrai problème.
En algorithmique (et en programmation), on peut regrouper toutes ces variables en une seule
structure qui s’appelle tableau.
Un tableau est un ensemble de variables de même type ayant toutes le même nom.
Suite à cette définition, la question suivante se pose :
- Comment peut-on différencier entre des variables ayant le même nom ?
La réponse est dans la notion du tableau lui-même où chaque élément est repéré par un
indice. Ce dernier est un numéro (généralement un entier) qui permet de différencier chaque
élément du tableau des autres. Ainsi, les éléments du tableau ont tous le même nom, mais
pas le même indice. Pour accéder à un élément d’un tableau, on utilise le nom du tableau
suivi de l’indice de l’élément entre crochets [4].
Exemple
Soit le tableau T contenant les valeurs suivantes : 5, 10, 29, 3, 18 et 14 : L’organisation
du tableau T dans la mémoire peut être représentée comme suit :

indices : i=0 i=1 i=2 i=3 i=4 i=5

T
valeurs : T[0]=5 T[1]=10 T[2]=29 T[3]=3 T[4]=18 T[5]=14

2. Tableaux à une seule dimension

Dans ce type de tableaux, chaque élément est accessible (pour lecture ou modification) par
un seul indice.
2.1. Déclaration

La syntaxe de déclaration d’un tableau à une seule dimension est la suivante :

Tableau nom_du_tableau [taille] : type ;

Exemple : Tableau Notes [100] : réel ;

Remarque :

-1-
Chapitre 5 - Les tableaux

L’indice d’un élément dans un tableau, peut être exprimé comme un nombre, mais aussi il
peut être exprimé comme une variable ou une expression calculée [10].
La valeur de l’indice doit être toujours :
• Supérieur ou égal à 0 : dans quelques langages, le premier élément d’un tableau
porte l’indice 1 (comme en Pascal). Mais dans d’autres, comme c’est le cas en
langage C, la numérotation des indices commence à zéro. Par exemple Notes[1] est
le deuxième élément du tableau Notes.
• de type entier : quel que soit le langage, l’élément Notes[1,…] n’existe jamais.
• Inférieur ou égal au nombre des éléments du tableau (moins 1 si l’on commence
à zéro): En langage C, si un tableau T est déclaré comme ayant 10 éléments, la
présence, dans une ligne du corps de l’algorithme, de l’expression T[10] déclenchera
automatiquement une erreur.

2.2. Manipulation

Une fois déclaré, un tableau peut être manipulé comme un ensemble de variables simples.
Les trois manipulations de base sont l’affectation, la lecture et l’écriture [4].

2.2.1. L’affectation
L’affectation d’une valeur v à un élément i d’un tableau T de type numérique, se fait par :

T[i] ← v ;
Par exemple, l’instruction : T[0] ← 5 ; affecte la valeur 5 au premier élément du tableau T.

Illustration:

Supposons maintenant que l’on veut affecter la même valeur à tous les éléments du tableau
T, on utilisera pour cela une boucle :

Pour i de 0 à n-1 // n est la taille de T T[i]

←5;
FinPour
Cette boucle permet de parcourir tout le tableau T en affectant à chaque élément la valeur 5.
Illustration :

-2-
Chapitre 5 - Les tableaux

2.2.2. La lecture

Il est possible aussi d’affecter des valeurs aux éléments d’un tableau par une instruction de
lecture.
Exemple :
Ecrire "Entrer une note :" ;
Lire T[0] ;

Dans cet exemple, la valeur saisie est affectée au premier (1er) élément du tableau T.

Illustration :

indices : i=0 i=1 i=2 i=3 i=4 i=5

T
valeurs : 0

2.2.3. L’écriture

De même que la lecture, l’écriture de la valeur d’un élément du tableau s’écrira comme suit
:
Ecrire T[i] ; Cette instruction permet d’afficher la valeur de l’élément i du tableau T.

Remarque :
Les éléments d’un tableau sont manipulés de la même façon que les variables simples. S’il
s’agit d’un tableau de type numérique, les éléments peuvent être utilisés dans l’évaluation
des expressions numériques du genre :
x ← (Notes [1] + Notes [2]) / 2 ; Notes
[0] ← Notes [0] + 1 ;

Exemple :
Soit Notes un tableau de valeurs réelles tel qu’il est illustré dans le schéma qui suit.

Illustration :

indices : i=0 i=1 i=2 i=3 i=4 i=5

Notes
valeurs : 10 15 7 8.25 11.5 16

L’exécution de l’instruction : x ← (Notes [1] + Notes [2]) / 2 ;

Est équivalente à l’opération :

-3-
Chapitre 5 - Les tableaux

2.3. Application 1
Ecrivons un algorithme qui permet de lire des valeurs saisies par l’utilisateur dans un tableau
de taille 20, et les afficher par la suite.
Algorithme :
Var i : entier ;
Tableau Tab [20] : réel ;
Début
Pour i de 0 à 19
Ecrire ("Donner une valeur :") ;
Lire (Tab[i]) ;
FinPour
Pour i de 0 à 19
Ecrire ("Valeur ", i, "=", Tab[i]) ;
FinPour
Fin

L’exécution du programme correspondant à l’algorithme ci-dessus, permet d’initialiser le

tableau Tab comme suit :

- Après la fin de la 1ère boucle (boucle de lecture) :

Après la fin de la 2ème boucle (boucle d’affichage), on aura, sur écran par exemple,
l’affichage suivant :
Valeur 0 = 5
Valeur 1 = 34
…
Valeur 18 = 14,5
Valeur 19 = 60

Remarque : les valeurs : 5, 34, 14.5 et 60 sont un exemple d’échantillon de valeurs saisies
par l’utilisateur.

3. Tableaux à deux dimensions

Les tableaux à deux dimensions se présentent généralement sous forme d’un ensemble de
lignes et de colonnes (Matrice). Par conséquent, chaque élément est repéré par deux indices.

-4-
Chapitre 5 - Les tableaux

Exemple : le tableau T ci-dessous possède 3 lignes et 4 colonnes.

Donc, T[2][1] (i=2 et j=1) désigne l’élément de la 3ème ligne et la 2ème colonne (en
commençant de zéro bien sûr).

3.1. Déclaration d’un tableau à deux dimensions

Syntaxe :
Tableau nom_tableau [taille1][taille2] : type ;

Exemple : Tableau Notes [10][20] : réel ;

Le tableau Notes est composé de 10 lignes et 20 colonnes. Ce tableau pourra contenir donc
10*20 soit 200 valeurs réelles.

Remarque :
L’utilité d’un tableau à deux dimensions réside dans la possibilité de déclarer un seul tableau
au lieu de déclarer plusieurs tableaux identiques. En effet, le tableau de l’exemple précédent
est équivalant à 10 tableaux simples de 20 éléments chacun. En d’autres termes, la
déclaration:
Tableau Notes [10][20] : réel ; remplace
celle-ci :
Tableau Notes1 [20], Notes2 [20],…, Notes10 [20] : réel ;

3.2. Manipulation d’un tableau à deux dimensions

Un tableau à deux dimensions est manipulé de la même façon qu’un tableau simple (à une
seule dimension) que ce soit pour l’affectation, la lecture ou l’écriture. Ces trois opérations
sont illustrées dans la sous-section suivante.

3.3. Application 2

Reprenons l’algorithme de la sous-section 2.3 mais cette fois-ci pour un tableau de 5 lignes
et 20 colonnes :

Var i, j : Entier ;
Tableau Tab [5][20] : réel ;

-5-
Chapitre 5 - Les tableaux

Début
Pour i de 0 à 4
Pour j de 0 à 19
Ecrire ("Donner une valeur :") ; Lire (Tab [i][j]) ;
Finpour
Finpour
Pour i de 0 à 4
Pour j de 0 à 19
Ecrire (Tab [i][j]) ;
Finpour
Finpour Fin

4. Tableaux à n dimensions
Les tableaux à n dimensions (n>2), peuvent être utilisés pour diverses raisons telles que la
création et le traitement des objets 3D par exemple qui nécessitent des tableaux de 3
dimensions au minimum. La déclaration de ce type de tableaux est comme suit :

Syntaxe :
Tableau nom_tableau [taille1][taille2] … [tailleN] : type ;

Exemple : Tableau T [10][20][50] : réel ; // un tableau T à 3 dimensions

La manipulation d’un tableau à plusieurs dimensions suit le même principe que celle des
tableaux à deux dimensions. Ceci s’appuie sur l’utilisation des boucles imbriquées pour
parcourir le tableau, de sorte qu’il y aura autant de boucles qu’il y a de dimensions.

5. La recherche dans un tableau

5.1. La notion du drapeau
Le drapeau (ou flag en Anglais) est une variable booléenne initialisée à Faux (drapeau baissé).
Dès qu’un évènement attendu se produit, la variable change de valeur à Vrai (drapeau levé).
Donc, la valeur finale du drapeau permet de savoir si un évènement a eu lieu ou pas. Cela
devrait s’éclairer à l’aide d’un exemple extrêmement fréquent : la recherche de l’occurrence
d’une valeur dans un tableau [10].
Exemple :
En supposant l’existence d’un tableau comportant N valeurs entières. On doit écrire un
algorithme qui lit un nombre donné et informe l’utilisateur de la présence ou de l’absence de

-6-
Chapitre 5 - Les tableaux

ce nombre dans le tableau. La première étape consiste à écrire les instructions de lecture du
nombre N et de parcours du tableau :
Tableau Tab[N] : Entier ;
Var val, i : Entier ;
Début
Ecrire ("Entrer la valeur à rechercher :") ; Lire (val) ;
Pour i de 0 à N-1
…
Finpour
Fin

Illustration :
On suppose que N=6 et les valeurs saisies sont celles figurant dans le schéma suivant :

indices : i=0 i=1 i=2 i=3 i=4 i=5

Tab
valeurs : 10 22 31 46 5 7

Revenons à l’algorithme, maintenant, il faut combler les points de la boucle (le bloc qui devra
contenir les instructions de la recherche). Évidemment, il va falloir comparer « val » à chaque
élément du tableau, s’il y a une égalité quelque part, alors « val » fait partie du tableau. Cela
va se traduire, bien entendu, par l’instruction conditionnelle « Si … Alors … Sinon ».
…
Début
Ecrire ("Entrez la valeur à rechercher ") ; Lire (val) ;
Pour i de 0 à N-1
Si (val = Tab[i]) Alors

Ecrire (val, "figure") ; ?

Sinon
Ecrire (val, "ne figure pas") ;
Finsi
Finpour Fin

-7-
Chapitre 5 - Les tableaux

Illustration :
On suppose que la valeur à rechercher (val) est égale à 31 :

On peut constater qu’on a deux possibilités :

- ou bien la valeur « val » figure dans le tableau, - ou bien elle n'y figure pas.
Mais dans tous les cas, l'algorithme ne doit produire qu'une seule réponse, quel que soit le
nombre d'éléments du tableau. Or, l'algorithme ci-dessus affiche autant de messages qu'il y a
de valeurs dans le tableau. Il y a donc une erreur quelque part.
En fait, on ne peut savoir si la valeur recherchée existe dans le tableau ou non que lorsque le
parcours du tableau est entièrement accompli.
Pour pallier à cette erreur, on doit réécrire l’algorithme en plaçant le test après la boucle et en
utilisant cette fois-ci une variable booléenne (drapeau) que l’on appelle « Existe ».
Cette variable doit être gérée comme suit :
- La valeur de départ de « Existe » doit être évidemment Faux (drapeau baissé).
- La valeur de la variable « Existe » doit devenir Vrai (drapeau levé), si un test dans la
boucle est vérifié (lorsque la valeur de « val » est rencontrée dans le tableau). mais le
test doit être asymétrique, c.à.d. qu’il ne comporte pas de "sinon".

Donc l’algorithme correct devrait être comme suit :

Tableau Tab[N] : entier ;

Var val, i : entier ;
existe : booléen ;
Début
Ecrire ("Entrez la valeur à rechercher ") ;
Lire (val) ;
existe ← faux ;
Pour i de 0 à N-1
Si (val = Tab[i]) Alors existe ← vrai; Finsi
Finpour

-8-
Chapitre 5 - Les tableaux

Si (existe) Alors Ecrire (val, "fait partie du tableau") ;

Sinon Ecrire (val, "ne fait pas partie du tableau") ;
Finsi

Fin

Illustration :
En utilisant un drapeau (la variable « Existe ») :

➢ Question ?
Réécrire le même algorithme mais cette fois-ci, la boucle de recherche doit être arrêtée dès
que la valeur du drapeau change.

6. Le tri d’un tableau

Qu’est-ce qu’un tri ?
Le tri est une opération consistant à ordonner un ensemble d’éléments suivant une relation
d’ordre prédéfinie. Le problème du tri est un grand classique en algorithmique. Trier un
tableau numérique c’est donc ranger ses éléments en ordre croissant ou décroissant. Il existe
plusieurs algorithmes de tri, parmi lesquels le tri par sélection, tri par insertion, tri à bulles,
tri par fusion, etc. Nous illustrons dans ce qui suit deux types de tri, à savoir le tri par sélection
et le tri par insertion.

6.1. Tri par sélection

Cette technique est parmi les plus simples, elle consiste à sélectionner, pour une place donnée,
l’élément qui doit y être positionné. Par exemple pour trier un tableau en ordre croissant, on
met en première position le plus petit élément du tableau et on passe à la position suivante
pour mettre le plus petit élément parmi les éléments restants et ainsi de suite jusqu’au dernier
[2].

-9-
Chapitre 5 - Les tableaux

Exemple :
Soit à trier, en ordre croissant, le tableau suivant :
25 10 13 31 22 4 2 18
Nous commençons par la recherche de la plus petite valeur et sa position. Une fois identifiée
(dans ce cas, c’est le nombre 2 en 7ème position), nous l’échangeons avec le 1er élément (le
nombre 25). Le tableau devient ainsi :
2 10 13 31 22 4 25 18
Nous recommençons la recherche, mais cette fois, à partir du 2ème élément (puisque le 1er est
à sa position correcte). Le plus petit élément se trouve en 6ème position (le nombre 4). Nous
échangeons donc le 2ème élément avec le 6ème élément :
2 4 13 31 22 10 25 18
Nous recommençons la recherche à partir du 3ème élément (puisque les deux premiers sont
maintenant bien placés), Le plus petit élément se trouve aussi en 6ème position (10), en
l’échangeant avec le 3ème, ça donnera:
2 4 10 31 22 13 25 18
Nous recommençons maintenant à partir du 4ème élément et de la même façon nous procédons
jusqu’à l’avant dernier :
2 4 10 13 22 31 25 18

2 4 10 13 18 31 25 22

2 4 10 13 18 22 25 31

2 4 10 13 18 22 25 31
Algorithmiquement, nous pouvons décrire ce processus de la manière suivante :

• Boucle principale : prenant comme point de départ le premier élément, puis le second,
etc, jusqu’à l’avant dernier.

• Boucle secondaire : à partir de ce point de départ mouvant, nous recherchons jusqu’à la

fin du tableau le plus petit élément. Une fois trouvé, nous l’échangeons avec le point de
départ.

- 10 -
Chapitre 5 - Les tableaux

Donc, cela s’écrit :

/* boucle principale : le point de départ se décale à chaque tour */

Pour i de 0 à 6
/* on considère provisoirement que T(i) est le plus petit élément */
posmin ← i ; // posmin est la position du minimum initialisée par i
/* on examine tous les éléments suivants */
Pour j de (i + 1) à 7
Si (T(j) < T(posmin)) Alors posmin ← j ; Finsi

Finpour
/* on sait maintenant où est le plus petit élément. Il ne reste plus qu'à effectuer la permutation
*/
temp ← T(posmin) ;
T(posmin) ← T(i) ;
T(i) ← temp ;
/* On a placé correctement l'élément numéro i, on passe à présent au suivant */
FinPour

6.2. Tri par insertion

Soit à trier un tableau d’éléments en ordre croissant.

Le principe de ce type de tri repose à chaque itération sur trois phases [2] :
a) On prend le premier élément dans la partie non encore triée du tableau (la clé).
b) On cherche la place de la clé dans la partie déjà triée du tableau, en commençant par
la droite de cette partie.
c) Une fois cette place trouvée, on y insère la clé après qu’on ait décalé vers la droite
tous les éléments de la partie triée dont la valeur est plus grande ou égale à la valeur
de la clé.
Il faut noter qu’initialement, la partie triée est constituée seulement du premier élément du
tableau, autrement dit, le processus du tri commence à partir du deuxième élément.

Exemple :

Soit à trier, en ordre croissant, le même tableau précédent en appliquant le tri par insertion :

i=1 25 10 13 31 22 4 2 18

Clé Partie non encore triée

- 11 -
Chapitre 5 - Les tableaux

On décale le 1er élément de la partie triée vers la droite puisque sa valeur est supérieure à la
clé. Cette dernière est déplacée à la 1ère position :
i=2 10 25 13 31 22 4 2 18

On recommence le processus avec une nouvelle clé. Le 1er élément à droite de la partie triée
(25) est décalé vers la droite puisque sa valeur est supérieure à la clé. Le 2ème élément ne sera
pas décalé puisqu’il est inférieur à la clé. Par conséquent, la clé est insérée dans la 2ème
position du tableau :

i=3 10 13 25 31 22 4 2 18

On ne déplace pas cette clé (31) puisque sa valeur est supérieure à celles des éléments qui la
précèdent.

i=4 10 13 25 31 22 4 2 18

On décale les deux premiers éléments (31 et 25) vers la droite et la clé est insérée à la 3ème
position :

i=5 10 13 22 25 31 4 2 18

On décale tous les éléments de la partie triée vers la droite puisque leurs valeurs sont
supérieures à celle de la clé. Cette dernière est déplacée à la 1ère position :

4 10 13 22 25 31 2 18
La même opération est répétée pour cette clé (2) :
i=6
i=7 2 4 10 13 22 25 31 18

Les trois éléments (22,25 et 31) sont décalés vers la droite et la clé est déplacée vers la 5ème
position :
2 4 10 13 18 22 25 31

Nous obtenons donc un tableau qui est trié en ordre croissant.

L’algorithme correspondant à ce type de tri est présenté dans ce qui suit :

Algorithme Tri_Insertion ;

- 12 -
Chapitre 5 - Les tableaux

Var i, j, n, clé : Entier; // n est la taille du tableauT

T : Tableau d’entiers ;
Début
Pour i de 1 à n-1 // on commence par le 2ème élément (début de la partie non triée) clé
 T[i] ;
j  i - 1 ; // indice du 1er élément à droite de la partie triée
Tant que ((j >= 0) ET (clé < T[j])) Faire
T[j +1]  T[j]; // Décalage j  j
- 1;
FinTant que
T[j +1]  clé; // Insertion de la clé
FinPour
Fin

6.3. Comparaison

Dans l’algorithme de tri par sélection, nous avons dans tous les cas, la boucle interne est
exécuté pour i=1, 2, 3 jusqu’à i=(n-1) par conséquent, nous avons (n-1) + (n-2) + (n-3) + …
+ 1 étant n (n-1) / 2 exécutions. Par exemple, pour un tableau de 100 éléments, la boucle est
exécutée 4950 fois dans tous les cas.
Dans l’algorithme de tri par insertion, nous avons dans le pire des cas un tableau trié à l’envers
(en ordre décroissant dans ce cas), et la boucle interne est exécuté (n-1) + (n-2) + (n-3) + …
+ 1 fois, étant n (n-1) / 2 exécutions au maximum. Au meilleur des cas, le tableau est trié en
ordre voulu (croissant dans ce cas) et la boucle interne ne s’exécutera jamais. En moyenne,
le nombre d’exécutions est n (n-1) / 4. Par exemple, pour un tableau de 100 éléments, la
boucle est exécutée 4950 fois au maximum et 2475 en moyenne.

7. Conclusion

Dans ce chapitre, nous avons vu comment mémoriser et manipuler un ensemble de valeurs

représentées par le même nom et identifiées par des numéros à travers la notion du tableau.
En fait, un tableau n’est pas un type de données mais plutôt une liste d’éléments d’un type
donné. Le problème du tri qui est un grand classique de l’algorithmique, a été abordé par la
suite à travers deux algorithmes parmi les plus simples, à savoir le tri par sélection et le tri
par insertion. Une comparaison entre les deux algorithmes a été donnée à la fin de ce chapitre.

- 13 -
Chapitre 6 - Les enregistrements (structures)

Chapitre 6 - Les enregistrements (structures)

1. Introduction

Nous avons vu dans le chapitre précédent, que les tableaux nous permettent de stocker
plusieurs éléments de même type, tel que stocker les notes des étudiants dans un tableau de
type réel. Supposons maintenant qu’en plus des notes des étudiants, nous voulons stocker
aussi leurs informations (nom, prénom, matricule, …). Il nous faut dans ce cas de figure, une
autre structure qui permet de stocker des données de différents types. Donc, une nouvelle
structure appelée enregistrement est plus adaptée dans ce cas.

2. Définition
Un enregistrement (ou structure) permet de regrouper un ensemble de données de différents
types sous le même nom (un seul objet). Il est défini par un ensemble d’éléments appelés
champs. Ces derniers sont des données élémentaires ou composées qui peuvent être de types
différents.

3. Déclaration et manipulation
La syntaxe de déclaration d’une structure est la suivante :
Structure nom_structure
champ1 : type1 ;
champ2 : type2 ;
...
champN : typeN ;
FinStructure ;

Tel que « nom_structure » est le nom d’enregistrement défini par l’utilisateur. « champ1,
champ2, …, champN » sont les variables membres de la structure déclarée.
Exemple :
Structure Etudiant
num : entier ;
nom : chaîne ;
moyenne : réel;
FinStructure ;
Par la suite, des variables de type Etudiant peuvent être déclarées comme suit :
Var x,y : Structure Etudiant ; /* Deux variables structures x et y de type Etudiant */

- 14 -
Chapitre 6 - Les enregistrements (structures)

La manipulation d’une variable structure se fait par champ (membre) et l’accès à une
information contenue dans un champ se fait en précisant le nom de la variable structure
suivie du champ concerné. Les deux séparés par un point.
Exemple :
[Link] ←123 ; // affecte le nombre 123 au champ num
Lire ([Link]) ; // lire le champ nom
[Link] ←13.5 ; // affecte le nombre 13.5 au champ moyenne

4. Tableau de structures
Il est possible de déclarer un tableau dont les éléments sont des structures avec la syntaxe
suivante :
Tableau nom_tableau [taille] : Structure nom_structure ;

Exemple : Tableau T[10] : Structure Etudiant ;

Donc, T est un tableau de 10 éléments de type structure (« Etudiant » dans ce cas).

L'accès à un champ d’élément i d’un tableau de structure se fait comme suit :

nom_tableau [i].champ

Par exemple, les instructions :

T[0].nom ← "Mohamed" ;
T[0].num ← 1 ; et
T[0].moyenne ← 12.5 ; affectent respectivement la valeur entière « 1 », la chaîne de
caractères « Mohamed » et la valeur réelle « 12.5 » aux champs « num », « nom » et «
moyenne » du 1er élément du tableau T. Illustration :

indices : i=0 i=1 … i=9

T num : 1 num : num :
nom :Mohamed nom : … nom :
Eléments : moyenne : 12.5 moyenne : moyenne :

De même, les instructions :

Ecrire (T[0].num) ;
Ecrire (T[0].nom) ;
Ecrire (T[0]. moyenne) ;
Affichent les contenues des trois champs du 1er élément du tableau T.

- 15 -
Chapitre 6 - Les enregistrements (structures)

5. Structure membre d’une autre structure

Une structure peut figurer parmi les champs d'une autre structure. Dans ce cas, elle doit être
déclarée avant la structure qui la contient [6].

Exemple :
Structure Date
jour, mois, annee : entier ;
Finstructure ;
Structure Compte
Ncpt: entier;
nom: chaine ;
DtOuverture : Date ;
Finstructure ;

Où « DtOuverture » est une variable structure de type « Date », champ de la structure «

Compte ». Donc, la structure « Date » est déclarée obligatoirement avant la structure «
Compte ».
Lorsqu'un champ d'une structure est lui-même une structure, l’accès à ce champ se fait
comme suit : variable_structure.variable_sous_structure.champ

Par exemple : [Link] ← 2019 ; affecte la valeur 2019 au champ année de

l’enregistrement « DtOuverture » qui est lui-même un champ de l’enregistrement « c ». Tel
que « c » est une variable de type « Compte ».

Dans le cas d'un tableau, l'accès se fait comme suit :

nom_tableau[indice].variable_sous_structure.champ

Par exemple : T[i].[Link] ← 2019 ;

Où T[i] fait référence au ième élément du tableau T de type « Compte ».

6. Conclusion

Nous avons vu dans le cinquième chapitre que les tableaux sont très pratiques, cependant ils
ne permettent pas de répondre à tous les besoins de stockage tels que le regroupement de
plusieurs données de types différents en un seul objet. A cet effet, la notion de structure (ou
d’enregistrement) abordée dans le présent chapitre permet de pallier ce problème en créant
un nouveau type permettant le stockage des données de types différents ou non. Un
enregistrement qui est composé de plusieurs champs où chaque champ correspond à une
donnée, constitue la brique de base pour les structures de données telles que les listes, les
piles et les files qui ne font pas l’objet d’étude dans ce polycopié.

- 16 -
- 17 -