C-SHARP - 4.1 Tableaux Avancés

Cette vidéo aborde une notion plus avancée des tableaux en C#. Avant d'entrer dans le vif du sujet, petit rappel : un tableau représente un nombre fixe de variables d'un même type (int, string…). On commence par recréer deux tableaux d'illustration, l'un de trois entiers avec initialisation entre accolades, l'autre de trois chaînes assignées par index :

int[] valeurs = new int[3] { 1, 2, 3 };
string[] mot = new string[3];
mot[0] = "bonjour";
mot[1] = "hello";
mot[2] = "hola";

Tableaux à plusieurs dimensions

Jusqu'ici, nous avons utilisé des tableaux à une dimension : une seule ligne, plusieurs colonnes, comme une liste. C# permet également des tableaux à deux ou trois dimensions, où chaque élément peut être lui-même un tableau. Le cas le plus courant est le tableau à deux dimensions (matrices), qui représente bien des structures du monde physique. Exemple : une classe divisée en trois groupes de trois étudiants :

var tab_dim = new string[3, 3]
{
    { "Jason",  "Thibaut", "Tom" },
    { "Marc",   "Idriss",  "Theo" },
    { "Sami",   "Lucas",   "Karim" }
};

Notez le var : il laisse le compilateur déduire le type. Les deux nombres entre crochets désignent respectivement le nombre de lignes et le nombre de colonnes.

Accès et parcours par boucles imbriquées

Pour afficher une valeur précise, on indique [ligne, colonne]. tab_dim[1, 2] donne « Tom » (2e ligne, 3e colonne). Pour parcourir l'ensemble du tableau, on utilise deux boucles for imbriquées : la boucle externe parcourt les lignes, l'interne parcourt les colonnes :

for (int i = 0; i < 3; i++)
{
    Console.WriteLine(string.Format("Groupe n {0}\n", i + 1));
    for (int j = 0; j < 3; j++)
    {
        Console.WriteLine(tab_dim[i, j]);
    }
}

Les variables i et j servent d'index dynamiques. À chaque itération de la boucle externe, on entre une nouvelle ligne et la boucle interne énumère toutes ses colonnes avant de revenir en haut. Pour illustrer : imaginez un jeu où le personnage doit monter 10 escaliers pour atteindre un étage, et atteindre le 5e étage pour gagner. Une boucle interne (10 marches) répète son action à chaque tour de la boucle externe (5 étages). C'est exactement le principe des boucles imbriquées appliquées à un tableau 2D.

En résumé

Cette leçon approfondit les connaissances sur les tableaux en C# au-delà des bases. Elle couvre les tableaux à une dimension et les tableaux multidimensionnels (2D, 3D), en montrant comment les créer, les initialiser avec ou sans valeurs préalables, et accéder à leurs éléments via l'indexation 0-based. La leçon utilise des exemples concrets, notamment un tableau 2D représentant une classe divisée en groupes d'étudiants, et introduit le mot-clé `var` pour la déclaration de variables locales.

Points clés

• Tableaux à une dimension (une ligne, plusieurs colonnes) vs tableaux multidimensionnels (plusieurs lignes et colonnes)
• Déclaration avec `new Type[size]` pour 1D et `new Type[ligne,colonne]` pour 2D ; initialisation directe avec accolades ou affectation ultérieure
• Indexation 0-based : accès via `tableau[i]` en 1D ou `tableau[i,j]` en 2D pour récupérer un élément
• Le mot-clé `var` permet au compilateur de déduire automatiquement le type à partir de la valeur d'initialisation
• Tableaux multidimensionnels idéaux pour représenter des structures 2D du monde réel (grilles, matrices, données tabulaires)

Questions fréquentes

Comment créer et initialiser un tableau à deux dimensions en C# ?

On déclare avec `var nomTableau = new Type[ligne,colonne]` (ex: `new string[3,3]`), puis on remplit avec des accolades imbriquées contenant les valeurs : `{ { "val1", "val2", "val3" }, ... }`. Alternativement, on peut initialiser l'espace vide et affecter les valeurs élément par élément ensuite.

Comment accéder à une valeur spécifique dans un tableau 2D ?

On utilise la notation `tableau[ligne,colonne]` où ligne et colonne sont les indices commençant à 0. Par exemple, `mots[1,2]` accède à l'élément situé à la 2e ligne (index 1) et 3e colonne (index 2).

Quel est l'avantage du mot-clé `var` ?

Le mot-clé `var` permet de déclarer une variable locale sans spécifier son type explicitement — le compilateur le déduit automatiquement. Cela rend le code plus lisible et flexible, particulièrement utile avec les structures complexes comme les tableaux multidimensionnels.