1. Un tableau, c’est un conteneur d’éléments
Tu as sûrement déjà entendu que les ordis peuvent gérer des quantités énormes d’infos. Les instructions conditionnelles (if-else) et les boucles (for, while), ça aide bien sûr. Mais tu ne vas pas aller loin juste avec ça, parce qu’il faut bien stocker quelque part les données que tu traites.
Pour ça, en C#, comme dans quasi tous les langages de prog, il y a un truc super pratique : les tableaux (Array). On les appelle aussi des tables.
Un tableau, c’est un objet spécial dans lequel tu peux stocker non pas une seule valeur, mais plusieurs.
Avant, on comparait une variable à une boîte (où tu peux mettre une valeur). Un tableau, c’est plutôt une boîte divisée en sections à l’intérieur. Chaque section dans la « boîte-tableau » a son numéro. Et bien sûr, la numérotation commence à zéro...
Ou alors, imagine une autre analogie. Compare une maison normale et un immeuble. Une maison normale, c’est une famille, un immeuble est divisé en appartements. Pour écrire à une famille dans une maison, tu mets juste l’adresse. Pour écrire à une famille dans un appart, il faut l’adresse de l’immeuble et le numéro d’appart.
Donc, une variable-tableau, c’est une variable-immeuble. Tu peux y stocker plusieurs valeurs. Dans cette variable, il y a plusieurs apparts (cases), et tu peux accéder à chacune par son numéro (index).
Pour ça, après le nom de la variable, tu mets l’index de la case entre crochets. C’est super simple :
array[indice] = valeur;Ici, array c’est le nom de la variable-tableau, indice c’est le numéro de la case dans le tableau, et valeur c’est la valeur que tu veux mettre dans cette case.
Mais d’abord, voyons comment créer des tableaux.
2. Créer un tableau d’éléments en C#
Imaginons que ton programme doit stocker quelque part 100 nombres entiers. Un tableau serait parfait pour ça. Mais comment on le crée ?
Si tu voulais stocker un seul entier, tu prendrais le type int. Mais si tu veux stocker 100 entiers, il te faut sûrement un tableau de int. Voilà à quoi ressemble le code pour le créer :
int[] array = new int[100];
Voyons ce que ça veut dire.
Comme tu l’as peut-être deviné, à gauche du signe égal, on déclare une variable qui s’appelle array et qui est de type int[]. Après le type int, il y a des crochets, ce qui veut dire qu’on pourra stocker plusieurs valeurs dans ces « boîtes ».
À droite du signe égal, on a « création d’un objet » (le mot new) de 100 éléments (cases) de type int. Pas bien compliqué non plus.
Si on voulait, par exemple, créer un tableau de 20 cases pour stocker des nombres à virgule, le code ressemblerait à ça :
double[] vals = new double[20];Le nombre de cases dans un tableau s’appelle la taille du tableau ou longueur du tableau. Et comme il peut stocker plein de valeurs, on appelle aussi les tableaux des conteneurs.
Fait important : la taille du conteneur-tableau ne peut pas être changée après création.
Tu peux créer un nouveau, mais tu ne peux pas changer la longueur d’un tableau déjà créé.
3. Travailler avec les cases d’un tableau
Ok, on sait créer des tableaux, mais comment on bosse avec ?
Presque pareil qu’avec des variables normales, sauf qu’après le nom de la variable-tableau, il faut toujours préciser le numéro de la case avec laquelle tu bosses.
La numérotation des cases commence toujours à zéro. Si tu as un tableau de 10 éléments, les numéros (index) de ses cases sont 0..9, si c’est un tableau de 200 éléments, alors 0..199. Et ainsi de suite.
Exemples :
int[] a = new int[10]; // On crée un tableau de 10 éléments de type int.
a[2] = 4; // On met la valeur 4 dans la case d’index 2.
a[7] = 9; // On met la valeur 9 dans la case d’index 7.
a[9] = a[2] + a[5]; // On met dans la case d’index 9 la somme des valeurs des cases 2
// (il y a 4) et 5 (il y a 0).
Voilà ce qui sera stocké en mémoire après ce code :
La colonne à gauche du tableau (en gris), ce sont les numéros (index) des cases. Dans les cases, tu retrouves les valeurs qu’on a mises : 4, 9 et 4. Juste après la création, toutes les cases du tableau sont remplies de zéros.
Important. Toutes les cases d’un tableau ont le même type de données. Si tu as créé un tableau de chaînes string, tu ne peux y mettre que des chaînes. Le type du tableau est défini à la création. Ni le type, ni la longueur ne peuvent être changés après.
4. Tableaux en mémoire
Les images des exemples précédents ne sont pas tout à fait exactes.
Quand tu crées des tableaux (comme pour les chaînes), la mémoire est découpée en deux blocs : un pour stocker le tableau (le conteneur), et un autre pour la variable qui garde son adresse. Voilà la vraie situation sur l’image ci-dessous :
En vert, tu vois un tableau de 10 éléments de type int et une variable de type int[] qui stocke l’adresse (référence) du tableau de int en mémoire.
Pour comparer, en bleu, c’est une variable normale de type int qui stocke la valeur 199.
Ça rappelle un peu comment les chaînes sont stockées en mémoire, non ?
Exactement, les chaînes. Et comme avec les chaînes, tu peux affecter une variable-tableau à une autre :
int[] a = new int[10]; // On crée un tableau de 10 éléments de type int.
a[2] = 4; // On met la valeur 4 dans la case d’index 2.
a[7] = 9; // On met la valeur 9 dans la case d’index 7.
int[] b = a; // On met dans la variable b l’adresse qui est dans la variable a.
// Maintenant, a et b pointent vers le même objet-tableau en mémoire.
a[9] = b[2] + a[7]; // On met dans la case d’index 9 du tableau la somme des valeurs
// des cases 2 (il y a 4) et 7 (il y a 9).
Le tableau-objet reste là où il est, et les variables a et b gardent la même adresse (référence) vers le même objet. Regarde l’image :
5. Travailler avec un tableau plus en détail
Tu peux créer un tableau de n’importe quel type. Il suffit de mettre des crochets après le nom du type. La forme générale pour créer un tableau, c’est :
type[] nom = new type[quantité];Ici, type c’est le type des éléments (cases) du tableau, nom c’est le nom de la variable pour accéder au tableau, et quantité c’est le nombre de cases dans le tableau.
Dans l’exemple ci-dessus, c’est la forme canonique : création de la variable-tableau et création de l’objet-tableau. Mais en vrai, ce sont deux trucs indépendants. Tu peux créer la variable-tableau et l’objet-tableau séparément :
type[] nom;
nom = new type[quantité];
Encore un point important
Comme index du tableau et comme quantité d’éléments, tu peux utiliser des variables ou même des expressions complètes.
Exemples :
int n = 100;
int[] a = new int[n]; // Création d’un tableau de n éléments
int n = 100;
int[] a = new int[n * 2 + 3]; // Création d’un tableau de 203 éléments
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2]; // a[20] = a[99] + a[98];
Dépasser les limites du tableau
Fais gaffe : si tu essaies d’accéder à une case du tableau avec un index qui n’existe pas (dans notre cas, tout entier sauf 0..99), le programme va planter avec l’erreur IndexOutOfRangeException — index hors limites du tableau.
6. Longueur du tableau
Comme on l’a vu dans l’exemple précédent, tu peux créer séparément une variable de type tableau et plus tard, dans le code, lui affecter une valeur (une référence vers un objet-tableau). Tu peux même faire comme ça :
int[] array; // On crée une variable-tableau de type int[]
if (a < 10) // Si la variable a est inférieure à 10,
array = new int[10]; // alors on crée un tableau de 10 éléments.
else // Sinon
array = new int[20]; // on crée un tableau de 20 éléments
Et comment on bosse avec ce tableau ensuite ? Comment savoir combien il a d’éléments ?
Pour ça, le tableau a une propriété spéciale (une variable) — length. Tu peux connaître la longueur du tableau avec cette expression :
array.Length;Ici, array c’est le nom de la variable-tableau, et Length c’est le nom de la propriété de l’objet-tableau. Tu ne peux pas changer la valeur de Length : tu peux l’assigner à d’autres variables, mais tu ne peux rien lui assigner (le programme ne compilera même pas).
Voilà comment tu peux continuer l’exemple précédent :
int[] array; // On crée une variable-tableau de type int[]
if (a < 10) // Si la variable a est inférieure à 10,
array = new int[10]; // alors on crée un tableau de 10 éléments.
else // Sinon
array = new int[20]; // on crée un tableau de 20 éléments
for (int i = 0; i < array.Length; i++) // Boucle sur tous les éléments du tableau : de 0 à array.Length – 1
{
Console.WriteLine(array[i]);
}
7. Faits sur les tableaux en C#
Petit résumé des faits à connaître sur les tableaux :
- Fait 1. Un tableau est composé de plein de cases.
- Fait 2. On accède à une case précise en donnant son numéro.
- Fait 3. Toutes les cases sont du même type.
- Fait 4. La valeur initiale de toutes les cases est 0 et null (si la case stocke une adresse), false (pour le type bool).
- Fait 5. string[] list — c’est juste la déclaration de la variable : le conteneur (l’objet-tableau) n’est pas encore créé. Pour l’utiliser, il faut créer le tableau (le conteneur) et le mettre dans cette variable, puis l’utiliser. Voir l’exemple ci-dessous.
- Fait 6. Quand tu crées un objet-tableau (conteneur), tu dois préciser sa longueur — combien il a de cases. Ça se fait avec la commande : new TypeName[n];
- Fait 7. Tu peux connaître la longueur du tableau avec la propriété .Length.
- Fait 8. Après avoir créé un tableau, tu ne peux plus changer ni le type de ses éléments, ni leur nombre.
string s; // s vaut null
string[] list; // list vaut null
list = new string[10]; // La variable list contient une référence vers un objet – un tableau de chaînes de 10 éléments.
int n = list.Length; // n vaut 10
list = new string[0]; // Maintenant list contient un tableau de 0 éléments.
// Le tableau existe, mais il ne peut rien stocker.
list = null;
Console.WriteLine(list[1]); // Ça va générer une erreur — le programme va planter.
// list contient une référence vide — null
list = new string[10];
Console.WriteLine(list[10]); // Ça va générer une erreur — dépassement des limites du tableau.
// Si list contient 10 éléments/cases, les index autorisés sont : 0 1 2 3 4 5 6 7 8 9 — soit 10 en tout.
GO TO FULL VERSION