Travail avancé avec les tableaux

1. Tableau de type string

Bon, en bref, j’aimerais te parler du tableau de type string.

Comme on l’a déjà dit, un tableau peut être de n’importe quel type. Donc, tu peux créer un tableau de type string. Voilà à quoi ressemblerait le code si on devait écrire un programme qui « lit 10 lignes au clavier et les affiche à l’écran dans l’ordre inverse ».

string[] array = new string[10];	// On crée un objet-tableau de 10 éléments
for (int i = 0; i < 10; i++)		// Boucle de 0 à 9
{
   array[i] = Console.ReadLine();	// On lit une ligne du clavier et on la stocke dans la case du tableau
}
for (int i = 9; i >= 0; i--)		// Boucle de 9 à 0
{
    Console.WriteLine(array[i]);	// On affiche à l’écran la case courante du tableau
}

Le code n’a quasiment pas changé ! Il a juste fallu remplacer le type int par string à la création du tableau. Pour le reste, c’est exactement pareil !

2. Tableau de type string en mémoire

Et encore un truc utile. Regarde ces 3 images :

Image 1. Comment un objet string est placé en mémoire :

Fais gaffe, le texte de la chaîne n’est pas stocké direct dans la variable : il y a un bloc mémoire séparé pour ça. Et dans la variable de type string, c’est juste l’adresse (la référence) vers l’objet contenant le texte.

Image 2. Comment un tableau d’entiers est placé en mémoire :

Tu as déjà vu cette image aussi.

Image 3. Comment un tableau de chaînes est placé en mémoire :

À gauche, on voit la variable-tableau de type string[] (elle stocke l’adresse de l’objet-tableau).
Au milieu — l’objet-tableau de type string.
Et à droite — les objets-string qui contiennent les textes.

Dans les cases de l’objet-tableau de type string, ce ne sont pas les chaînes elles-mêmes (les textes) qui sont stockées, mais leurs adresses (références). Exactement comme dans les variables de type string, c’est l’adresse du texte qui est stockée.

3. Initialisation rapide d’un tableau en C#

Les tableaux, c’est super utile, donc les devs de C# ont essayé de rendre leur utilisation la plus pratique possible. Et la première chose qu’ils ont faite — c’est simplifier l’initialisation du tableau, c’est-à-dire lui donner des valeurs de départ.

Parce que souvent, en plus des données que le programme lit quelque part, il a aussi besoin de ses propres données internes. Par exemple, il faut stocker dans un tableau la longueur de chaque mois. À quoi ça peut ressembler :

int[] months = new int[12];
months[0] = 31; // janvier
months[1] = 28; // février
months[2] = 31; // mars
months[3] = 30; // avril
months[4] = 31; // mai
months[5] = 30; // juin
months[6] = 31; // juillet
months[7] = 31; // août
months[8] = 30; // septembre
months[9] = 31; // octobre
months[10] = 30; // novembre
months[11] = 31; // décembre

Mais il y a moyen de faire plus court — merci aux créateurs de C# :

// longueurs des mois de l’année
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Tu peux juste lister toutes les valeurs du tableau, séparées par des virgules !

Pratique, non ? Mais ce n’est pas tout.

En fait, le compilateur peut deviner le type du conteneur (l’objet-tableau) à partir du type de la variable-tableau. Et pour la longueur du tableau — il compte juste le nombre d’éléments entre les accolades.

Donc ce code peut être encore plus court :

// longueurs des mois de l’année
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Avoue, c’est beau, non ? 🙂

Ce genre d’écriture s’appelle « initialisation rapide du tableau ». Et ça marche pas que pour int...

// noms des mois de l’année
string[] months = { "Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"};

4. La boucle foreach

Parcourir tous les éléments d’un tableau, c’est tellement courant qu’il existe une boucle spéciale pour ça (!). Elle s’appelle foreach. Et ça s’écrit comme ça :

foreach (int score in scores)
{
    Console.WriteLine($"Points : {score}");
}
        

Ici, la boucle parcourt elle-même les éléments — pas besoin d’indice manuel. Tu ne peux pas modifier les éléments directement (ils sont accessibles en lecture seule dans la boucle), mais c’est super pratique pour juste « balayer » le tableau.

Le compilateur transforme le code de la boucle foreach en ce code-là :

for (int i = 0; i < scores.Length; i++)
{
    int score = scores[i];
    Console.WriteLine($"Points : {score}");
}
        

Donc, pas de magie. Mais maintenant tu piges pourquoi tu ne peux pas modifier les éléments du tableau via la variable score.

Allez, encore un exemple : on va calculer la somme de tous les points.

int sum = 0;
foreach (int score in scores)
{
    sum += score;
}
Console.WriteLine($"Somme de tous les points : {sum}");
        

Quand utiliser quelle boucle ?

• Si tu as besoin de l’indice ou que tu veux modifier les éléments — utilise la boucle for.
• Si tu veux juste parcourir les valeurs — foreach est plus rapide et plus clean.

5. Indexation depuis la fin : opérateur ^

Depuis quelque temps en C#, tu peux accéder aux éléments depuis la fin du tableau. Avant, si tu voulais le dernier élément, tu faisais un truc du genre :

int lastScore = scores[scores.Length - 1];
        

Maintenant, c’est beaucoup plus simple. Il suffit de mettre l’opérateur ^ devant l’indice, et ça compte à partir de la fin :

int lastScore = scores[^1];        // Dernier élément
int penultimate = scores[^2];      // Avant-dernier élément
        

• ^1 — c’est le premier depuis la fin (le dernier).
• ^2 — c’est le deuxième depuis la fin.

Visualisation

score[^1] = 17, score[^2] = 22 — easy et clair.

Important ! Fais gaffe, les indices depuis la fin commencent à 1, pas à zéro.

6. Ranges : opérateur .. (range)

Parfois, tu veux récupérer un sous-tableau à partir d’un tableau existant. En C#, tu peux utiliser l’opérateur de range .. — c’est une façon concise et super pratique de choper le « morceau » de tableau qu’il te faut.

Ce sous-tableau, on l’appelle parfois slice (du mot anglais "slice"), et il est défini par deux bornes : début et fin.
Point important : la borne droite n’est pas incluse dans le résultat !

À quoi ça ressemble

int[] scores = { 10, 15, 8, 22, 17 };
int[] top3 = scores[0..3]; // On prend les éléments de 0 à 2 : {10, 15, 8}
        

• scores[0..3] — on prend les éléments à partir de l’indice 0 (inclus) jusqu’à l’indice 3 (NON inclus).
• Le tableau final contiendra les éléments d’indices 0, 1 et 2.

Raccourcis

Si la borne gauche n’est pas précisée, on prend depuis le tout début :

int[] firstTwo = scores[..2]; // pareil que scores[0..2], donc {10, 15}
        

Si la borne droite n’est pas précisée, on prend jusqu’à la fin :

int[] fromThird = scores[2..]; // {8, 22, 17}
        

Indices négatifs

Avec le symbole ^, tu peux compter les indices depuis la fin :

int[] lastTwo = scores[^2..]; // {22, 17}
        

Ici, ^2 — c’est « le deuxième élément depuis la fin ».

Tu peux aussi prendre un range « du point A au point B », en utilisant des indices négatifs des deux côtés :

int[] mid = scores[1..^1]; // {15, 8, 22} (du 2e à l’avant-dernier)
        

À retenir

• La borne droite n’est jamais incluse — donc si tu écris a..b, tu obtiens tous les éléments de a à b-1.
• Si tu mets des bornes qui dépassent le tableau, tu auras une exception IndexOutOfRangeException.
• Le slice — c’est un nouveau tableau, l’original ne change pas. Toute modif dans le nouveau tableau ne touche pas l’original.

Exemples pratiques

int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };

int[] start = arr[..3];      // {1, 2, 3}
int[] end = arr[^2..];       // {6, 7}
int[] middle = arr[2..5];    // {3, 4, 5}
int[] all = arr[..];         // {1, 2, 3, 4, 5, 6, 7} (copie complète)