C ++ façons de convertir l'énumération en chaîne

Un type de données qui peut se voir attribuer une liste de valeurs est connu sous le nom de type énuméré (enum). L'utilisateur spécifie les valeurs pour celle-ci lorsqu'un type énuméré est déclaré. Le compilateur lance une erreur lorsque nous attribuons une valeur flottante à une valeur de caractère. De même, tenter d'allouer toute autre valeur aux types de données spécifiés entraîne une erreur du compilateur. Les valeurs du type d'énumérateur sont parfois appelées énumérateurs. Il lui aussi est alloué une valeur de zéro, tout comme le tableau.

Enum est un type de données qui peut être spécifié par l'utilisateur qui contient des constantes intégrales. Pour le définir, nous utilisons le modificateur «Enum». Dans cet article, nous examinerons comment transférer certaines valeurs de type d'énumération à une chaîne en C++. La conversion d'une énumération en une chaîne peut être réalisée de diverses manières. Nous passerons par certaines des méthodes les plus efficaces et les plus simples pour convertir une énumération en une chaîne. Cette méthode représente une collection de nombres entiers d'une manière moins sujette aux erreurs et plus lisible.

Exemple 1: utilisation de la méthode stringify () pour convertir l'énum en chaîne en C ++:

La méthode macro stringify () est utilisée pour convertir une énumération en une chaîne. La déréférence variable et les remplacements de macro ne sont pas nécessaires avec cette méthode. L'important est que seul le texte inclus dans les parenthèses peut être converti à l'aide de la méthode Stringify ().

Voyons l'implémentation du code. Dans la première étape, nous avons importé deux fichiers standard dans la section d'en-tête. Le premier est le fichier ioStream et le second est le fichier Define Stringify qui passe un argument. Ce fichier convertit les arguments macro en chaîne littéraux sans étendre le nom du paramètre. Le fichier std de l'espace de noms est également inclus pour l'utilisation de ses fonctions.

Ensuite, nous avons défini une classe d'énumération comme un «univers» et il contient quatre valeurs différentes d'énumération de type. Ici, nous avons la première valeur d'énumération en position 0, la deuxième valeur d'énumération en position 1, et ainsi de suite, par défaut. Maintenant, nous avons une classe de type de données de caractère comme «convert_enum []» où nous avons appelé la méthode Stringify. La méthode Stringify prend les valeurs du type d'énumération et les convertit en une chaîne.

Nous avons créé une fonction comme «affichage» qui imprimera les valeurs stockées dans la classe Enum. En fin de compte, nous avons invoqué la fonction principale qui appelle la fonction «affichet» et prenant la classe d'énumération «Univers» comme argument. La valeur du type d'énumération sera convertie en une chaîne en utilisant cette méthode.

#inclure
#define Stringify (name) #name
Utilisation de Namespace Std;
Univers de l'énumération

Terre = 0,
Eau,
Air,
Feu
;
const char * convert_enum [] =

Stringify (Terre),
Stringify (eau),
Stringify (air),
Stringify (feu)
;
void DisplayItems (élément de l'univers)

couter<
int main()

couter<< "Enum items are: "<DisplayItems ((Univers) 0);
DisplayItems ((Univers) 1);
DisplayItems ((Univers) 2);
DisplayItems ((Univers) 3);
retour 0;

Les éléments contenant la classe Enum sont affichés dans l'image suivante et sont convertis en chaîne:

Exemple2: utilisation du tableau de char * constant pour convertir l'énumération en chaîne en C ++:

L'utilisation de const char * array est l'une des méthodes les plus fondamentales pour convertir une enum. Pour accéder aux éléments du tableau des chaînes, nous utiliserons les valeurs par défaut de l'énumération dans cette méthode.

Initialement, nous avons des fichiers d'en-tête standard dans la section d'en-tête du programme suivant. Nous avons également un fichier d'espace de noms pour accéder à sa fonction. Ensuite, nous avons défini une classe d'énumération en utilisant le mot clé Enum avec le nom de classe. Le nom de classe est représenté comme des «données». La classe Enum «DataTypes» contient les quatre éléments.

Après cela, nous avons un tableau de pointeur const char comme «enumstr» qui contient les valeurs de chaîne à partir d'un type d'énumération. Ainsi, «enumstr []» est un tableau de chaîne qui ne peut pas être modifié. Ensuite, nous avons la fonction principale et dans la fonction principale, nous avons une commande cout qui prend les valeurs du tableau de chaîne «enumstr» et nous imprimera sur l'écran de l'invite.

#inclure
#inclure
Utilisation de Namespace Std;
enum dataTypes Integer, String, char, float;
Static const char * enumstr [] =
"Integer", "String", "char", "float";
int main()
couter<couter<couter<couter<retour 0;

Le résultat que nous avons obtenu en utilisant le tableau de pointeur const char dans le programme ci-dessus est illustré ci-dessous:

Exemple 3: Utilisation de la fonction définie pour convertir l'énumération en chaîne en C ++:

Nous pouvons également implémenter notre fonction qui accepte un entier de la classe Enum en tant qu'argument et renvoie une chaîne en tant que sortie.

Le programme a inclus la bibliothèque C ++ requise dans l'en-tête avec le fichier d'espace de noms STD. Après cela, nous avons créé une énumération avec le modificateur «Enum». L'énumération est définie avec le nom «Animal». L'animal stocke cinq valeurs aléatoires d'un type d'énumération. Nous avons un tableau de pointeur const char comme «chaîne d'énumération» dans la ligne de code suivante. Il contient un tableau de valeurs de chaîne.

Ensuite, nous avons défini une fonction personnalisée comme «converttoenum». Cette fonction prend les entiers enum comme un argument comme «Val». La variable de chaîne est remplie à l'intérieur de la fonction avec un élément const de char * du tableau de chaîne d'énumération. En fin de compte, nous avons défini la fonction principale dans laquelle nous avons appelé la fonction personnalisée «converttoenum» et transmis les valeurs d'énumération à cette fonction personnalisée.

#inclure
#inclure
Utilisation de Namespace Std;
Enum Animals ours, chat, chien, chèvre, souris;
Static const char * enum_string [] =
"Bear", "Cat", "chien", "chèvre", "souris";
String converttoenum (int Val)

String mystr (enum_string [val]);
retourner mystr;

int main()
couter<couter<couter<couter<couter<retour 0;

Le tableau de chaîne généré à partir du type d'énumération est le résultat de l'exécution de code ci-dessus illustré dans l'image suivante.

Conclusion

Nous avons exploré de nombreuses approches pour convertir une énumération en une chaîne. La première méthode qui est la méthode stringify () peut également gérer de grandes énumérations, tandis que les autres méthodes peuvent être utilisées pour des conversions faciles. Ce sont des approches assez simples, et avec une seule tentative, vous serez à l'aise avec eux.