So verwenden Sie enum in der C-Sprache

How Use Enum C Language



Das enum-Programm in der Programmiersprache C wird verwendet, um ganzzahlige Konstantenwerte zu definieren, was beim Schreiben sauberer und lesbarer Programme sehr hilfreich ist. Programmierer verwenden normalerweise Aufzählungen, um benannte ganzzahlige Konstanten in ihren Programmen zu definieren, um eine bessere Lesbarkeit und Wartbarkeit der Software zu gewährleisten. Dieser Artikel wird enum im Detail besprechen.

Syntax

aufzählen <Name des Aufzählungstyps> {
Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…… .........,
Enumeration_Constant_Element-n,
};

Der Standardwert von Enumeration_Constant_Element-1 ist 0, der Wert von Enumeration_Constant_Element-2 ist 1, der Wert von Enumeration_Constant_Element-3 ist 2 und der Wert von Enumeration_Constant_Element-n ist (n-1).







Tauchen Sie ein in Enum

Da wir nun die Syntax zum Definieren des Aufzählungstyps kennen, sehen wir uns ein Beispiel an:



aufzählenFehler{
IO_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 verwenden. Nach dem Schlüsselwort enum müssen Sie einen gültigen Bezeichner verwenden, um die .



Im obigen Beispiel weist der Compiler IO_ERROR dem ganzzahligen Wert zu: 0, DISK_ERROR dem ganzzahligen Wert: 1 und NETWORK_ERROR dem ganzzahligen Wert: 2. Standardmäßig wird dem ersten Enum-Element immer der Wert 0 zugewiesen, dem nächsten enum-element wird der Wert 1 zugewiesen und so weiter.





Dieses Standardverhalten kann bei Bedarf durch explizite Zuweisung des konstanten Integralwertes wie folgt geändert werden:

aufzählenFehler{
IO_ERROR= 2,
FESTPLATTENFEHLER,
NETZWERKFEHLER= 8 ,
PRINT_ERROR
};

In diesem Fall wird IO_ERROR vom Programmierer explizit dem Wert 2 zugewiesen, DISK_ERROR wird vom Compiler dem Wert 3 zugewiesen, NETWORK_ERROR wird vom Programmierer explizit dem Wert 8 zugewiesen und PRINT_ERROR wird dem nächsten zugewiesen ganzzahliger Wert des vorherigen Aufzählungselements NETWORK_ERROR (dh 9) durch den Compiler.



Sie wissen jetzt also, wie Sie einen benutzerdefinierten Aufzählungstyp in C definieren. Ist es möglich, eine Variable vom Typ Aufzählung zu deklarieren (wie wir eine Variable vom Typ Integer deklarieren können)? Ja, so ist es! Sie können die Enum-Variable wie folgt deklarieren:

aufzählenFehler Hw_Error;

Auch hier ist enum das Schlüsselwort, Error 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: Verwendung der Standard-Enum-Definition
  • Beispiel 2: Verwendung einer benutzerdefinierten Aufzählungsdefinition
  • Beispiel 3: Aufzählungsdefinition mit konstantem Ausdruck
  • Beispiel 4: Enumerationsbereich

Beispiel 1: Verwendung der Standard-Enum-Definition

In diesem Beispiel erfahren Sie, wie Sie den Aufzählungstyp mit Standardkonstantenwerten definieren. Der Compiler übernimmt die Zuweisung der Standardwerte an die Enum-Elemente. Unten sehen Sie das Beispielprogramm und die entsprechende Ausgabe.

#enthalten

/* Definiere den Aufzählungstyp */
aufzählenFehler{
IO_ERROR,
FESTPLATTENFEHLER,
NETZWERKFEHLER
};

inthauptsächlich()
{
aufzählenFehler Hw_Error; /* Enum-Variable erstellen*/

druckenf ('Hw_Error auf IO_ERROR setzen ');
Hw_Error=IO_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf DISK_ERROR setzen ');
Hw_Error=FESTPLATTENFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf NETWORK_ERROR setzen ');
Hw_Error=NETZWERKFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

Rückkehr 0;
}

https://lh6.googleusercontent.com/0CHtUqkuIA-okDEPI0_5fZLU6lZ6Exz6DK4uUr63k5Ros863eqC-HmrvZ_LZBKbEvqeCVMCsnvXXhfrYJrBaxxfZBVoiMOhzPzPzeXeyX4hzfZBV

Beispiel 2: Verwendung einer benutzerdefinierten Aufzählungsdefinition

In diesem Beispiel erfahren Sie, wie Sie den Aufzählungstyp mit einem benutzerdefinierten konstanten Wert definieren. Dieses Beispiel hilft Ihnen außerdem zu verstehen, wie die Initialisierung der benutzerdefinierten Konstanten in beliebiger Reihenfolge erfolgen kann. In diesem Beispiel haben wir den konstanten Wert für die 1 . explizit definiertNSund 3rdenum-Elemente (d. h. IO_ERROR bzw. NETWORK_ERROR), aber wir haben die explizite Initialisierung für die 2 übersprungenndund 4NSElemente. Es liegt nun in der Verantwortung des Compilers, den 2 . die Standardwerte zuzuweisenndund 4NSAufzählungselemente (d. h. DISK_ERROR bzw. PRINT_ERROR). DISK_ERROR wird dem Wert 3 zugewiesen und PRINT_ERROR wird dem Wert 9 zugewiesen. Unten sehen Sie das Beispielprogramm und die Ausgabe.

#enthalten

/* Aufzählungstyp definieren - Benutzerdefinierte Initialisierung*/
aufzählenFehler{
IO_ERROR= 2,
FESTPLATTENFEHLER,
NETZWERKFEHLER= 8,
PRINT_ERROR
};

inthauptsächlich()
{

/* Enum-Variable deklarieren*/
aufzählenFehler Hw_Error;

druckenf ('Hw_Error auf IO_ERROR setzen ');
Hw_Error=IO_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf DISK_ERROR setzen ');
Hw_Error=FESTPLATTENFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf NETWORK_ERROR setzen ');
Hw_Error=NETZWERKFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf PRINT_ERROR setzen ');
Hw_Error=PRINT_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

Rückkehr 0;
}

https://lh6.googleusercontent.com/hKtv00Hj7iPnnlNhC7mu1v7hzPhB64C9nyHwjB6oQgyCyEwOgiLSYWDOxvQCDrhumn4IzqhkN4qF9HcuGZ9thqlBLy6wzxvr04F-KafVaf0KafVaf0KafVaf0KafVaf0KafVkaf0

Beispiel 3: Enum-Definition mit konstantem Ausdruck

In diesem Beispiel erfahren Sie, wie Sie den konstanten Ausdruck verwenden, um den konstanten Wert für Aufzählungselemente zu definieren.

#enthalten

/* Aufzählungstyp definieren - benutzerdefinierte Initialisierung mit konstantem Ausdruck
konstanter Ausdruck wird hier verwendet im Fall von:
A. IO_ERROR und
B. NETZWERKFEHLER
Dies ist eine ungewöhnliche Art, die Aufzählungselemente zu definieren; aber das
Das Programm zeigt, dass diese Art der Initialisierung von Aufzählungselementen in c möglich ist.
* /


aufzählenFehler{
IO_ERROR= 1 + 2 * 3 + 4,
FESTPLATTENFEHLER,
NETZWERKFEHLER= 2 == 2,
PRINT_ERROR
};

inthauptsächlich()
{

/* Enum-Variable deklarieren*/
aufzählenFehler Hw_Error;

druckenf ('Hw_Error auf IO_ERROR setzen ');
Hw_Error=IO_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf DISK_ERROR setzen ');
Hw_Error=FESTPLATTENFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf NETWORK_ERROR setzen ');
Hw_Error=NETZWERKFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf PRINT_ERROR setzen ');
Hw_Error=PRINT_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

Rückkehr 0;
}

https://lh4.googleusercontent.com/9FAbPOnM95LiP_UQvg40oHSW4sv34aqpFgasbHMiy06Z_rKEom81TuMCVsfxWaZedtQOMEQx7ef_5qEfRVcNrUvhitDzOcTvOilby1Xregm4

Beispiel 4: Enum-Bereich

In diesem Beispiel erfahren Sie, wie die Bereichsregel für enum funktioniert. Ein MACRO (#define) hätte verwendet werden können, um eine Konstante anstelle der Aufzählung zu definieren, aber die Bereichsregel funktioniert nicht für MACRO.

#enthalten

inthauptsächlich()
{

/* Definiere den Aufzählungstyp */
aufzählenFehler_1{
IO_ERROR= 10,
FESTPLATTENFEHLER,
NETZWERKFEHLER= 3,
PRINT_ERROR
};


{

/* Definiere den Aufzählungstyp im inneren Gültigkeitsbereich*/
aufzählenFehler_1{
IO_ERROR= zwanzig,
FESTPLATTENFEHLER,
NETZWERKFEHLER= 35,
PRINT_ERROR
};

/* Enum-Variable deklarieren*/
aufzählenError_1 Hw_Error;
druckenf ('Hw_Error auf IO_ERROR setzen ');
Hw_Error=IO_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf DISK_ERROR setzen ');
Hw_Error=FESTPLATTENFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf NETWORK_ERROR setzen ');
Hw_Error=NETZWERKFEHLER;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);

druckenf (' Hw_Error auf PRINT_ERROR setzen ');
Hw_Error=PRINT_ERROR;
druckenf ('Wert von Hw_Error = %d ',Hw_Error);
}
Rückkehr 0;
}

Vergleich zwischen Enum und Makro

Aufzählung Makro
Die Bereichsregel gilt für enum. Bereichsregel gilt nicht für Makro.
Die standardmäßige Zuweisung der Enum-Werte erfolgt automatisch.

Enum ist sehr hilfreich beim Definieren einer großen Anzahl von Konstanten. Der Compiler verwendet die standardmäßige Konstantenwertinitialisierung.

Die Makrokonstantenwerte müssen vom Programmierer immer explizit genannt werden.

Dies kann bei einer großen Anzahl von Konstanten ein mühsamer Prozess sein, da der Programmierer beim Definieren des Makros immer jeden Konstantenwert manuell definieren muss.

Abschluss

Das Aufzählungsprogramm in C könnte als optionale Methode für eigenständige Programme oder kleine Projekte angesehen werden, da Programmierer immer Makros anstelle einer Aufzählung verwenden können. Erfahrene Programmierer neigen jedoch dazu, für umfangreiche Softwareentwicklungsprojekte Enumeration über Makro zu verwenden. Dies hilft beim Schreiben sauberer und lesbarer Programme.