Warum können zwei verschiedene enum-Enumerationskonstanten denselben ganzzahligen Wert haben?

Ich weiß das, wenn ich einen Enum-Wochentag wie folgt definiert habe:

enum weekday {
    MON,
    TUE,
    WED,
    THU,
    FRI,
};

Dann wäre MON intern standardmäßig gleich 0 und TUE gleich 1, WED gleich 2 …

Aber wenn ich es so definiere:

enum weekday {
    MON,
    TUE = 0,
    WED,
    THU,
    FRI,
};

Dann beides MON und TUE würde den Wert 0 bekommen.

Wie würde ein System MON und TUE intern unterscheiden? Ich meine, wenn ich so etwas deklariere:

enum weekday today = 0;

Dann ist heute MON oder TUE? Oder, philosophisch gesprochen, beides?

C-Enumerationen sind „wirklich“ Ganzzahlen – nicht nur, weil sie zufällig so implementiert sind, sondern weil es der Standard ist definiert Enum-Typen haben ganzzahlige Werte. Also der Wert von today ist “wirklich” 0. Alles, was passiert ist, ist, dass Sie zwei verschiedene Namen für den Wert 0 erstellt haben.

Ich nehme an, dass die Antwort auf “ist heute MO oder DI” “ja” lautet 😉

Die Sprache hält Sie nicht auf, denn gelegentlich ist es nützlich, dass eine Aufzählung mehrere Namen für denselben Wert hat. Zum Beispiel:

enum compression_method {
    COMP_NONE = 0,
    COMP_LOW = 1,
    COMP_HIGH = 2,
    COMP_BEST = 2,
    COMP_FASTEST = 0,
};

Warum können zwei verschiedene Aufzählungskonstanten denselben ganzzahligen Wert haben?

Weil es ausdrücklich von der erlaubt ist N1265 C99 Standardentwurf bei 6.7.2.2/3 “Aufzählungsbezeichner”:

Die Verwendung von Enumeratoren mit = kann Aufzählungskonstanten mit Werten erzeugen, die andere Werte in derselben Aufzählung duplizieren.

Wie würde ein System MON und TUE intern unterscheiden?

Ich denke, es ist unmöglich, weil es sich um Kompilierzeitkonstanten handelt (6.6/6 “Konstante Ausdrücke”). Als Konsequenz sie:

• können nicht geändert werden, um sie nach der Kompilierung zu unterscheiden

• haben keine Adresse, um sie zu unterscheiden: Speicherort des Aufzählungswerts in C

  Kompilierzeitkonstanten benötigen keine Adresse, da Adressen für Dinge nutzlos sind, die Sie nicht ändern können.

GCC ersetzt einfach die Verwendung von Aufzählungsmitgliedern durch unmittelbare Werte in der Assemblierung zur Kompilierzeit. In Betracht ziehen:

#include <stdio.h>

enum E {
    E0 = 0x1234,
    E1 = 0x1234
};
int i = 0x5678;

int main() {
    printf("%d\n", E0);
    printf("%d\n", E1);
    printf("%d\n", i);
    return 0;
}

Kompilieren und dekompilieren mit GCC 4.8 x86_64:

gcc -c -g -O0 -std=c89 main.c
objdump -Sr main.o

Die Ausgabe enthält:

    printf("%d\n", E0);
   4:       be 34 12 00 00          mov    $0x1234,%esi
  ...
    printf("%d\n", E1);
  18:       be 34 12 00 00          mov    $0x1234,%esi
  ...
    printf("%d\n", i);
  2c:       8b 05 00 00 00 00       mov    0x0(%rip),%eax        # 32 <main+0x32>
                    2e: R_X86_64_PC32       i-0x4
  32:       89 c6                   mov    %eax,%esi

Also wir sehen das:

• Die Aufzählungsmitglieder werden als Direktwerte verwendet $0x1234daher ist es unmöglich zu wissen, woher sie kamen
• Die Variable i kommt aber aus der erinnerung 0x0(%rip) (zu verschieben), sodass zwei Variablen anhand der Adresse unterschieden werden können

Nur um andere Antworten zu ergänzen, gebe ich Ihnen ein praktisches Beispiel dafür, wie Sie denselben Wert für verschiedene Aufzählungen für einen bestimmten Wert verwenden enum ist weithin nützlich:

enum slots_t {
    SLOT_FIRST = 0,
    SLOT_LEFTARM = SLOT_FIRST,
    SLOT_RIGHTARM = 1,
    SLOT_TORSO = 2,
    SLOT_LEFTLEG = 3,
    SLOT_RIGHTLEG = 4,
    SLOT_LAST = SLOT_RIGHTLEG
};

Dann können Sie in Ihrem Code tun:

for (int i = SLOT_FIRST; i <= SLOT_LAST; ++i) { }

Es ist so philosophisch (oder nicht) wie

#define ZILCH 0
#define NADA  0

Es gibt viele Anwendungen, bei denen es sinnvoll ist, dass unterschiedliche Namen dieselbe Nummer ergeben.

Zur Wertzuweisung wird der Name der Aufzählungskonstante verwendet und nicht der eigentliche Wert selbst. Wenn Sie dem heutigen Tag den Wert 0 zuweisen, ist der Ausgabewert 0. Und ja, sowohl MON als auch TUE haben den Wert 0 und den verbleibenden wird der Wert WED = 1 THU = 2 zugewiesen und so weiter.