Puis-je afficher la valeur d'un enum avec printf()?

Est-il un one-liner qui me permet de la sortie de la valeur actuelle d'un enum?

InformationsquelleAutor Pieter | 2010-01-29
  1. 46

    Comme une chaîne de caractères, pas de. Comme un entier, %d.

    Sauf si vous comptez:

    static char* enumStrings[] = { /* filler 0's to get to the first value, */
                               "enum0", "enum1", 
                               /* filler for hole in the middle: ,0 */
                               "enum2", "enum3", .... };

...

printf("The value is %s\n", enumStrings[thevalue]);

    Cela ne fonctionne pas pour quelque chose comme une énumération des masques de bits. À ce stade, vous avez besoin d'une table de hachage ou une autre plus élaborée structure de données.

    • Ce (bien sûr) implique que votre enum commence vraiment à 0 et consécutifs sans "trous".
    InformationsquelleAutor bmargulies
  2. 23
    enum MyEnum
{  A_ENUM_VALUE=0,
   B_ENUM_VALUE,
   C_ENUM_VALUE
};


int main()
{
 printf("My enum Value : %d\n", (int)C_ENUM_VALUE);
 return 0;
}

    Vous avez juste à jeter enum pour int !

    Sortie : Mon enum Valeur : 2

    • les enums est ints.
    • il est facile de négliger lors de fonte et lorsqu'il n'est pas, cependant. Qu'entendez-vous par "enum"? Je ferais toujours la fonte. Au-dessus de la fonte est redondant, parce que c'est à l'aide de l'agent recenseur. Mais s'il l'avait fait enum MyEnum c = C_ENUM_VALUE; et en passant ensuite c, il aurait besoin de la fonte. Voir la discussion ci-dessous sur @Neil réponse.
    • Je vois. Cela est vrai, alors.
    • de ma connaissance, vous avez raison. merci pour l'explication claire !
    InformationsquelleAutor Matthieu
  3. 6

    La bonne réponse à ce qui a déjà été donné: non, vous ne pouvez pas donner le nom d'un enum, que c'est la valeur.

    Néanmoins, juste pour le plaisir, ce qui vous donnera une énumération et une recherche-table tout en un, et vous donne un moyen d'impression par son nom:

    principal.c:

    #include "Enum.h"

CreateEnum(
        EnumerationName,
        ENUMValue1,
        ENUMValue2,
        ENUMValue3);

int main(void)
{
    int i;
    EnumerationName EnumInstance = ENUMValue1;

    /* Prints "ENUMValue1" */
    PrintEnumValue(EnumerationName, EnumInstance);

    /* Prints:
     * ENUMValue1
     * ENUMValue2
     * ENUMValue3
     */
    for (i=0;i<3;i++)
    {
        PrintEnumValue(EnumerationName, i);
    }
    return 0;
}

    Enum.h:

    #include <stdio.h>
#include <string.h>

#ifdef NDEBUG
#define CreateEnum(name,...) \
    typedef enum \
    { \
        __VA_ARGS__ \
    } name;
#define PrintEnumValue(name,value)
#else
#define CreateEnum(name,...) \
    typedef enum \
    { \
        __VA_ARGS__ \
    } name; \
    const char Lookup##name[] = \
        #__VA_ARGS__;
#define PrintEnumValue(name, value) print_enum_value(Lookup##name, value)
void print_enum_value(const char *lookup, int value);
#endif

    Enum.c

    #include "Enum.h"

#ifndef NDEBUG
void print_enum_value(const char *lookup, int value)
{
    char *lookup_copy;
    int lookup_length;
    char *pch;

    lookup_length = strlen(lookup);
    lookup_copy = malloc((1+lookup_length)*sizeof(char));
    strcpy(lookup_copy, lookup);

    pch = strtok(lookup_copy," ,");
    while (pch != NULL)
    {
        if (value == 0)
        {
            printf("%s\n",pch);
            break;
        }
        else
        {
            pch = strtok(NULL, " ,.-");
            value--;
        }
    }

    free(lookup_copy);
}
#endif

    Avertissement: ne pas le faire.

    InformationsquelleAutor DrAl
  4. 2
    enum A { foo, bar } a;
a = foo;
printf( "%d", a );   //see comments below
    • Est que le cast en int vraiment nécessaire? En C les énumérations sont toujours de type int.
    • Probablement pas - je vais le changer.
    • Que le cast est nécessaire. L'énumération des variables sont d'un type distinct, et sont compatibles avec certains type intégral être en mesure de stocker toutes les valeurs des agents recenseurs. Ce n'est pas nécessairement de type int. (Une variable d'énumération peut être compatible avec long, par exemple, très bien). printf du langage %d souhaite cependant exactement type de int, donc une fonte est le mieux à faire, je pense. Seuls les agents recenseurs (l'un dans la liste dans la déclaration) sont exactement du type int.
    • Ne sont pas certains standards conversions réalisées sur des paramètres variants.?
    • Eh bien, ces "argument par défaut promotions" se passer pour les "expressions avec les types d'entiers dont la conversion rang est inférieur ou égal au rang de int et unsigned int". De toute façon, la conversion rang des énumérations sont définies à 6.3.1.1/1 comme étant "égal au rang de la compatible de type entier". Si ce type compatible est long ou quelque chose, alors pas de valeur par défaut de la promotion qui se passe.
    • OK - je vais laisser le code tel qu'il est, que vos commentaires sont instructifs, comme d'habitude.
    • Notez qu'une énumération est aussi un type entier (contrairement à C++, où ils ne le sont pas), mais le type compatible choisie ci-dessus ne doit pas être un type d'énumération, parce qu'il dit qu'il doit être un entier signé de type ou d'un type entier non signé", ni de qui les énumérations sont. Donc, je devrais avoir dit ci-dessus que "certains signé/non signé de type intégral ou char" est choisi, je pense 🙂 Cette question est comme bool ou char en C++, qui sont les types integer, mais ni un "entier signé" l'un ni un "unsigned integer" (même tho char est soit signé ou non signé). La matière est un peu compliqué, je pense.-
    • Maintenant je commence à me confondre. À partir de cette discussion (et de Wikipédia, MSDN, etc.) J'ai l'impression que l'enum expression est toujours de type int. Le type sous-jacent peut varier et peut être de type char, int, long, etc. Donc printf("%d", a) est potentiellement dangereux, tout printf("%d", C_ENUM_VALUE) serait à l'abri?
    • oui. C_ENUM_VALUE est appelé "agent recenseur", et en C, il a toujours de type int. Mais a est une variable d'énumération, et il a le type de l'énumération. Mais en C, les types peuvent être compatibles (ce qui signifie que vous pouvez T *t = &some_u si U et T sont compatibles, parmi d'autres choses). De nombreuses règles sont exprimés uniquement en termes de compatibilité au lieu de l'égalité de traitement. Un type d'énumération est compatible avec char ou un signés ou non signés type intégral. Vous ne savez pas, et il est préférable de ne pas faire d'hypothèses sur elle.

    InformationsquelleAutor
  5. 2

    Un mec est venu avec une puce de préprocesseur idée dans ce post

    Moyen facile d'utiliser des variables de types enum comme une chaîne de caractères en C?

    InformationsquelleAutor BlueTrin
  6. 0

    J'ai eu le même problème.

    J'ai eu d'impression de la couleur des nœuds où la couleur était: enum col { WHITE, GRAY, BLACK }; et le nœud: typedef struct Node { col color; };

    J'ai essayé d'imprimer node->color avec printf("%s\n", node->color); mais tout ce que j'ai sur l'écran était (null)\n.

    La réponse bmargulies a presque résolu le problème.

    Ma dernière solution est la suivante:

    static char *enumStrings[] = {"WHITE", "GRAY", "BLACK"};
printf("%s\n", enumStrings[node->color]);
    • Je crois que cela devrait en fait être modifié de façon à : printf("%s\n", enumStrings[node->color]); Comme vous en avez maintenant accès à l'ensemble lui-même pour trouver le correspondant de la chaîne.
    • Vous avez raison! J'ai corrigé.
    InformationsquelleAutor Alex Bondor