Bonsoir,

Je suis un peu nouveau en C++, après avoir appris les bases et les généralités du langage, j'ai voulu me lancer un peu dans des interfaces graphiques simples et je suis tombé sur la SFML, qui est une bibliothèque que j'apprécie beaucoup pour sa simplicité et son intégration facile. Bref au hasard de mes explorations, j'ai voulu faire un petit programme qui teste si des touches ont été appuyées. Je savais que les touches du clavier étaient référencées par la bibliothèques dans un genre de liste, membre de la classe Keyboard (qui est une classe statique, je crois, qu'on n'a pas besoin d'instancier en tous cas). Et c'est là que je suis tombé sur le type "enum", que je n'ai pas bien compris et je n'ai pas trouvé beaucoup d'infos intéressantes. Ce que j'ai trouvé dans le Keyboard.hpp, entre autre, c'est ça: 

 enum Key
    {
        Unknown = -1, ///< Unhandled key
        A = 0,        ///< The A key
        B,            ///< The B key
        C,            ///< The C key
        D,            ///< The D key
        E,            ///< The E key
     //...et ainsi de suite
    };

Et voilà, moi, ce que je voudrais faire, c'est une boucle (qui s'exécute à chaque tick mais ça c'est pas le problème) et qui teste si la touche A a été pressée, puis si la touche B a été pressée...tout cela sans avoir besoin de réécrire A,B,C,D...dans un nouveau tableau. En clair j'aimerais itérer ou au moins avoir accès aux "valeurs" de l'enum pour pouvoir checker une par une chaque valeur, un peu faire un foreach sur l'enum, mais je ne sais pas trop si c'st possible puisque de ce que j'ai compris, une enum n'est qu'une variable classique qui peut prendre différentes valeurs définies. Mais bon ces valeurs elles doivent bien être stockées quelque part, et j'aimerais bien y avoir accès. Merci beaucoup pour votre aide, je trouve ça déplorable qu'il n'existe pas de documentation officielle du c++ et du std::, d'ailleurs, en aparté, si vous connaissez des sites clairs et concis avec des exemples qui décrivent un peu tout ça, je serai vraiment preneur (en français ou en anglais). Merci beaucoup !

Bonsoir, pas besoin de "parcourir" l'énumération, tu te dis bien que SFML ne propose pas seulement une énumération des touches de ton clavier mais propose également de nombreuses méthodes et fonctions pour traiter les entrées éventuelles :

Si tu souhaites tester qu'une touche, n'importe laquelle, est pressée, tu peux simplement dans ta boucle d'évenements traiter le cas avec sf::Event::KeyPressed.

sf::RenderWindow window {/**/} ; // Ta fenêtre
sf::Event event;

while(window.pollEvent(event){
   if(event.type == sf::Event::KeyPressed)
      // Fais quelquechose

}

Maintenant tu peux être plus précis et tu peux tester si la touche pressée est la touche Entrée (par exemple) : 

sf::RenderWindow window {/**/} ; // Ta fenêtre
sf::Event event;

while(window.pollEvent(event){
   if(event.type == sf::Event::KeyPressed){

      if(event.key.code == sf::Keyboard::Enter)
         // Fais quelque chose
   }

}

Tout cela est bien mieux détaillé dans la documentation de SFML. Profite du fait que la doc SFML est vraiment très complète en plus d'être disponible en français : https://www.sfml-dev.org/index-fr.php

Ensuite, il faut que tu saches qu'une énumération n'est qu'un moyen de stocker des données qui sont représentées par des entiers. En outre un code tel que 

enum Couleur { Rouge, Vert, Bleu, Max };

Est équivalent à : 

enum Couleur { Rouge = 0 , Vert = 1, Bleu = 2, Max };

C'est pourquoi ta question initiale "parcourir l'énumération" n'a pas tellement de sens si bien qu'une simple boucle for te permette de faire cela (la taille de l'énumération étant connue avant la compilation) :

for(std::size_t k {}; k < Couleur::Max; ++k){
   
   // Tu traites ici
}

Avec évidemment Max présent dans l'énumération.

> je trouve ça déplorable qu'il n'existe pas de documentation officielle du c++ et du std::

Bien sur qu'il existe une documentation du C++ : https://en.cppreference.com/w/

Bonne soirée.

-
Edité par AmirProg 19 octobre 2020 à 21:27:53

Salut,

Le principe d'une énumération, c'est, tout simplement, d'associer un(e liste d')identifiant(s) à une (des) valeur(s) numérique(s) entière(s).

L'idée, c'est que les identifiants seront plus "en rapport" avec le domaine dans lequel ils sont utilisés, et qu'ils permettront donc "plus facilement" de manipuler les différentes valeurs numériques, sans même savoir quelle valeur est associée à quel identifiant.

Car, si nous parlons des touches du clavier, et que je te dis "teste la valeur de la touche qui est enfoncée", tu n'auras même plus à t'inquiéter du fait  que A est associé à la valeur 0 ou à la valeur 14789, tu pourras te contenter de savoir qu'il "suffit" de tester si la touche enfoncée est égale à sf::Keyboard::A, dans un code proche de

if(event.key.code == sf::Keyboard::A){
    /* ce qu'il faut faire si la touche A est enfoncée */
}else if(event.key.code == sf::Keyboard::C){
    /* ce qu'il faut faire si la touche C est enfoncée */
}/* et ainsi de suite */

De la même manière, si je voulais représenter les différents jours de la semaine, je pourrais parfaitement créer une énumération proche de

enum JoursDeLaSemaine{
   lundi,
   mardi,
   mercredi,
   jeudi,
   vendredi,
   samedi,
   dimanche
};

Et, à l'usage, tu n'aurais aucun besoin de te casser la tête pour retenir à quelle valeur les différents identifiants sont associés, tu saurais que si tu cherches à déterminer à quel jour correspond une valeur particulière, il te suffirait de vérifier si cette valeur est identique à celle associée au jour qui t'intéresse: tu testeras donc si ta "valeur de référence" est égale à mercredi si tu veux réagir explicitement à quelque chose qui a lieu ... le mercredi.

La dernière chose qu'il peut être intéressant de savoir, c'est que les valeurs numériques associées aux différents identifiants d'une énumérations sont des constantes de compilation.

C'est à dire que le compilateur sait exactement, déjà au moment où il traduit ton code pour générer le code binaire exécutable, quelle valeur est associée à chaque identifiant.

Cela permet un tas de choses du genre "très sympathiques", surtout lorsque tu envisages d'utiliser le paradigme générique (AKA : les fonctions et les classes template )