Imprimer le texte au lieu de la valeur à partir de C enum

Question

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

Answer 1

Les énumérations dans C sont des nombres qui ont des noms pratiques dans votre code. Ce ne sont pas des chaînes, et les noms qui leur sont attribués dans le code source ne sont pas compilés dans votre programme, ils 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 de l'énumération en une chaîne de caractères. Par exemple. (En supposant ici que vous déplacez la déclaration de enum Days en 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)); 

Sinon, vous pouvez utiliser un tableau comme une carte, par exemple

const char* dayNames[] = {"Sunday", "Monday", "Tuesday", /* ... etc ... */ }; 

/* ... */ 

printf("%s", dayNames[TheDay]); 

Mais ici, vous voudrez certainement attribuer Sunday = 0 dans l'énumération pour être sûr ... Je ne sais pas si la norme C exige compilateurs pour commencer énumérations de 0, bien que la plupart ne (je suis sûr quelqu'un commentera pour confirmer ou infirmer cela).

Answer 2

enum s ne fonctionnent pas vraiment comme vous le souhaitez. Vous pouvez les considérer comme des constantes glorifiées (avec quelques avantages supplémentaires en étant une collection de ces constantes), et le texte que vous avez écrit pour "Dimanche" est vraiment résolu en nombre lors de la compilation, le le texte est finalement rejeté. En bref: pour faire ce que vous voulez vraiment, vous devez garder un tableau des chaînes ou créer une fonction pour mapper de la valeur de l'énumération au texte que vous souhaitez imprimer.

Answer 3

Le jour correspond à un type entier. Alors:

printf("%s", TheDay); 

tente d'analyser theday comme une chaîne et seront soit imprimer les ordures ou accident. Printf n'est pas de typeafe et vous fait confiance pour lui transmettre la bonne valeur. Pour imprimer le nom de la valeur, vous devez créer une méthode pour mapper la valeur enum à une chaîne - soit une table de recherche, une instruction switch géante, etc.

Answer 4

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

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

Answer 5

énumérations en C sont essentiellement sucre syntaxique pour les listes nommées de valeurs entières-séquences automatiquement. Autrement dit, quand vous avez ce code:

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

    Days TheDay = Monday; 
} 

Votre compilateur recrache fait ce:

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 fait sens pour le compilateur. Si vous voulez avoir des chaînes lisibles par un humain, vous devrez définir des fonctions pour convertir des énumérations en chaînes.

Answer 6

J'utilise quelque chose comme ceci:

dans un fichier « 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 

puis dans un fichier d'en-tête vous faire la déclaration enum, jour 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) 

puis dans un fichier appelé EnumToString.c:

#include "enum.h" 

#define GENERATE_ENUM_STRINGS // Start string generation 

#include "enum.h"    

#undef GENERATE_ENUM_STRINGS // Stop string generation 

puis dans 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; 
} 

cela générera "un utomatiquement » les chaînes pour toutes les énumérations déclarées de cette façon et inclus dans « EnumToString.c »

Answer 7

est ici un nettoyeur façon de le faire avec des macros:

#include <stdio.h> 
#include <stdlib.h> 

#define DOW(X, S)               \ 
    X(Sunday) S X(Monday) S X(Tuesday) S X(Wednesday) S X(Thursday) S X(Friday) S X(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; 
} 

Je ne suis pas sûr que ce soit totalement portable b/w préprocesseurs, mais cela fonctionne avec gcc.

Ceci est c99 btw, donc utilisez c99 strict si vous le branchez dans (the online compiler) ideone.

Answer 8

je suis nouveau à cela, mais une instruction switch travaillerai defenitely

#include <stdio.h> 

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

Answer 9

Je sais que je suis en retard à la fête, mais que diriez-vous?

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

De cette façon, vous ne devez pas garder manuellement le enum et le tableau char* synchronisés. Si vous êtes comme moi, les chances sont que vous changerez plus tard le enum, et le tableau char* imprimera des chaînes invalides. Il se peut que cette fonctionnalité ne soit pas prise en charge universellement. Cependant, la plupart des compilateurs de jour C de Mordern supportent ce style d'initiateur désigné.

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

Answer 10

J'aime ça d'enumer dans le jourNames. Pour réduire la saisie, nous pouvons faire ce qui suit:

#define EP(x) [x] = #x /* ENUM PRINT */ 

const char* dayNames[] = { EP(Sunday), EP(Monday)};