Imprimer du texte au lieu de la valeur de C enum

int main() { enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}; Days TheDay; int j = 0; printf("Please enter the day of the week (0 to 6)\n"); scanf("%d",&j); TheDay = Days(j); //how to PRINT THE VALUES stored in TheDay printf("%s",TheDay); // isnt working return 0; } 

Les énumérations dans C sont des nombres qui ont des noms commodes dans votre code. Ce ne sont pas des chaînes, et les noms qui leur sont atsortingbués dans le code source ne sont pas compilés dans votre programme et ne sont donc pas accessibles au moment de l’exécution.

La seule façon d’obtenir ce que vous voulez est d’écrire vous-même une fonction qui traduit la valeur d’énumération en une chaîne. Par exemple (en supposant ici que vous déplacez la déclaration des enum Days dehors de main ):

 const char* getDayName(enum Days day) { switch (day) { case Sunday: return "Sunday"; case Monday: return "Monday"; /* etc... */ } } /* Then, later in main: */ printf("%s", getDayName(TheDay)); 

Vous pouvez également utiliser un tableau comme carte, par exemple

 const char* dayNames[] = {"Sunday", "Monday", "Tuesday", /* ... etc ... */ }; /* ... */ printf("%s", dayNames[TheDay]); 

Mais ici vous voudrez probablement assigner Sunday = 0 dans l’énumération pour être sûr … Je ne suis pas sûr que le standard C exige que les compilateurs commencent les énumérations à partir de 0, bien que la plupart le fassent (je suis sûr que quelqu’un ou nier cela).

J’utilise quelque chose comme ça:

dans un fichier “EnumToSsortingng.h”:

 #undef DECL_ENUM_ELEMENT #undef DECL_ENUM_ELEMENT_VAL #undef DECL_ENUM_ELEMENT_STR #undef DECL_ENUM_ELEMENT_VAL_STR #undef BEGIN_ENUM #undef END_ENUM #ifndef GENERATE_ENUM_STRINGS #define DECL_ENUM_ELEMENT( element ) element, #define DECL_ENUM_ELEMENT_VAL( element, value ) element = value, #define DECL_ENUM_ELEMENT_STR( element, descr ) DECL_ENUM_ELEMENT( element ) #define DECL_ENUM_ELEMENT_VAL_STR( element, value, descr ) DECL_ENUM_ELEMENT_VAL( element, value ) #define BEGIN_ENUM( ENUM_NAME ) typedef enum tag##ENUM_NAME #define END_ENUM( ENUM_NAME ) ENUM_NAME; \ const char* GetSsortingng##ENUM_NAME(enum tag##ENUM_NAME index); #else #define BEGIN_ENUM( ENUM_NAME) const char * GetSsortingng##ENUM_NAME( enum tag##ENUM_NAME index ) {\ switch( index ) { #define DECL_ENUM_ELEMENT( element ) case element: return #element; break; #define DECL_ENUM_ELEMENT_VAL( element, value ) DECL_ENUM_ELEMENT( element ) #define DECL_ENUM_ELEMENT_STR( element, descr ) case element: return descr; break; #define DECL_ENUM_ELEMENT_VAL_STR( element, value, descr ) DECL_ENUM_ELEMENT_STR( element, descr ) #define END_ENUM( ENUM_NAME ) default: return "Unknown value"; } } ; #endif 

alors dans n’importe quel fichier d’en-tête, vous faites la déclaration enum, jour enum.h

 #include "EnumToSsortingng.h" BEGIN_ENUM(Days) { DECL_ENUM_ELEMENT(Sunday) //will render "Sunday" DECL_ENUM_ELEMENT(Monday) //will render "Monday" DECL_ENUM_ELEMENT_STR(Tuesday, "Tuesday ssortingng") //will render "Tuesday ssortingng" DECL_ENUM_ELEMENT(Wednesday) //will render "Wednesday" DECL_ENUM_ELEMENT_VAL_STR(Thursday, 500, "Thursday ssortingng") // will render "Thursday ssortingng" and the enum will have 500 as value /* ... and so on */ } END_ENUM(MyEnum) 

puis dans un fichier appelé EnumToSsortingng.c:

 #include "enum.h" #define GENERATE_ENUM_STRINGS // Start ssortingng generation #include "enum.h" #undef GENERATE_ENUM_STRINGS // Stop ssortingng generation 

puis dans main.c:

 int main(int argc, char* argv[]) { Days TheDay = Monday; printf( "%d - %s\n", TheDay, GetSsortingngDay(TheDay) ); //will print "1 - Monday" TheDay = Thursday; printf( "%d - %s\n", TheDay, GetSsortingngDay(TheDay) ); //will print "500 - Thursday ssortingng" return 0; } 

cela va générer “automatiquement” les chaînes pour toutes les énumérations déclarées de cette façon et incluses dans “EnumToSsortingng.c”

La façon dont je le fais habituellement est en stockant les représentations de chaîne dans un tableau séparé dans le même ordre, puis en indexant le tableau avec la valeur enum:

 const char *DayNames[] = { "Sunday", "Monday", "Tuesday", /* etc */ }; printf("%s", DayNames[Sunday]); // prints "Sunday" 

enum s in C ne fonctionnent pas vraiment comme prévu. Vous pouvez les considérer comme des constantes glorifiées (avec quelques avantages supplémentaires liés au fait d’être une collection de telles constantes), et le texte que vous avez écrit pour “Sunday” est vraiment résolu en nombre lors de la compilation, le texte est finalement jeté.

En bref: pour faire ce que vous voulez vraiment, vous devez conserver un tableau de chaînes ou créer une fonction pour la mapper de la valeur de l’énumération au texte que vous souhaitez imprimer.

Les énumérations dans C sont essentiellement du sucre syntaxique pour les listes nommées de valeurs entières automatiquement séquencées. C’est à dire quand vous avez ce code:

 int main() { enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}; Days TheDay = Monday; } 

Votre compilateur crache effectivement ceci:

 int main() { int TheDay = 1; // Monday is the second enumeration, hence 1. Sunday would be 0. } 

Par conséquent, la sortie d’une énumération C en tant que chaîne n’est pas une opération qui a du sens pour le compilateur. Si vous voulez avoir des chaînes lisibles par l’homme, vous devrez définir des fonctions pour convertir des énumérations en chaînes.

Voici une façon plus propre de le faire avec les macros:

 #include  #include  #define DOW(X, S) \ X(Sunday) SX(Monday) SX(Tuesday) SX(Wednesday) SX(Thursday) SX(Friday) SX(Saturday) #define COMMA , /* declare the enum */ #define DOW_ENUM(DOW) DOW enum dow { DOW(DOW_ENUM, COMMA) }; /* create an array of ssortingngs with the enum names... */ #define DOW_ARR(DOW ) [DOW] = #DOW const char * const dow_str[] = { DOW(DOW_ARR, COMMA) }; /* ...or create a switchy function. */ static const char * dowstr(int i) { #define DOW_CASE(D) case D: return #D switch(i) { DOW(DOW_CASE, ;); default: return NULL; } } int main(void) { for(int i = 0; i < 7; i++) printf("[%d] = «%s»\n", i, dow_str[i]); printf("\n"); for(int i = 0; i < 7; i++) printf("[%d] = «%s»\n", i, dowstr(i)); return 0; } 

Je ne suis pas sûr que ce soit des préprocesseurs N / B totalement portables, mais cela fonctionne avec gcc.

Ceci est c99 btw, donc utilisez c99 ssortingct si vous le twigz sur l’ideone (le compilateur en ligne) .

Je sais que je suis en retard à la fête, mais qu’en est-il de ça?

 const char* dayNames[] = { [Sunday] = "Sunday", [Monday] = "Monday", /*and so on*/ }; printf("%s", dayNames[Sunday]); // prints "Sunday" 

De cette façon, vous n’avez pas à conserver manuellement le tableau et le tableau de caractères char* en synchronisation. Si vous êtes comme moi, il y a des chances que vous modifiiez plus tard l’ enum et que le tableau char* affiche des chaînes non valides. Cela peut ne pas être une fonctionnalité universellement prise en charge. Cependant, la plupart des compilateurs du jour C du mordern prennent en charge ce style d’initialisation désigné.

Vous pouvez en savoir plus sur les initialiseurs désignés ici .

TheDay correspond à un type entier. Alors:

 printf("%s", TheDay); 

Tente d’parsingr TheDay sous la forme d’une chaîne et d’imprimer des erreurs ou des pannes.

printf n’est pas typé et vous fait confiance pour lui transmettre la bonne valeur. Pour imprimer le nom de la valeur, vous devez créer une méthode permettant de mapper la valeur enum à une chaîne – soit une table de recherche, une instruction de changement géant, etc.

je suis nouveau à cela, mais une déclaration de changement fonctionnera certainement

 #include  enum mycolor; int main(int argc, const char * argv[]) { enum Days{Sunday=1,Monday=2,Tuesday=3,Wednesday=4,Thursday=5,Friday=6,Saturday=7}; enum Days TheDay; printf("Please enter the day of the week (0 to 6)\n"); scanf("%d",&TheDay); switch (TheDay) { case Sunday: printf("the selected day is sunday"); break; case Monday: printf("the selected day is monday"); break; case Tuesday: printf("the selected day is Tuesday"); break; case Wednesday: printf("the selected day is Wednesday"); break; case Thursday: printf("the selected day is thursday"); break; case Friday: printf("the selected day is friday"); break; case Saturday: printf("the selected day is Saturaday"); break; default: break; } return 0; } 

J’aime ça pour avoir la enum dans le jourNames. Pour réduire la saisie, nous pouvons procéder comme suit:

 #define EP(x) [x] = #x /* ENUM PRINT */ const char* dayNames[] = { EP(Sunday), EP(Monday)};