Aufzählungen

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Aufzählungen - Index

Der Datentyp Aufzählung erlaubt es, statt einer Menge von konstanten Integerwerten entsprechende Bezeichner zu verwenden. Zum Beispiel wird in der folgenden Deklaration:

enum tage { so, mo, di, mi, do, fr, sa } alletage;

Die vorstehende Deklaration ergibt den eindeutigen ganzzahligen Typ tage, die Variable irgendein_tag von eben diesem Typ sowie eine Menge von Aufzählungskonstanten (so, mo, ...) mit ganzzahligen Werten.

The Compiler-Option -b steuert die Option “Aufzählungen als Int behandeln”. Wenn diese Option verwendet wird, reserviert der Compiler für Aufzählungstypen (Variablen vom Typ enum) ein ganzes Wort (einen 4-Byte-Integer). Die Standardeinstellung ist <ON> (Aufzählungstypen sind also normalerweise vom Typ int), wenn der Wertebereich es zulässt. In Ausdrücken werden die Werte von Aufzählungstypen immer auf Integer ausgedehnt. Die Bezeichner in einer Aufzählungsliste sind implizit vom Typ signed char, unsigned char oder int, abhängig vom Wertebereich der Aufzählung. Können alle Werte in einem signed oder unsigned char gespeichert werden, wird einer dieser Typen verwendet.

In C kann einer Aufzählungstypvariablen jeder Wert vom Typ int zugewiesen werden – es gibt keine darüberhinausgehende Typenprüfung. In C++ dagegen kann einer derartigen Variable nur einer der bereits aufgezählten Bezeichner zugewiesen werden: Zum Beispiel:

anyday = mon;        // OK
alletage = 1;       // ungültig, obwohl mo == 1

Der Bezeichner tage ist ein optionales Aufzählungs-Tag und kann in nachfolgenden Deklarationen von Aufzählungsvariablen des Typs enum tage verwendet werden:

enum tage Zahltag, Feiertag; // deklariert zwei Variablen

In C++ können Sie das Schlüsselwort enum auch weglassen, wenn tage im aktuellen Gültigkeitsbereich keine andere Bedeutung hat.

Genauso wie bei Strukturen und Varianten kann man den Tag-Namen weglassen, wenn keine weiteren Variablen dieses Aufzählungstyps benötigt werden:

enum { so, mo, di, mi, do, fr, sa } alletage;
/* anonymer Aufzählungstyp */

Die Aufzählungsbezeichner innerhalb der geschweiften Klammern heißen Aufzählungskonstanten. Jeder dieser Konstanten ist ein fester Integerwert zugewiesen. Sind keine expliziten Initialisierer vorhanden, wird die erste Konstante so auf Null gesetzt und die folgenden in Einerschritten aufsteigend belegt (mo = 1, di = 2 usw.). Weitere Informationen hierzu finden Sie unter Aufzählungstyp-Konstanten.

Mittels expliziter Initialisierer können Sie jedoch eine oder mehrere Konstanten auf einen bestimmten Wert setzen. Alle folgenden Konstanten werden dann mit jeweils um 1 steigenden Konstanten initialisiert. In dem folgenden Deklarationsbeispiel:

/* Die Initialisierung kann bereits deklarierte Aufzählungskonstanten enthalten */
enum coins { penny = 1, tuppence, nickel = penny + 4, dime = 10,
             quarter = nickel * nickel } smallchange;

hat tuppence den Wert 2, nickel den Wert 5 und quarter den Wert 25.

Zur Initialisierung kann jeder Ausdruck verwendet werden, der einen positiven oder negativen Integerwert ergibt (nach möglichen Integerausdehnungen). Diese Werte sind normalerweise eindeutig, doppelt vorkommende sind aber erlaubt.

Aufzählungstypen können immer dann verwendet werden, wenn int-Typen zulässig sind.

enum tage { so, mo, di, mi, do, fr, sa } alletage;
enum tage Zahltag;
typedef enum tage TAGE;
TAGE *tageptr;
int i = di;
anyday = mon;        // OK
tageptr = alletage;   // OK
mo = di;              // UNGÜLTIG: mo ist eine Konstante

Die Tag-Namen von Aufzählungstypen teilen sich den Namespace mit Struktur und Varianten. Die aufgezählten Konstanten teilen sich den Namespace mit normalen Variablen:

int mo = 11;
{
   enum tage { so, mo, di, mi, do, fr, sa } alletage;
   /* Die Aufzählungskonstante mo verdeckt die vorherige Deklaration von int mo */
   struct days { int i, j;};   // UNGÜLTIG: doppeltes Tag-Tag
   double sat;                 // UNGÜLTIG: Neudefinition von sat
}
mo = 12;                       // zurück im Gültigkeitsbereich von int mo

In C++ gelten Aufzählungskonstanten, die in einer Klasse definiert wurden, nur im Gültigkeitsbereich dieser Klasse.

In C++ können die meisten Operatoren für einen Aufzählungstyp überladen werden. Weil die Operatoren =, [ ], ( ) und ­-> jedoch als Elementfunktion überladen sein müssen, können sie nicht für eine Aufzählung überladen werden. Im folgenden Beispiel für das Überladen von Operatoren des Aufzählungstyps enum wird gezeigt, wie die Operatoren Suffix- und Präfix-Inkrement überladen werden.