Stockage des données
Disons que vous avez développé un jeu informatique appelé "User Hostile" dans lequel les joueurs s'affrontent contre une interface informatique complexe et peu conviviale. Vous devez maintenant écrire un programme qui suit les ventes mensuelles de ce jeu sur une période de cinq ans. Ou disons que vous devez faire l'inventaire des cartes à collectionner Hacker Hero.
Très bientôt, vous arriverez à la conclusion que vous avez besoin de plus que de simples types de données de base pour stocker et traiter les informations.
Tableaux (listes). Présentation
Afin de faciliter le travail avec une grande quantité de données, un groupe de cellules reçoit un nom commun. Un tel groupe de cellules est appelé un tableau
Array – il s'agit d'un groupe de cellules mémoire de même type, situées côte à côte et ayant un nom commun. Chaque cellule du groupe a un numéro unique.
Lorsque vous travaillez avec des tableaux, vous devez apprendre à résoudre trois tâches :
X allouer de la mémoire de la taille requise pour un tableau
X écrire des données dans la cellule souhaitée
X lire les données de la cellule
Tableaux en Pascal
Pascal utilise traditionnellement des tableaux statiques comme
var a : tableau [1..10] d'entiers ;
Les limites d'un tableau doivent être définies par des constantes et vous ne pouvez pas modifier la taille d'un tableau pendant le fonctionnement du programme. Mais vous pouvez faire un index non seulement d'un entier, mais aussi, disons, d'un caractère ou d'un type énuméré. Par exemple, pour compter l'occurrence de chaque lettre, vous pouvez utiliser un tableau
var LettersCount : tableau ['a'..'z'] d'entiers ;
et travaillez-le comme bon vous semble :
LettersCount['z'] := 1;
LettersCount['d'] := LettersCount['d'] + 1;
Les inconvénients de tels tableaux sont connus : si le nombre d'éléments à utiliser n'est pas connu à l'avance, la taille maximale de la mémoire est allouée au tableau. En conséquence, dans la plupart des cas, nous "stockons pour l'avenir", et parfois cette "réserve" s'avère insuffisant. C'est pourquoi de tels tableaux sont appelés statiques : leur taille est statique et doit être définie lors de la compilation du programme. Cependant, en Pascal, il existe des tableaux dynamiques, dont la taille peut non seulement être définie, mais également modifiée au cours du programme. Ce sont ces tableaux et les avantages de leur utilisation qui seront discutés plus loin.
Création d'un tableau
Lors de la création d'un tableau, de l'espace est alloué en mémoire (un certain nombre de cellules)
1) Les tableaux peuvent être créé en listant simplement les éléments :
var a : tableau d'entiers ;
SetLength(a, 3);
un[0] := 1;
un[1] := 2;
a[2] := 3;
2) Les tableaux peuvent être composés de données de n'importe quel type - nombres entiers ou réels, chaînes de caractères
var a : tableau de caractères ;
SetLength(a, 3);
un[0] := 'un';
un[1] := 'b';
un[2] := 'c';
3) Un tableau "sait" toujours ta taille. La fonction length est utilisée pour déterminer la taille d'un tableau. Souvent, la taille du tableau est stockée dans une variable distincte afin que le programme puisse être facilement modifié pour fonctionner avec une taille de tableau différente. Exemple:
N := 10; // dans la variable N on stocke la taille du tableau
SetLength(a, N); // définit le tableau et la taille N
writeln(longueur(a)); // affiche la taille du tableau
La taille d'un tableau peut être définie à partir du clavier.
|
Référencer un élément de tableau
Une grande partie de l'utilité des tableaux vient du fait que ses éléments sont accessibles individuellement.
La façon de faire est d'utiliser un index pour numéroter les éléments.
Index est une valeur qui pointe vers un élément de tableau spécifique
SOUVENEZ-VOUS !
LA NUMEROTATION DES TABLEAUX EN PASCAL COMMENCE A ZERO !
(Ceci est obligatoire - vous devez recommencer à zéro. Il est particulièrement important de s'en souvenir)
Exemples d'accès au tableau A :
x := (A[3] + 5) * A[1] // lit les valeurs de A[3] et A[1]
A[0] := x + 6 // écrit une nouvelle valeur dans A[0]
Analysons le programme pour travailler avec des éléments de tableau.
var i : entier ;
a : tableau d'entiers ;
commencer
je := 1;
setlength(a, 5); //crée un tableau de 5 éléments
un[0] := 23; // à chacun des 5 éléments du tableau (indices de 0 à 4)
a[1] := 12; // écrit une valeur spécifique
a[2] := 7;
a[3] := 43;
a[4] := 51;
un[2] := un[je] + 2 * un[je - 1] + un[2 * je] ; // change la valeur de l'élément d'index 2 par le résultat de l'expression
// parce que i=1, puis en substituant la valeur de la variable i dans l'expression que nous obtenons
// expression suivante a[2] := a[1] + 2*a[0] + a[2];
écrireln(a[2] + a[4]);
fin.
À la suite de l'exécution ce programme la valeur de la somme des éléments du tableau d'indice 2 et d'indice 4 égal à 116 apparaîtra à l'écran. Comme vous pouvez le voir dans l'exemple, nous pouvons accéder à n'importe quel élément du tableau . Et calculez également le nombre requis d'éléments à l'aide de diverses formules (par exemple, comme dans le programme A[i-1] ou A[2*i], dans ces cas, les indices des éléments seront calculés et dépendront de la valeur de i.)
Regardons un exemple de programme
var a : tableau d'entiers ;
commencer
setlength(a, 5);
a[5] := 5;
un[-1] := 0;
fin.
Parce que le tableau est déclaré avec 5 éléments, donc les éléments seront numérotés de 0 à 4. Nous voyons que le programme de la 6ème ligne fait référence à un élément inexistant а [5] et sur la 7ème ligne au également inexistant a[-1].
Il s'avère que le programme a dépassé les limites du tableau
Le tableau hors limites accède à un élément avec un index qui n'existe pas dans le tableau.
Dans de tels cas, le programme se bloque généralement avec erreur d'exécution
|
Lorsque vous travaillez avec des tableaux, vous devez généralement travailler avec tous les éléments du tableau à la fois.
Itération à travers les éléments : nous parcourons tous les éléments du tableau et, si nécessaire, effectuons une opération sur chacun d'eux.
Pour cela, on utilise le plus souvent une boucle avec une variable, qui passe de 0 à N-1, où N est le nombre d'éléments du tableau.
Sous N, nous considérerons la taille actuelle du tableau, c'est-à-dire
N := longueur(A)
...
for i := 0 to n - 1 do begin
// ici on travaille avec a[i]
fin;
...
Dans la boucle spécifiée, la variable i prendra les valeurs 0, 1, 2, ..., N-1. Ainsi, à chaque étape de la boucle, on accède à un élément spécifique du tableau avec le numéro i.
Ainsi, il suffit de décrire ce qu'il faut faire avec un élément du tableau a[i] et de placer ces actions à l'intérieur d'un tel cycle.
Écrivons un programme qui remplit le tableau avec les N premiers nombres naturels, c'est-à-dire qu'à la fin du programme, les éléments du tableau doivent devenir égaux
un[0] = 1
un[1] = 2
a[2] = 3
...
a[N - 1] = N
Il est facile de voir le modèle : la valeur d'un élément de tableau doit être supérieure de 1 à l'indice de l'élément.
La boucle ressemblera à ceci
pour i := 1 à n - 1 faire
un[je] := je + 1;
Terminez la tâche.
|