Imprimer le texte au lieu de la valeur 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 les C sont des nombres qui ont des noms de pratique à l'intérieur de votre code. Ils ne sont pas des chaînes, et les noms qui leur est attribué dans le code source ne sont pas compilées dans votre programme, et donc ils ne sont pas accessibles au moment de l'exécution.

La seule façon d'obtenir ce que vous voulez est d'écrire une fonction pour vous-même, qui se traduit par la valeur de l'énumération dans une chaîne. E. g. (en supposant ici que vous déplacez la déclaration d' enum Days à l'extérieur de l' 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 auriez probablement souhaitez affecter Sunday = 0 dans l'énumération pour être sûr... je ne suis pas sûr si C norme exige que les compilateurs pour commencer les énumérations de 0, bien que la plupart ne le font (je suis sûr que quelqu'un va commenter pour confirmer ou d'infirmer cette).

Answer 2

J'utilise quelque chose comme ça:

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 n'importe quel fichier d'en-tête, vous faites la déclaration 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)
 

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 "automatiquement" les chaînes de toutes les énumérations déclarées de cette façon et incluses dans "EnumToString.c"

Answer 3

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

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

Answer 4

enums dans C ne fonctionnent pas vraiment la façon dont vous vous attendez d'eux. Vous pouvez penser à eux un peu comme glorifié constantes (avec quelques avantages supplémentaires liés à l'exploitation d'une collection de ces constantes), et le texte que vous avez écrit dans "dimanche" vraiment est résolu à un certain nombre lors de la compilation, le texte est finalement écartée.

En bref: pour faire ce que vous voulez vraiment, vous aurez besoin de garder un tableau de chaînes ou de créer une fonction de carte à partir de la valeur de l'enum pour le texte que vous voulez imprimer.

Answer 5

Les énumérations en C sont essentiellement un sucre syntaxique pour les listes nommées de valeurs entières séquencées automatiquement. 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 réellement 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 utile pour le compilateur. Si vous souhaitez utiliser des chaînes lisibles par l'homme, vous devez définir des fonctions pour convertir les énumérations en chaînes.