So verwenden Sie Enum in C -Sprache
Syntax
AufreumEnumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
… ,
Enumeration_Constant_Element-n,
;
Der Standardwert von Enumeration_Constant_Element-1 beträgt 0, der Wert von Enumeration_Constant_Element-2 ist 1, der Wert der Enumeration_Constant_Element-3 2 und der Wert der Enumeration_Constant_Element-N ist (n-1) (N-1).
Tiefer Eintauchen in Enum
Da wir nun die Syntax kennen, um den Aufzählungstyp zu definieren, sollten wir uns ein Beispiel ansehen:
AufzündungsfehlerIo_error,
FESTPLATTENFEHLER,
NETZWERKFEHLER
;
Das Schlüsselwort „Enum“ muss immer verwendet werden, um den Aufzählungstyp zu definieren. Wenn Sie also einen Aufzählungstyp definieren möchten, müssen Sie das Schlüsselwort „Enum“ vor dem Schlüsselwort verwenden . Nach dem Schlüsselwort "Enum" müssen Sie eine gültige Kennung verwenden, um die zu definieren .
Im obigen Beispiel weist der Compiler dem Integralwert IO_Error zu: 0, Disk_error dem integralen Wert: 1 und network_error dem integralen Wert: 2. Standardmäßig wird dem ersten Aufzündungselement immer der Wert 0 zugewiesen, dem nächsten Auflaufelement wird der Wert 1 zugewiesen und so weiter.
Dieses Standardverhalten kann bei Bedarf geändert werden, indem der konstante integrale Wert explizit wie folgt zugewiesen wird:
AufzündungsfehlerIo_error = 2,
FESTPLATTENFEHLER,
Network_error = 8 ,
Print_error
;
In diesem Fall wird der IO_Error vom Programmierer ausdrücklich einem Wert von 2 zugeordnet. Disk_error wird vom Compiler einem Wert von 3 zugewiesen. Network_error wird vom Programmer explizit dem Wert von 8 zugeordnet, und Print_error wird dem nächsten zugewiesen Integraler Wert des vorherigen Enum -Element -Network_error (i.e., 9) durch den Compiler.
Sie verstehen jetzt, wie Sie einen benutzerdefinierten Aufzählungsart in C definieren können. Ist es möglich, eine Variable des Enum -Typs zu deklarieren (da wir eine Variable des Ganzzahltyps deklarieren können)? Ja ist es! Sie können die Enum -Variable wie folgt deklarieren:
Enum -Fehler hw_error;Auch hier ist "Enum" das Schlüsselwort hier, "Fehler" ist der Enum -Typ und "hw_error" ist eine Enum -Variable.
Wir werden uns nun die folgenden Beispiele ansehen, um die verschiedenen Verwendungen von Enum zu verstehen:
- Beispiel 1: Standard -Definitionsnutzung
- Beispiel 2: Benutzerdefinierte Definitionsnutzung
- Beispiel 3: Enum -Definition mit konstantem Ausdruck
- Beispiel 4: Enum Scope
Beispiel 1: Standard -Definitionsnutzung
In diesem Beispiel lernen Sie, wie Sie den Aufzählungstyp mit Standardwerten konstant definieren können. Der Compiler kümmert sich darum, die Standardwerte den Enum -Elementen zuzuweisen. Im Folgenden sehen Sie das Beispielprogramm und die entsprechende Ausgabe.
#enthalten/ * Definieren Sie den Enum -Typ */
Aufzündungsfehler
Io_error,
FESTPLATTENFEHLER,
NETZWERKFEHLER
;
int main ()
Enum -Fehler hw_error; /* Erstellen von Enum -Variablen*/
printf ("hw_error auf io_error \ n");
Hw_error = io_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu network_error \ n");
Hw_error = network_error;
printf ("Wert von hw_error = %d \ n", hw_error);
Rückkehr 0;
Beispiel 2: Benutzerdefinierte Definitionsnutzung
In diesem Beispiel lernen Sie, wie Sie den Aufzählungstyp mit einem benutzerdefinierten konstanten Wert definieren. In diesem Beispiel können Sie auch verstehen, wie die Initialisierung der benutzerdefinierten Konstanten in jeder zufälligen Reihenfolge durchgeführt werden kann. In diesem Beispiel haben wir den konstanten Wert für die 1 explizit definiertst und 3Rd Enum -Elemente (ich.e., IO_Error bzw. network_error), aber wir haben die explizite Initialisierung für die 2 übersprungennd und 4th Elemente. Es liegt nun in der Verantwortung des Compilers, den Standardwerten den 2 zuzuweisennd und 4th Enum -Elemente (ich.e., Disk_error bzw. print_error). Disk_error wird einem Wert von 3 zugewiesen und Print_error wird einem Wert von 9 zugewiesen. Unten sehen Sie das Beispielprogramm und die Ausgabe.
#enthalten/* Definieren Sie den Enum -Typ - benutzerdefinierte Initialisierung*/
Aufzündungsfehler
Io_error = 2,
FESTPLATTENFEHLER,
Network_error = 8,
Print_error
;
int main ()
/* Declare Enum Variable*/
Enum -Fehler hw_error;
printf ("hw_error auf io_error \ n");
Hw_error = io_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu network_error \ n");
Hw_error = network_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu print_error \ n");
Hw_error = print_error;
printf ("Wert von hw_error = %d \ n", hw_error);
Rückkehr 0;
Beispiel 3: Enum -Definition mit konstantem Ausdruck
In diesem Beispiel lernen Sie, wie Sie den konstanten Ausdruck verwenden, um den konstanten Wert für Enumelemente zu definieren.
#enthalten/* Definieren Sie den Enum -Typ - benutzerdefinierte Initialisierung unter Verwendung konstanter Ausdruck
Hier wird hier ein ständiger Ausdruck verwendet, wenn:
A. Io_error und
B. NETZWERKFEHLER
Dies ist eine ungewöhnliche Möglichkeit, die Enum -Elemente zu definieren. Dies jedoch
Das Programm zeigt, dass diese Initialisierung von Enum -Elementen in C möglich ist.
*/
Aufzündungsfehler
Io_error = 1 + 2 * 3 + 4,
FESTPLATTENFEHLER,
Network_error = 2 == 2,
Print_error
;
int main ()
/* Declare Enum Variable*/
Enum -Fehler hw_error;
printf ("hw_error auf io_error \ n");
Hw_error = io_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu network_error \ n");
Hw_error = network_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu print_error \ n");
Hw_error = print_error;
printf ("Wert von hw_error = %d \ n", hw_error);
Rückkehr 0;
Beispiel 4: Enum Scope
In diesem Beispiel erfahren Sie, wie die Scoping -Regel für Enum funktioniert. Ein Makro (#define) hätte verwendet werden können, um eine Konstante anstelle des Enum zu definieren, aber die Scoping -Regel funktioniert nicht für Makro.
#enthaltenint main ()
/ * Definieren Sie den Enum -Typ */
enum error_1
Io_error = 10,
FESTPLATTENFEHLER,
Network_error = 3,
Print_error
;
/* Definieren Sie den Enumtyp im inneren Bereich*/
enum error_1
Io_error = 20,
FESTPLATTENFEHLER,
Network_error = 35,
Print_error
;
/* Declare Enum Variable*/
enum error_1 hw_error;
printf ("hw_error auf io_error \ n");
Hw_error = io_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu network_error \ n");
Hw_error = network_error;
printf ("Wert von hw_error = %d \ n", hw_error);
printf ("\ netting hw_error zu print_error \ n");
Hw_error = print_error;
printf ("Wert von hw_error = %d \ n", hw_error);
Rückkehr 0;
Vergleich zwischen Enum und Makro
| Aufreum | Makro |
| Scoping -Regel gilt für Enum. | Die Scoping -Regel gilt nicht für Makro. |
| Die Standard -Enum -Wert -Zuordnung erfolgt automatisch. Enum ist sehr hilfreich bei der Definition einer großen Anzahl von Konstanten. Der Compiler übernimmt die Initialisierung des Standardwertwertwerts. | Die Konstantenwerte der Makro müssen vom Programmierer immer explizit erwähnt werden. Dies könnte ein mühsamer Prozess für eine große Anzahl von Konstanten sein, da der Programmierer bei der Definition des Makros immer manuell jeden konstanten Wert definieren muss. |
Abschluss
Das Enum-Programm in C kann als optionale Methode für eigenständige Programme oder kleine Projekte angesehen werden, da Programmierer immer MACRO anstelle eines Enum verwenden können. Erfahrene Programmierer verwenden jedoch in der Regel Enum über Makro für groß angelegte Softwareentwicklungsprojekte. Dies hilft beim Schreiben von sauberen und lesbaren Programmen.