Boucles imbriquées en C++

1. Utilisez la boucle for imbriquée pour initialiser la matrice bidimensionnelle en C++
2. Utiliser la boucle imbriquée while pour initialiser la matrice bidimensionnelle en C++
3. Utilisez la boucle imbriquée do...while pour initialiser la matrice bidimensionnelle en C++

Cet article décrira comment utiliser différentes boucles imbriquées en C++.

Utilisez la boucle for imbriquée pour initialiser la matrice bidimensionnelle en C++

Les boucles sont connues sous le nom d’instructions de flux de contrôle, qui modifient généralement le compteur du programme et forcent le processeur en cours d’exécution à passer à une instruction différente (généralement non séquentielle) dans le programme. Le compteur de programme est un registre dans le cœur du processeur qui stocke l’instruction suivante d’un programme en cours d’exécution.

Pensons en termes de représentation du programme au niveau du langage assembleur, où chaque instruction correspond à une seule instruction machine. Le code s’exécute de manière séquentielle et le processeur récupère l’instruction suivante, sauf indication contraire (en gros, car les cœurs de processeur contemporains sont des machines massivement optimisées qui peuvent récupérer plusieurs instructions et souvent à partir d’emplacements non séquentiels dans le programme). Ainsi, nous devons indiquer dans le langage assembleur avec des instructions spéciales pour transférer l’exécution vers une autre partie du programme si nous voulons implémenter une boucle.

Considérons maintenant une syntaxe de langage C++ et comment implémenter différentes instructions de flux de contrôle comme des boucles.

L’une des instructions de boucle les plus courantes dans les langages de programmation est les boucles for et while. La boucle for a la partie en-tête qui comprend des instructions en trois parties et contrôle l’exécution du corps de la boucle. Plusieurs instructions de boucle for peuvent être imbriquées les unes dans les autres, formant une construction utile pour de nombreuses tâches de programmation.

Cet article montre un exemple d’initialisation d’une matrice à deux dimensions à l’aide de boucles for imbriquées. Chaque niveau de boucle imbriquée traite une seule ligne de la matrice, nous avons donc deux niveaux dans cet exemple. Notez que nous imprimons également les éléments après l’affectation de l’entier aléatoire à la position donnée. La dernière étape sera effectuée séparément dans des scénarios du monde réel, mais cet exemple de code est uniquement à des fins éducatives.

#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;
using std::setw;

constexpr int ROW = 4;
constexpr int COL = 3;

int main() {
  int *matrix = new int[ROW * COL];

  for (int i = 0; i < ROW; ++i) {
    for (int j = 0; j < COL; ++j) {
      matrix[j * ROW + i] = rand() % 100;
      cout << setw(2) << matrix[j * ROW + i] << "; ";
    }
    cout << endl;
  }

  delete[] matrix;

  return EXIT_SUCCESS;
}

Production:

83; 86; 77;
36; 93; 35;
86; 92; 14;
22; 62; 27;

Utiliser la boucle imbriquée while pour initialiser la matrice bidimensionnelle en C++

Alternativement, nous pouvons implémenter le code précédent en utilisant des instructions de boucle while imbriquées. Dans cette variante, nous devons déclarer les variables d’index i et j en dehors du corps while et n’en initialiser qu’une seule dans la même portée.

Notez que la deuxième variable y - correspondant à la position de la colonne de la matrice est initialisée à 0 à chaque cycle de la boucle while externe. Cela garantit que la boucle interne est exécutée après le traitement de la première ligne. Nous devrions également placer des instructions d’incrémentation pour chaque variable d’index dans les portées de boucle respectives, car le while lui-même n’a que l’en-tête conditionnel qui contrôle l’itération.

#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;
using std::setw;

constexpr int ROW = 4;
constexpr int COL = 3;

int main() {
  int *matrix = new int[ROW * COL];

  int j, i = 0;
  while (i < ROW) {
    j = 0;
    while (j < COL) {
      matrix[j * ROW + i] = rand() % 100;
      cout << setw(2) << matrix[j * ROW + i] << "; ";
      j++;
    }
    i++;
    cout << endl;
  }

  delete[] matrix;

  return EXIT_SUCCESS;
}

Production:

83; 86; 77;
36; 93; 35;
86; 92; 14;
22; 62; 27;

Utilisez la boucle imbriquée do...while pour initialiser la matrice bidimensionnelle en C++

D’un autre côté, le langage C++ possède également la construction de boucle do...while, qui convient aux cas particuliers d’itération, mais nous pouvons réécrire le même extrait de code en l’utilisant.

L’instruction do...while exécute toujours la première itération. Ainsi, cet exemple ne souffrira pas de cette fonctionnalité car nous supposons que la matrice générée a au moins des dimensions 1x1.

La structure de boucle do...while est presque la même que l’exemple while ci-dessus, car ces deux-là ont un format d’en-tête similaire, qui n’inclut que l’expression conditionnelle.

#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;
using std::setw;

constexpr int ROW = 4;
constexpr int COL = 3;

int main() {
  int *matrix = new int[ROW * COL];

  int j, i = 0;
  do {
    j = 0;
    do {
      matrix[j * ROW + i] = rand() % 100;
      cout << setw(2) << matrix[j * ROW + i] << "; ";
      j++;
    } while (j < COL);
    i++;
    cout << endl;
  } while (i < ROW);

  delete[] matrix;

  return EXIT_SUCCESS;
}

Production:

83; 86; 77;
36; 93; 35;
86; 92; 14;
22; 62; 27;