Stampa il testo anziché il valore da 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; } 

Le enumerazioni in C sono numeri con nomi convenienti all’interno del codice. Non sono stringhe e i nomi assegnati a loro nel codice sorgente non sono compilati nel tuo programma e quindi non sono accessibili in fase di runtime.

L’unico modo per ottenere ciò che vuoi è scrivere una funzione tu stesso che traduca il valore di enumerazione in una stringa. Ad esempio (supponendo che tu sposti la dichiarazione di enum Days fuori dal 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)); 

In alternativa, è ansible utilizzare un array come una mappa, ad es

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

Ma qui vorresti probabilmente assegnare Sunday = 0 all’enumerazione per essere sicuro … Non sono sicuro che lo standard C richieda ai compilatori di iniziare le enumerazioni da 0, anche se la maggior parte lo fa (sono sicuro che qualcuno commenterà per confermare o negarlo).

Io uso qualcosa come questo:

in un file “EnumToString.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* GetString##ENUM_NAME(enum tag##ENUM_NAME index); #else #define BEGIN_ENUM( ENUM_NAME) const char * GetString##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 

quindi in qualsiasi file di intestazione si effettua la dichiarazione enum, day enum.h

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

quindi in un file chiamato EnumToString.c:

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

quindi in main.c:

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

questo genererà “automaticamente” le stringhe per qualsiasi enumerazione dichiarata in questo modo e inclusa in “EnumToString.c”

Il modo in cui faccio questo è memorizzando le rappresentazioni di stringa in un array separato nello stesso ordine, quindi indicizzando l’array con il valore enum:

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

enum s in C non funziona davvero come te lo aspetti. Puoi pensare a loro come ad esempio costanti glorificate (con alcuni vantaggi aggiuntivi relativi ad essere una raccolta di tali costanti), e il testo che hai scritto per “Domenica” viene davvero risolto in un numero durante la compilazione, il testo è alla fine scartati.

In breve: per fare ciò che vuoi veramente, devi tenere una serie di stringhe o creare una funzione per mappare dal valore dell’enum al testo che desideri stampare.

Le enumerazioni in C sono essenzialmente zucchero sintattico per liste nominate di valori interi automaticamente sequenziati. Cioè, quando hai questo codice:

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

Il tuo compilatore in realtà sputa questo:

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

Pertanto, l’emissione di un’enumerazione C come stringa non è un’operazione che ha senso per il compilatore. Se si desidera avere stringhe leggibili dall’uomo per questi, sarà necessario definire le funzioni per convertire da enumerazioni a stringhe.

Ecco un modo più semplice per farlo con i macro:

 #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 strings 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; } 

Non sono sicuro che si tratti di preprocessori b / n totalmente portatili, ma funziona con gcc.

Questo è c99 btw, quindi usa c99 strict se lo colleghi al (il compilatore online) ideone .

So di essere in ritardo per la festa, ma che ne dici di questo?

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

In questo modo, non è necessario mantenere manualmente l’ enum e l’array char* in sincronizzazione. Se sei come me, è probabile che in seguito cambi l’ enum e l’array char* stamperà le stringhe non valide. Questa potrebbe non essere una funzione supportata universalmente. Però, la maggior parte dei compilatori Mordern day C supportano questo stile di initialier designato.

Puoi leggere ulteriori informazioni sugli inizializzatori designati qui .

TheDay esegue il mapping su un tipo intero. Così:

 printf("%s", TheDay); 

Tenta di analizzare TheDay come una stringa e stamperà fuori garbage o crash.

printf non è typesafe e si fida di farvi passare il giusto valore. Per stampare il nome del valore, è necessario creare un metodo per mappare il valore enum su una stringa: una tabella di ricerca, un’istruzione switch gigante, ecc.

Sono nuovo a questo, ma una dichiarazione switch funzionerà sicuramente

 #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; } 

Mi piace avere enum in the dayNames. Per ridurre la digitazione, possiamo fare quanto segue:

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