CodeGym /Cours /C# SELF /Les boucles imbriquées et leur utilisation

Les boucles imbriquées et leur utilisation

C# SELF
Niveau 4, Leçon 5
Disponible

1. Intro

On commence par une question : pourquoi on aurait besoin de mettre une boucle dans une autre ? En fait, souvent nos données ou nos problèmes sont pas juste en ligne droite, mais genre en tableau, en grille ou même en structure multidimensionnelle. Genre, tu veux afficher une table de multiplication, parcourir un tableau à deux dimensions ou compter les intersections entre toutes les paires d’éléments. Là, une seule boucle, ça suffit pas — il te faut une boucle dans une boucle.

En prog, une boucle imbriquée, c’est comme deux réveils : le réveil extérieur sonne, et à l’intérieur, t’en as un autre qui va sonner à chaque fois tant que le premier est actif. Donc, pendant qu’une itération "extérieure" tourne, la boucle intérieure fait tout son tour (et recommence pour chaque itération extérieure).

Un bon exemple — les heures et les minutes. Les heures, c’est la boucle extérieure de 0 à 23, les minutes — la boucle intérieure de 0 à 59. À chaque changement de l’heure, la boucle des minutes a le temps de passer tous ses états.

2. Syntaxe des boucles imbriquées

En C#, la syntaxe des boucles imbriquées, c’est pareil que pour les boucles normales — tu mets juste une boucle dans le corps d’une autre. Mate les exemples avec for et while :


for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)
    {
        Console.Write($"{i},{j} ");
    }
    Console.WriteLine();
}
Boucles imbriquées for pour afficher les coordonnées

Ici, la boucle extérieure contrôle la variable i (de 0 à 2), et la boucle intérieure — la variable j (de 0 à 3). Pour chaque valeur de i, la boucle intérieure va de j=0 à j=3. Si tu lances ce code, tu verras un joli tableau de coordonnées :

0,0 0,1 0,2 0,3 
1,0 1,1 1,2 1,3 
2,0 2,1 2,2 2,3 

Même exemple mais avec while :

int i = 0;
while (i < 3)
{
    int j = 0;
    while (j < 4)
    {
        Console.Write($"{i},{j} ");
        j++;
    }
    Console.WriteLine();
    i++;
}

Fais gaffe : à chaque passage de la boucle extérieure, la variable de la boucle intérieure (j) doit être réinitialisée, sinon tu verras qu’une seule ligne !

3. Exemples d’utilisation des boucles imbriquées

Exemple 1 : affichage d’un échiquier (8x8)

Première mission — afficher un échiquier classique à l’écran avec des cases noires et blanches (genre # — noir, _ — blanc). On fait ça avec des boucles imbriquées for :


for (int row = 0; row < 8; row++)
{
    for (int col = 0; col < 8; col++)
    {
        if ((row + col) % 2 == 0)
            Console.Write("_");
        else
            Console.Write("#");
    }
    Console.WriteLine();
}
Boucles imbriquées pour afficher un échiquier

Résultat :

_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_

Point important : l’imbrication fait que pour chaque ligne (row), on parcourt toutes les colonnes (col). Sans imbrication, t’aurais qu’une ligne ou qu’une colonne, pas un plateau d’échecs.

Exemple 2 : table de multiplication

Un classique pour les boucles imbriquées ! On va afficher la table de multiplication de 1 à 9 :


for (int i = 1; i <= 9; i++)
{
    for (int j = 1; j <= 9; j++)
    {
        Console.Write($"{i * j,3} ");
    }
    Console.WriteLine();
}
Boucles imbriquées pour afficher la table de multiplication

Le formatage ${i * j,3} ajoute des espaces pour que la table soit bien alignée.

Résultat :

   1   2   3   4   5   6   7   8   9
  2   4   6   8  10  12  14  16  18 
  3   6   9  12  15  18  21  24  27 
  4   8  12  16  20  24  28  32  36 
...
  9  18  27  36  45  54  63  72  81 

4. Boucles imbriquées et gestion — subtilités

À propos de break et continue dans les boucles imbriquées

Là, beaucoup de débutants se plantent ! Si tu utilises break ou continue dans la boucle intérieure, ça agit que sur cette boucle-là. L’extérieure continue comme si de rien n’était.


for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (j == 3)
            break; // on sort juste de la boucle intérieure !
        Console.Write($"{i},{j} ");
    }
    Console.WriteLine();
}
break sort seulement de la boucle intérieure

Résultat :

0,0 0,1 0,2 
1,0 1,1 1,2 
2,0 2,1 2,2 

Si tu veux sortir direct des deux boucles (genre, arrêter la recherche dès que t’as trouvé ce que tu veux dans un tableau), en général tu utilises un flag ou une astuce (genre return — si tout est dans une fonction).

5. Visualiser les boucles imbriquées

Des fois, c’est pas évident de "voir" l’ordre d’exécution des boucles imbriquées. Regarde ce schéma :

Visualisation des boucles imbriquées

En mode tableau — combien d’itérations au total si i va de 1 à 3, j de 1 à 4 ?

i j (parcouru pour chaque i) Itérations de la boucle intérieure
1 1, 2, 3, 4 4
2 1, 2, 3, 4 4
3 1, 2, 3, 4 4
Total : 3 × 4 = 12

6. Erreurs et pièges avec les boucles imbriquées

Erreur fréquente — mal initialiser la variable de la boucle intérieure. Genre, tu la déclares en dehors de la boucle extérieure, mais tu la remets pas à zéro à chaque tour. Résultat : la boucle intérieure peut ne jamais tourner, ou tourner n’importe comment.

int j = 0;
for (int i = 0; i < 3; i++)
{
    while (j < 4) // Oups ! j peut déjà valoir 4 après la première itération.
    {
        Console.Write($"{i},{j} ");
        j++;
    }
    Console.WriteLine();
}

Ici, la boucle ne tournera qu’une seule fois. Pense à initialiser les variables des boucles intérieures à l’intérieur des extérieures !

Aussi, si tu mets deux boucles imbriquées avec les mêmes variables par erreur, le compilateur va râler : la variable est déjà définie.


for (int i = 0; i < 3; i++)
{
    for (int i = 0; i < 3; i++)
    {
        Console.Write($"{i},{i} ");
    }
    Console.WriteLine();
}
2
Mission
C# SELF, niveau 4, leçon 5
Bloqué
Échiquier
Échiquier
2
Mission
C# SELF, niveau 4, leçon 5
Bloqué
Table de multiplication
Table de multiplication
1
Étude/Quiz
Les boucles, niveau 4, leçon 5
Indisponible
Les boucles
Boucles imbriquées et leur utilisation
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION