Discussion :

[hary66]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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à ?

[Seabirds]

Bonjour

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

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

[Gruzo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[koala01]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[hary66]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ca à l'air d'être satisfaisant.

[Bousk]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[hary66]

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.