Utilisation d'un enum pour un flag

Bonjour.

Je voulais faire usage d'un enum pour contenir et faire afficher l'état d'un flag, mais je n'obtiens pas le résultat recherché !

Code:

---

1 2 3 4 5 6 7

enum sortie_capteur{Tc_K_ON, Pyro_ON};//crétaion du type sortie_capteur capteur_en_service = Tc_K_ON;//création et initilaisation de mon flag de type sortie_capteur code modifiant la valeur de capteur_en_service . . cout << "Capteur en service : " << capteur_en_service << endl;

---

cela affiche :
Capteur en service : 0
ou
Capteur en service : 1

En fait, si je comprends bien, le code fait bien ce que je lui demande, mais pas ce que je voudrais.
Ce que je voudrais c'est afficher :
Capteur en service : Tc_K_ON
ou
Capteur en service : Pyro_ON

Comment faire celà ?

Bonjour

Je pense que tu trouveras des éléments de réponse ici :

https://stackoverflow.com/questions/...le-to-a-string

Salutations j'ai peut-être une solution pour toi. Il faudrait tout simplement que tu redéfinisses l'opérateur << et que tu utilises la notation constexp.
Je te joins un programme d'exemple.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <iostream> enum Metal { Cuivre, Fer, Bronze }; std::ostream& operator<<(std::ostream &os, Metal m) { static constexpr const char *noms[] = { "Cuivre", "Fer", "Bronze" }; return os << noms[m]; } Metal m = Metal::Cuivre;   int main() { std::cout << m << std::endl;   }

---

En espérant que ça t'aide ! :)
Je te joins le lien de mon chic prof pour t'aider à comprendre : https://h-deb.clg.qc.ca/Sujets/AuSec...ndre-enum.html
Il y a surement une solution plus simple mais celle ci marche ! :)

Salut,

Il faut déjà commencer par comprendre que, une fois que le code que tu as écrit est traduit en code binaire exécutable, tout ce qu'il reste, tout ce que le processeur est capable de manipuler, ce sont des valeurs numériques codées en binaires, qui peuvent être:

1. un numéro de circuit par lequel faire passer une information pour obtenir un résultat donné (autrement dit : un numéro d'instruction connue du compilateur)
2. une adresse mémoire
3. une valeur dont l'interprétation (le nombre de bits utilisés, et la signification donnée à chacun d'eux) dépendra du contexte

(bon, pour le (1), je simplifie et j'extrapole énormément, mais c'est pour te permettre de comprendre ;) )

Tous les identifiants que l'on peut disséminer dans le code (nom de type, de donnée, de fonction, de valeur énumérées) n'existent plus dans le code binaire. Il n'ont en effet du sens que pour le développeur qui lit le code, et l'une des premières choses que le compilateur va faire, c'est de créer une "table d'équivalence" qui lui permettra de connaitre le nombre de bits qu'il doit prévoir pour représenter ces différents identifiants.

Même la notion de caractère n'est jamais qu'un "table d'association" entre des valeurs numériques (comprise, pour la table ASCII entre 0 et 255 inclus) et des "glyphes" qui seront affichés à l'écran.

Dés lors, quand tu définis une énumération sous la forme de

Code:

---

1 2 3 4 5 6

/* cela revient au même que ton code, mais c'est plus lisible :D */ enum sortie_capteur{ Tc_K_ON, Pyro_ON };//crétaion du type

---

le compilateur va créer une "table d'équivalence" dans laquelle Tc_K_ON sera associé à la valeur 0 et Pyro_ON sera associé à la valeur 1, et ce sont ces valeurs qui seront effectivement utilisées dans le code binaire que le processeur pourra comprendre.

Si tu veux que ces valeurs soient interprétées autrement que comme 0 et 1 --entre autres lors de l'affichage -- tu dois forcément indiquer au processeur comment il doit les interpréter, les manipulations qu'il doit entreprendre pour te donner le résultat que tu espère.

L'une des solutions serait de surcharger l'opérateur << pour ton énumération, en la modifiant un tout petit peu pour lui donner la forme de

Code:

---

1 2 3 4 5 6 7

/* cela revient au même que ton code, mais c'est plus lisible :D */ enum sortie_capteur{ Tc_K_ON, Pyro_ON, MAX_SORTIE // == 2, uniquement utilisé dans l'opérateur << };//crétaion du type

---

et en définissant l'opérateur << sous une forme proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

std::ostream & operator<<(std::ostream & ofs, sortie_capteur sortie){ assert(sortie < MAX_SORTIE && "unknown flag"); // parce que le développeur // est un imbécile distrait // (requière #include <cassert> ) /* requière le support de C++11 ou supérieur, et #include <array>   * définit les chaines de caractères que nous voulons afficher, pour chaque   * valeur de l'énumération   */ static std::array<std::string, MAX_SORTIE> const strings={"Tc_K_ON", "Pyro_ON"}; ofs<<strings[sortie]; return ofs; }

---

qui nous permettra d'avoir un code proche de

Code:

---

1 2 3 4 5

int main(){ sortie_capteur capteur_en_service = Tc_K_ON; std::cout << "Capteur en service : " << capteur_en_service << std::endl; }

---

dont la sortie ressemblera à

Code:

---

1 2	philippe@philstower:~/Documents$ ./a.out Capteur en service : Tc_K_ON

---

Ce que vous présentez me semble un peu compliqué (je débute), mais je me suis inspiré de ce que j'ai pu voir.

J'ai écrit :

Code:

---

1 2 3 4 5 6 7

enum sortie_capteur{Tc_K_ON, Pyro_ON};//crétaion du type sortie_capteur capteur_en_service = Tc_K_ON;//création et initilaisation de mon flag de type sortie_capteur String capteur[2]={"Tc_K_ON", "Pyro_ON"}; code modifiant la valeur de capteur_en_service . . cout << "Capteur en service : " << capteur[sortie_capteur] << endl;

---

En fait le code suivant au lieu de "cout <<" car je code en Arduino.

Code:

---

1 2 3

Serial.print("Capteur en service : ") ; Serial.println( capteur[sortie_capteur]);

---

Ca à l'air d'être satisfaisant.

Perso, si j'ai besoin d'avoir une string pour mon enum, je préfère écrire mon enum via macros dans un fichier à part pour générer tout ça.
Du genre
Enum.inl

Code:

---

1 2 3 4 5 6 7 8

#ifndef ENTRY #error You need to #define ENTRY before including this file! #endif   ENTRY(Value1) ENTRY(Value2)   #undef ENTRY

---

Enum.hpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11

enum Enum { #define ENTRY(v) v, #include "Enum.inl" }; inline const char* ToString(Enum val) { switch(val) { #define ENTRY(v) case v : return #v; #include "Enum.inl" default: return "<unknown>"; // ou throw std::invalid_argument("Valeur inconnue"); } }

---

Parce que devoir retourner à X endroits du code pour ajouter ou supprimer une entrée, y'a pas plus chiant et source d'erreur.

Je peux comprendre la remarque, mais je ne sais pas exploiter cette histoire de macros ni ne comprends votre code ! Je suis désolé de ne pouvoir profiter plus de vos informations.

Bonsoir,

:arrow: Les item-lists ;)