Kann ich den Wert einer Aufzählung mit printf() anzeigen?

Gibt es einen Einzeiler, mit dem ich den aktuellen Wert einer Aufzählung ausgeben kann?

Als Saite, nein. Als ganze Zahl %d.

Es sei denn, Sie zählen:

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]);

Dies funktioniert nicht für so etwas wie eine Aufzählung von Bitmasken. An diesem Punkt benötigen Sie eine Hash-Tabelle oder eine andere ausgefeiltere Datenstruktur.

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

Sie müssen nur enum in int umwandeln!
Ausgabe : Mein Enum-Wert: 2

Die richtige Antwort darauf wurde bereits gegeben: Nein, Sie können nicht den Namen einer Aufzählung angeben, sondern nur ihren Wert.

Nichtsdestotrotz, nur zum Spaß, gibt Ihnen dies eine Aufzählung und eine Nachschlagetabelle in einem und gibt Ihnen die Möglichkeit, sie namentlich zu drucken:

Haupt 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

Haftungsausschluss: Tun Sie dies nicht.

enum A { foo, bar } a;
a = foo;
printf( "%d", a );   // see comments below

Irgendein Typ hat sich in diesem Beitrag eine schlaue Präprozessor-Idee ausgedacht

Einfache Möglichkeit, Variablen von Enum-Typen als Zeichenfolge in C zu verwenden?

Ich hatte das gleiche Problem.

Ich musste die Farbe der Knoten drucken, wo die Farbe war: enum col { WHITE, GRAY, BLACK }; und der Knoten: typedef struct Node { col color; };

Ich habe versucht zu drucken node->color mit printf("%s\n", node->color); aber alles, was ich auf dem Bildschirm bekam, war (null)\n.

Die Antwort bmargulies gab fast das Problem gelöst.

Also meine endgültige Lösung ist:

static char *enumStrings[] = {"WHITE", "GRAY", "BLACK"};
printf("%s\n", enumStrings[node->color]);

Das Drucken eines Aufzählungswerts kann schwierig sein, da die Größe jedes seiner Elemente je nach Implementierung variieren kann. Nehmen Sie dieses Beispiel, das auf gcc 8.4.0 kompiliert wurde.

#include <stdio.h>

int main(void) {
  enum option {A = 0, B = 0x100000000};

  // Enumerator sizes of the same enumeration can differ
  printf("sizeof(A)=%zu\n", sizeof(A)); // sizeof(A)=4
  printf("sizeof(B)=%zu\n", sizeof(B)); // sizeof(B)=8

  // Same output even though they have different values
  printf("A=%d\n", A); // A=0
  printf("B=%d\n", B); // B=0

  // You should know beforehand the maximum enumerator size
  printf("A=%ld\n", A); // A=0
  printf("B=%ld\n", B); // B=4294967296
}