1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Boucles For-each C++

abdelouafiDec 1, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      865
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      Dans la leçon 6.3 - Tableaux et boucles, nous avons montré des exemples dans lesquels nous utilisions une boucle for pour parcourir chaque élément d'un tableau.

      Par exemple:
      Code:
      #include <iostream>
      int main()
      {
          const int numStudents = 5;
          int scores[numStudents] = { 84, 92, 76, 81, 56 };
          int maxScore = 0; // keep track of our largest score
          for (int student = 0; student < numStudents; ++student)
              if (scores[student] > maxScore)
                  maxScore = scores[student];
          std::cout << "The best score was " << maxScore << '\n';
          return 0;
      }
      Bien que les boucles for fournissent un moyen pratique et flexible de parcourir une matrice, elles sont également faciles à gâcher et sont sujettes à des erreurs erronées.

      C ++ 11 introduit un nouveau type de boucle appelé boucle for-each (également appelée boucle for basée sur une plage) qui fournit une méthode plus simple et plus sûre pour les cas dans lesquels nous souhaitons parcourir tous les éléments d'un tableau (ou autre liste). -type de structure).

      Boucles For-each

      L'instruction for-each a une syntaxe qui ressemble à ceci:
      Code:
      for (element_declaration : array)
         statement;
      Lorsque cette instruction est rencontrée, la boucle parcourt chaque élément du tableau en affectant la valeur de l'élément de tableau en cours à la variable déclarée dans déclaration_élément. Pour de meilleurs résultats, déclaration_élément devrait avoir le même type que les éléments du tableau, sinon la conversion de type se produira.

      Jetons un coup d’œil à un exemple simple qui utilise une boucle for-each pour imprimer tous les éléments d’un tableau nommé fibonacci:
      Code:
      #include <iostream>
      int main()
      {
          int fibonacci[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
          for (int number : fibonacci) // iterate over array fibonacci
             std::cout << number << ' '; // we access the array element for this iteration through variable number
          return 0;
      }
      ce programme affiche:
      0 1 1 2 3 5 8 13 21 34 55 89



      Voyons de plus près comment cela fonctionne. Tout d'abord, la boucle for s'exécute et le numéro de variable est défini sur la valeur du premier élément, qui a la valeur 0. Le programme exécute l'instruction qui affiche 0. La boucle for s'exécute à nouveau et le nombre est défini sur la valeur le deuxième élément, qui a la valeur 1. L'instruction s'exécute à nouveau, laquelle imprime 1. La boucle for continue à parcourir successivement chacun des nombres, en exécutant l'instruction pour chacun jusqu'à ce qu'il ne reste plus d'éléments dans le tableau à itérer. plus de. À ce stade, la boucle se termine et le programme continue son exécution (renvoyant 0 au système d'exploitation).

      Notez que le numéro de variable n'est pas un index de tableau. La valeur de l’élément de tableau est affectée à l’itération de la boucle en cours.

      Pour chaque boucle et le mot clé auto

      Etant donné que déclaration_élément devrait avoir le même type que les éléments de tableau, il s'agit d'un cas idéal pour utiliser le mot clé auto et laisser C ++ en déduire le type des éléments de tableau pour nous.

      Voici l'exemple ci-dessus, en utilisant auto:
      Code:
      #include <iostream>
      int main()
      {
          int fibonacci[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
          for (auto number : fibonacci) // type is auto, so number has its type deduced from the fibonacci array
             std::cout << number << ' ';
          return 0;
      }
      Boucles et références for-each

      Dans les exemples pour-each ci-dessus, nos déclarations d'élément sont déclarées par valeur:
      Code:
      int array[5] = { 9, 7, 5, 3, 1 };
          for (auto element: array) // element will be a copy of the current array element
              std::cout << element << ' ';
      Cela signifie que chaque élément du tableau itératif sera copié dans un élément variable. La copie des éléments d'un tableau peut être coûteuse et la plupart du temps, nous souhaitons simplement nous référer à l'élément d'origine. Heureusement, nous pouvons utiliser des références pour cela:
      Code:
       int array[5] = { 9, 7, 5, 3, 1 };
          for (auto &element: array) // The ampersand makes element a reference to the actual array element, preventing a copy from being made
              std::cout << element << ' ';
      Dans l'exemple ci-dessus, element sera une référence à l'élément de tableau actuellement itéré, évitant ainsi de faire une copie. De plus, toute modification apportée à l'élément affectera le tableau sur lequel on effectue une itération, chose impossible si l'élément est une variable normale.

      Et bien sûr, c’est une bonne idée de rendre votre élément constant si vous avez l’intention de l’utiliser en lecture seule:
      Code:
       int array[5] = { 9, 7, 5, 3, 1 };
          for (const auto &element: array) // element is a const reference to the currently iterated array element
              std::cout << element << ' ';
      Règle: dans les déclarations d'élément de boucles for-each, si vos éléments sont des types non fondamentaux, utilisez des références ou des références const pour des raisons de performances.

      Réécrire l'exemple des scores maximum en utilisant une boucle for-each

      Voici l’exemple en haut de la leçon réécrit en utilisant une boucle pour chaque boucle:
      Code:
      #include <iostream>
      int main()
      {
          const int numStudents = 5;
          int scores[numStudents] = { 84, 92, 76, 81, 56 };
          int maxScore = 0; // keep track of our largest score
          for (const auto &score: scores) // iterate over array scores, assigning each value in turn to variable score
              if (score > maxScore)
                  maxScore = score;
          std::cout << "The best score was " << maxScore << '\n';
          return 0;
      }
      Notez que dans cet exemple, il n'est plus nécessaire d'indiquer manuellement le tableau. Nous pouvons accéder à l'élément de tableau directement par le biais de score variable.

      Boucles For-each et non-array

      Les boucles For-each ne fonctionnent pas uniquement avec des tableaux fixes, elles fonctionnent avec de nombreux types de structures de type liste, telles que des vecteurs (par exemple, std :: vector), des listes chaînées, des arbres et des cartes. Nous n’avons encore couvert aucun de ces problèmes, alors ne vous inquiétez pas si vous ne savez pas ce qu’ils sont. Rappelez-vous simplement que pour chaque boucle, il existe un moyen générique et flexible d’itérer plus que des tableaux.
      Code:
      #include <vector>
      #include <iostream>
      int main()
      {
          std::vector<int> fibonacci = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 }; // note use of std::vector here rather than a fixed array
          for (const auto &number : fibonacci)
              std::cout << number << ' ';
          return 0;
      }
      For-each ne fonctionne pas avec les pointeurs vers un tableau

      Pour pouvoir parcourir le tableau, for-each a besoin de connaître la taille du tableau, ce qui signifie connaître la taille du tableau. Comme les tableaux décomposés en pointeur ne connaissent pas leur taille, les boucles for-each ne fonctionneront pas avec elles!
      Code:
      #include <iostream>
      int sumArray(int array[]) // array is a pointer
      {
          int sum = 0;
          for (const auto &number : array) // compile error, the size of array isn't known
              sum += number;
          return sum;   
      }
      int main()
      {
           int array[5] = { 9, 7, 5, 3, 1 };
           std::cout << sumArray(array); // array decays into a pointer here
           return 0;
      }
      De même, les tableaux dynamiques ne fonctionneront pas avec des boucles for-each pour la même raison.

      Puis-je obtenir l'index de l'élément actuel?

      Les boucles For-each ne fournissent pas un moyen direct d'obtenir l'index de tableau de l'élément en cours. En effet, beaucoup de structures avec lesquelles des boucles for-each peuvent être utilisées (telles que des listes chaînées) ne sont pas directement indexables!

      Conclusion

      Les boucles For-each fournissent une syntaxe supérieure pour effectuer une itération dans un tableau lorsqu'il est nécessaire d'accéder à tous les éléments du tableau dans l'ordre séquentiel des transferts. Il doit être préféré à la norme pour la boucle dans les cas où il peut être utilisé. Pour éviter de copier chaque élément, la déclaration d'élément doit idéalement être une référence.

      Notez que chaque élément ajouté en C ++ 11 ne fonctionnera pas avec les compilateurs ne prenant pas en charge C ++ 11.

      Quiz

      Celui-ci devrait être facile.

      1) Déclarez un tableau fixe avec les noms suivants: Alex, Betty, Caroline, Dave, Emily, Fred, Greg et Holly. Demandez à l'utilisateur d'entrer un nom. Utilisez un pour chaque boucle pour voir si le nom saisi par l'utilisateur se trouve dans le tableau.

      Exemple de sortie:
      Entrez un nom: Betty
      Betty a été retrouvée.
      Entrez un nom: Megatron
      Megatron n'a pas été trouvé.
      Astuce: utilisez std :: string comme type de tableau.
       
      Loading...
      Code:
      #include <iostream>
      #include <string>
      int main()
      {
          const std::string names[] = { "Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly" };
         
          std::cout << "Enter a name: ";
          std::string username;
          std::cin >> username;
          bool found(false);
          for (const auto &name : names)
              if (name == username)
              {
                  found = true;
                  break;
              }
          if (found)
              std::cout << username << " was found.\n";
          else
              std::cout << username << " was not found.\n";
          return 0;
      }

Share This Page

Share
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation