Aufzählungstyp - Enumerated type

In der Computerprogrammierung , ein Aufzählungstyp (auch genannt Enumeration , ENUM oder Faktor in der R - Programmiersprache und eine kategorische Variable in der Statistik) ist ein Datentyp aus einem Satz von benannten bestehend Werten genannt Elemente , Elemente , enumeral oder Aufzählungen von der Typ. Die Enumeratornamen sind normalerweise Bezeichner , die sich in der Sprache wie Konstanten verhalten . Ein Aufzählungstyp kann als eine degenerierte getaggte Vereinigung des Einheitentyps angesehen werden . Einer Variablen , die als Aufzählungstyp deklariert wurde , kann jeder Enumerator als Wert zugewiesen werden. Mit anderen Worten, ein Aufzählungstyp hat Werte, die sich voneinander unterscheiden und die verglichen und zugewiesen werden können, aber vom Programmierer nicht als eine bestimmte konkrete Darstellung im Speicher des Computers angegeben werden; Compiler und Interpreter können sie beliebig darstellen.

Zum Beispiel können die vier Farben in einem Kartenspiel vier Aufzählungszeichen namens Club , Diamond , Heart und Spade sein , die zu einem Aufzählungstyp namens Suit gehören . Wenn eine Variable V mit Suit als Datentyp deklariert ist , kann man ihr jeden dieser vier Werte zuweisen.

Obwohl die Enumeratoren normalerweise unterschiedlich sind, können einige Sprachen zulassen, dass derselbe Enumerator zweimal in der Deklaration des Typs aufgeführt wird. Die Namen von Enumeratoren müssen in keiner Weise semantisch vollständig oder kompatibel sein. Ein Aufzählungstyp namens color kann beispielsweise so definiert werden, dass er aus den Aufzählungen Red , Green , Zebra , Missing und Bacon besteht . In einigen Sprachen definiert die Deklaration eines Aufzählungstyps auch absichtlich eine Reihenfolge seiner Member; in anderen sind die Enumeratoren ungeordnet; in anderen wiederum entsteht eine implizite Ordnung dadurch, dass der Compiler Enumeratoren konkret als ganze Zahlen darstellt.

Einige Enumeratortypen können in die Sprache integriert sein. Der Typ Boolean ist beispielsweise oft eine vordefinierte Aufzählung der Werte False und True . In vielen Sprachen können Benutzer neue Aufzählungstypen definieren.

Werte und Variablen eines Aufzählungstyps werden normalerweise als Bitstrings fester Länge implementiert , oft in einem Format und einer Größe, die mit einem ganzzahligen Typ kompatibel sind . Einige Sprachen, insbesondere Systemprogrammiersprachen , ermöglichen es dem Benutzer, die für jeden Enumerator zu verwendende Bitkombination anzugeben. In der Typentheorie werden Aufzählungstypen oft als getaggte Vereinigungen von Unit-Typen betrachtet . Da solche Typen die Form haben , können sie auch als natürliche Zahlen geschrieben werden. $1+1+\cdots+1$

Begründung

Einige frühe Programmiersprachen hatten ursprünglich keine Aufzählungstypen. Wenn ein Programmierer möchte, dass eine Variable, zum Beispiel myColor , den Wert red hat, würde die Variable red deklariert und einem beliebigen Wert zugewiesen, normalerweise eine ganzzahlige Konstante. Die Variable Rot würde dann myColor zugewiesen . Andere Techniken weisen Strings, die die Namen der Enumeratoren enthalten, beliebige Werte zu.

Diese willkürlichen Werte wurden manchmal als magische Zahlen bezeichnet, da es oft keine Erklärung dafür gab, wie die Zahlen erhalten wurden oder ob ihre tatsächlichen Werte signifikant waren. Diese magischen Zahlen könnten es anderen erschweren, den Quellcode zu verstehen und zu warten.

Aufzählungstypen hingegen machen den Code selbstdokumentierender. Abhängig von der Sprache könnte der Compiler den Enumeratoren automatisch Standardwerte zuweisen und so unnötige Details vor dem Programmierer verbergen. Diese Werte sind möglicherweise nicht einmal für den Programmierer sichtbar (siehe Ausblenden von Informationen ). Aufzählungstypen können einen Programmierer auch daran hindern, unlogischen Code zu schreiben, wie zum Beispiel mathematische Operationen an den Werten der Enumeratoren durchzuführen. Wenn der Wert einer Variablen, der ein Enumerator zugewiesen wurde, ausgegeben werden soll, können einige Programmiersprachen auch den Namen des Enumerators anstelle des zugrunde liegenden numerischen Werts ausgeben. Ein weiterer Vorteil besteht darin, dass Aufzählungstypen Compilern ermöglichen können, semantische Korrektheit zu erzwingen. Zum Beispiel: myColor = TRIANGLE kann verboten werden, während myColor = RED akzeptiert wird, auch wenn DREIECK und ROT intern beide als 1 dargestellt werden .

Vom Konzept her ähnelt ein Aufzählungstyp einer Liste von Nominalen (numerischen Codes), da jedem möglichen Wert des Typs eine eindeutige natürliche Zahl zugewiesen wird. Ein gegebener Aufzählungstyp ist somit eine konkrete Implementierung dieses Begriffs. Wenn die Reihenfolge sinnvoll ist und/oder zum Vergleich verwendet wird, wird aus einem Aufzählungstyp ein Ordinaltyp .

Konventionen

Programmiersprachen neigen dazu, ihre eigenen, oft mehrfachen, Programmierstile und Namenskonventionen zu haben . Die einer Aufzählung zugewiesene Variable ist normalerweise ein Nomen in Singularform und folgt häufig entweder einer PascalCase- oder Großbuchstabenkonvention , während Kleinbuchstaben und andere weniger häufig vorkommen.

Syntax in mehreren Programmiersprachen

Pascal und syntaktisch ähnliche Sprachen

Pascal

In Pascal kann ein Aufzählungstyp implizit deklariert werden, indem die Werte in einer Liste in Klammern aufgelistet werden:

  var
    suit: (clubs, diamonds, hearts, spades);

Die Deklaration erscheint oft in einer Typsynonymdeklaration, sodass sie für mehrere Variablen verwendet werden kann:

  type
    cardsuit = (clubs, diamonds, hearts, spades);
    card = record
             suit: cardsuit;
             value: 1 .. 13;
           end;
  var
    hand: array [ 1 .. 13 ] of card;
    trump: cardsuit;

Die Reihenfolge, in der die Aufzählungswerte angegeben werden, ist von Bedeutung. Ein Aufzählungstyp ist ein Ordnungstyp, und die predund succFunktionen werden den vorherigen oder nächsten Wert der Enumeration geben und ordkönnen Enumerationswerten ihre Integerdarstellung umwandeln. Standard Pascal bietet jedoch keine Konvertierung von arithmetischen Typen in Aufzählungen an. Extended Pascal bietet diese Funktionalität über eine erweiterte succFunktion. Einige andere Pascal-Dialekte erlauben dies über Typumwandlungen. Einige moderne Nachkommen von Pascal, wie Modula-3 , bieten eine spezielle Konvertierungssyntax mit einer Methode namens VAL; Modula-3 behandelt auch BOOLEANund CHARals spezielle vordefinierte Aufzählungstypen und Verwendungen ORDund VALfür die Standard- ASCII- Dekodierung und -Kodierung.

Sprachen im Pascal-Stil ermöglichen auch die Verwendung von Aufzählungen als Array-Index:

  var
    suitcount: array [cardsuit] of integer;

Ada

In Ada wurde die Verwendung von "=" durch "ist" ersetzt, wodurch die Definition ziemlich ähnlich blieb:

type Cardsuit is (clubs, diamonds, hearts, spades);

Neben Pred, Succ, Valund Posunterstützt Ada auch einfache String-Konvertierungen über Imageund Value.

Ähnlich wie bei Sprachen im C-Stil ermöglicht Ada die Angabe der internen Darstellung der Aufzählung:

for Cardsuit use
  (clubs => 1, diamonds => 2, hearts => 4, spades => 8);

Im Gegensatz zu Sprachen im C-Stil ermöglicht Ada auch die Angabe der Anzahl der Bits der Aufzählung:

for Cardsuit'Size use 4;  -- 4 bits

Außerdem kann man Aufzählungen als Indizes für Arrays verwenden, wie in Pascal, aber für Aufzählungen sind Attribute definiert

   Shuffle : constant array(Cardsuit) of Cardsuit :=
     (Clubs => Cardsuit'Succ(Clubs), -- see attributes of enumerations 'First, 'Last, 'Succ, 'Pred
      Diamonds => Hearts, --an explicit value
      Hearts => Cardsuit'Last, --first enumeration value of type Cardsuit e.g., clubs
      Spades => Cardsuit'First --last enumeration value of type Cardsuit e.g., spades
      );

Wie Modula-3 behandelt Ada Booleanund Characterals spezielle vordefinierte (im Paket " Standard") aufgezählte Typen. Im Gegensatz zu Modula-3 kann man auch eigene Zeichentypen definieren:

type Cards is ('7', '8', '9', 'J', 'Q', 'K', 'A');

C und syntaktisch ähnliche Sprachen

C

Der ursprüngliche K&R- Dialekt der Programmiersprache C hatte keine Aufzählungstypen. In C werden Aufzählungen durch explizite Definitionen erstellt (das enumSchlüsselwort allein verursacht keine Speicherzuweisung), die das enumSchlüsselwort verwenden und an struct- und union- Definitionen erinnern :

enum cardsuit {
    Clubs,
    Diamonds,
    Hearts,
    Spades
};

struct card {
    enum cardsuit suit;
    short int value;
} hand[13];

enum cardsuit trump;

C stellt dem Programmierer die ganzzahlige Darstellung von Aufzählungswerten direkt zur Verfügung. Integer- und Enum-Werte können frei gemischt werden, und alle arithmetischen Operationen auf Enum-Werten sind erlaubt. Es ist sogar möglich, dass eine Aufzählungsvariable eine ganze Zahl enthält, die keinen der Aufzählungswerte darstellt. Tatsächlich definiert der obige Code gemäß der Sprachdefinition Clubs, Diamonds, Hearts, und Spadesals Konstanten vom Typ int, die nur (still) in konvertiert werden, enum cardsuitwenn sie in einer Variablen dieses Typs gespeichert sind.

C erlaubt dem Programmierer auch, die Werte der Aufzählungskonstanten explizit auszuwählen, auch ohne Typ. Zum Beispiel,

enum cardsuit {
    Clubs    = 1,
    Diamonds = 2,
    Hearts   = 4,
    Spades   = 8
};

könnte verwendet werden, um einen Typ zu definieren, der es ermöglicht, mathematische Sätze von Farben enum cardsuitdurch bitweise logische Operationen darzustellen.

C#

Aufzählungstypen in der Programmiersprache C# behalten die meisten der "kleinen Ganzzahl"-Semantik der Aufzählungen von C bei. Einige arithmetische Operationen sind nicht für Aufzählungen definiert, aber ein Aufzählungswert kann explizit in eine ganze Zahl und wieder zurück konvertiert werden, und eine Aufzählungsvariable kann Werte haben, die nicht durch die Aufzählungsdefinition deklariert wurden. Zum Beispiel gegeben

enum Cardsuit
{
    Clubs,
    Diamonds,
    Spades,
    Hearts
}

die Ausdrücke CardSuit.Diamonds + 1und CardSuit.Hearts - CardSuit.Clubssind direkt erlaubt (weil es sinnvoll sein kann, die Wertefolge zu durchlaufen oder zu fragen, wie viele Schritte zwischen zwei Werten liegen), wird aber CardSuit.Hearts * CardSuit.Spadesals wenig sinnvoll erachtet und ist nur erlaubt, wenn die Werte zuerst in ganze Zahlen umgewandelt werden .

C# bietet auch die C-ähnliche Funktion, bestimmte ganzzahlige Werte für Enumerationen definieren zu können. Auf diese Weise ist es möglich, binäre Operationen an Aufzählungen durchzuführen, wodurch Aufzählungswerte als Sätze von Flags behandelt werden. Diese Flags können mit binären Operationen oder mit der eingebauten Methode 'HasFlag' des Enum-Typs getestet werden.

Die Aufzählungsdefinition definiert Namen für die ausgewählten Integer-Werte und ist syntaktischer Zucker , da es möglich ist, einer Aufzählungsvariablen andere Integer-Werte zuzuweisen, die nicht in den Geltungsbereich der Aufzählungsdefinition fallen.

C++

C++ hat Aufzählungstypen, die direkt von Cs geerbt werden und größtenteils wie diese funktionieren, außer dass eine Aufzählung ein echter Typ in C++ ist, was eine zusätzliche Überprüfung zur Kompilierzeit ermöglicht. Außerdem wird (wie bei structs) das C++- enumSchlüsselwort automatisch mit einem typedef kombiniert , sodass Sie den Typ enum nameeinfach benennen , anstatt ihn zu benennen name. Dies kann in C mit einem typedef simuliert werden:typedef enum {Value1, Value2} name;

C++11 bietet einen zweiten, typsicheren Enumerationstyp, der nicht implizit in einen Integer-Typ konvertiert wird. Es ermöglicht die Definition von io-Streaming für diesen Typ. Außerdem sind die Aufzählungen nicht durchgesickert, daher müssen sie mit Enumeration verwendet werden Type::enumeration. Dies wird durch den Ausdruck "enum class" angegeben. Zum Beispiel:

enum class Color {Red, Green, Blue};

Der zugrunde liegende Typ ist ein implementierungsdefinierter ganzzahliger Typ, der groß genug ist, um alle Aufzählungswerte aufzunehmen (es muss nicht der kleinstmögliche Typ sein!). In C++ können Sie den zugrunde liegenden Typ direkt angeben. Das ermöglicht "Vorwärtsdeklarationen" von Aufzählungen:

enum class Color : long {Red, Green, Blue};  // must fit in size and memory layout the type 'long'
enum class Shapes : char;  // forward declaration. If later there are values defined that don't fit in 'char' it is an error.

gehen

Go verwendet das iotaSchlüsselwort, um Aufzählungskonstanten zu erstellen.

type ByteSize float64

const (
    _           = iota // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
)

Java

Die J2SE-Version 5.0 der Programmiersprache Java hat Aufzählungstypen hinzugefügt, deren Deklarationssyntax der von C ähnlich ist :

enum Cardsuit { CLUBS, DIAMONDS, SPADES, HEARTS };
...
Cardsuit trump;

Das Java-Typsystem behandelt Aufzählungen jedoch als einen von Ganzzahlen getrennten Typ, und eine Vermischung von Aufzählungs- und Ganzzahlwerten ist nicht zulässig. Tatsächlich ist ein Aufzählungstyp in Java eher eine spezielle vom Compiler generierte Klasse als ein arithmetischer Typ, und Aufzählungswerte verhalten sich wie globale vorgenerierte Instanzen dieser Klasse. Aufzählungstypen können Instanzmethoden und einen Konstruktor haben (deren Argumente für jeden Aufzählungswert separat angegeben werden können). Alle Enum-Typen erweitern implizit die Enumabstrakte Klasse. Ein Aufzählungstyp kann nicht direkt instanziiert werden.

Intern enthält jeder Aufzählungswert eine ganze Zahl, entsprechend der Reihenfolge, in der sie im Quellcode deklariert werden, beginnend bei 0. Der Programmierer kann nicht direkt eine benutzerdefinierte Ganzzahl für einen Aufzählungswert festlegen, aber man kann überladene Konstruktoren definieren , die dann zuweisen können beliebige Werte zu selbstdefinierten Membern der Enum-Klasse. Das Definieren von Gettern ermöglicht dann den Zugriff auf diese selbstdefinierten Member. Die interne ganze Zahl kann mithilfe der ordinal()Methode aus einem Aufzählungswert abgerufen werden, und die Liste der Aufzählungswerte eines Aufzählungstyps kann mithilfe der Methode der Reihe nach abgerufen values()werden. Programmierern wird im Allgemeinen davon abgeraten, Aufzählungen in Ganzzahlen umzuwandeln und umgekehrt. Aufgezählte Typen sind Comparable, mit der internen Ganzzahl; Dadurch können sie sortiert werden.

Die Java-Standardbibliothek stellt Dienstprogrammklassen zur Verwendung mit Enumerationen bereit. Die EnumSetKlasse implementiert a Setvon Aufzählungswerten; es ist als Bit-Array implementiert , was es sehr kompakt und so effizient wie die explizite Bit-Manipulation macht, aber sicherer. Die EnumMapKlasse implementiert eine MapAnzahl von Aufzählungswerten in ein Objekt. Es ist als Array implementiert, wobei der ganzzahlige Wert des Enum-Werts als Index dient.

Perl

Dynamisch typisierte Sprachen in der syntaktischen Tradition von C (zB Perl oder JavaScript ) bieten im Allgemeinen keine Aufzählungen. Aber in der Perl-Programmierung kann das gleiche Ergebnis mit der Abkürzung strings list und hashes (möglicherweise Slices ) erzielt werden :

my @enum = qw(Clubs Diamonds Hearts Spades);
my( %set1, %set2 );
@set1{@enum} = ();          # all cleared
@set2{@enum} = (1) x @enum; # all set to 1
$set1{Clubs} ...            # false
$set2{Diamonds} ...         # true

Raku

Raku (früher bekannt als Perl 6) unterstützt Aufzählungen. Es gibt mehrere Möglichkeiten, Aufzählungen in Raku zu deklarieren, wobei alle eine Back-End-Map erstellen.

enum Cat <sphynx siamese bengal shorthair other>; # Using "quote-words"

enum Cat ('sphynx', 'siamese', 'bengal', 'shorthair', 'other'); # Using a list

enum Cat (sphynx => 0, siamese => 1, bengal => 2, shorthair => 3, other => 4); # Using Pair constructors

enum Cat (:sphynx(0), :siamese(1), :bengal(2), shorthair(3), :other(4)); # Another way of using Pairs, you can also use `:0sphynx`

PHP

Enums wurden in PHP-Version 8.1 hinzugefügt.

enum CardSuit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;
}

Rost

Obwohl Rust das enumSchlüsselwort wie C verwendet, verwendet es es, um getaggte unions zu beschreiben , von denen Aufzählungen als eine degenerierte Form angesehen werden können. Die Enumerationen von Rust sind daher viel flexibler und können Struktur- und Tupelvarianten enthalten.

enum Message {
    Quit,
    Move { x: i32, y: i32 }, // struct
    Write(String), // single-element tuple
    ChangeColor(i32, i32, i32), // three-element tuple
}

Schnell

In C weisen Aufzählungen einem Satz ganzzahliger Werte verwandte Namen zu. In Swift sind Aufzählungen viel flexibler und müssen nicht für jeden Fall der Aufzählung einen Wert angeben. Wenn für jeden Aufzählungsfall ein Wert (als Rohwert bezeichnet) bereitgestellt wird, kann der Wert eine Zeichenfolge, ein Zeichen oder ein Wert eines beliebigen Ganzzahl- oder Gleitkommatyps sein.

Alternativ können Aufzählungsfälle zugehörige Werte eines beliebigen Typs angeben, die zusammen mit jedem unterschiedlichen Fallwert gespeichert werden, ähnlich wie dies bei Vereinigungen oder Varianten in anderen Sprachen der Fall ist. Als Teil einer Enumeration kann ein gemeinsamer Satz verwandter Fälle definiert werden, von denen jeder einen anderen Satz von Werten geeigneter Typen zugeordnet hat.

In Swift sind Aufzählungen ein erstklassiger Typ. Sie übernehmen viele Funktionen, die traditionell nur von Klassen unterstützt werden, z. B. berechnete Eigenschaften, um zusätzliche Informationen über den aktuellen Wert der Enumeration bereitzustellen, und Instanzmethoden, um Funktionen in Bezug auf die Werte bereitzustellen, die die Enumeration darstellt. Aufzählungen können auch Initialisierer definieren, um einen anfänglichen Fallwert bereitzustellen, und können erweitert werden, um ihre Funktionalität über ihre ursprüngliche Implementierung hinaus zu erweitern; und kann Protokollen entsprechen, um Standardfunktionen bereitzustellen.

enum CardSuit {
    case clubs
    case diamonds
    case hearts
    case spades
}

Im Gegensatz zu C und Objective-C wird Swift-Enumerationsfällen beim Erstellen kein ganzzahliger Standardwert zugewiesen. Im obigen CardSuit-Beispiel sind Kreuz, Karo, Herz und Pik nicht implizit gleich 0, 1, 2 und 3. Stattdessen sind die verschiedenen Aufzählungsfälle eigenständige Werte mit einem explizit definierten CardSuit-Typ .

Mehrere Fälle können in einer einzigen Zeile durch Kommas getrennt erscheinen:

enum CardSuit {
    case clubs, diamonds, hearts, spades
}

Wenn Sie mit Aufzählungen arbeiten, die Integer- oder String-Rohwerte speichern, muss man nicht für jeden Fall explizit einen Rohwert zuweisen, da Swift die Werte automatisch zuweist.

Wenn zum Beispiel ganze Zahlen für Rohwerte verwendet werden, ist der implizite Wert für jeden Fall eins mehr als im vorherigen Fall. Wenn für den ersten Fall kein Wert festgelegt ist, ist sein Wert 0.

Die folgende Aufzählung ist eine Verfeinerung der früheren Planeten-Aufzählung mit ganzzahligen Rohwerten, um die Reihenfolge jedes Planeten von der Sonne aus darzustellen:

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

Im obigen Beispiel hat Planet.mercury einen expliziten Rohwert von 1, Planet.venus hat einen impliziten Rohwert von 2 und so weiter.

"Details finden Sie in der Swift-Dokumentation online hier."

Typoskript

TypeScript fügt JavaScript einen 'enum'-Datentyp hinzu.

enum Cardsuit {Clubs, Diamonds, Hearts, Spades};
var c: Cardsuit = Cardsuit.Diamonds;

Enumeriert standardmäßig Nummernelemente beginnend bei 0; dies kann überschrieben werden, indem der Wert des ersten gesetzt wird:

enum Cardsuit {Clubs = 1, Diamonds, Hearts, Spades};
var c: Cardsuit = Cardsuit.Diamonds;

Alle Werte können eingestellt werden:

enum Cardsuit {Clubs = 1, Diamonds = 2, Hearts = 4, Spades = 8};
var c: Cardsuit = Cardsuit.Diamonds;

TypeScript unterstützt die Zuordnung des numerischen Werts zu seinem Namen. Dies findet beispielsweise den Namen des Wertes 2:

enum Cardsuit {Clubs = 1, Diamonds, Hearts, Spades};
var suitName: string = Cardsuit[2];

alert(suitName);

Python

enumIn Version 3.4 wurde der Python-Standardbibliothek ein Modul hinzugefügt.

from enum import Enum
class Cards(Enum):
    CLUBS = 1
    DIAMONDS = 2
    HEARTS = 3
    SPADES = 4

Es gibt auch eine funktionale API zum Erstellen von Aufzählungen mit automatisch generierten Indizes (beginnend mit einem):

Cards = Enum('Cards', 'CLUBS DIAMONDS HEARTS SPADES'])

Python-Enumerationen erzwingen keine semantische Korrektheit (ein bedeutungsloser Vergleich mit einer inkompatiblen Enumeration gibt immer False zurück, anstatt einen TypeError auszulösen ):

>>> Color = Enum("Color", "RED GREEN BLUE")
>>> Shape = Enum("Shape", ["CIRCLE", "TRIANGLE", "SQUARE", "HEXAGON"])
>>> def has_vertices(shape):
... 	return shape != Shape.CIRCLE
...
>>> has_vertices(Color.GREEN)
True

Fortran

Fortran hat nur Aufzählungstypen für die Interoperabilität mit C; daher ist die Semantik C ähnlich, und wie in C sind die Enum-Werte nur ganze Zahlen und es wird keine weitere Typprüfung durchgeführt. Das C-Beispiel von oben kann in Fortran geschrieben werden als

enum, bind( C )
  enumerator :: CLUBS = 1, DIAMONDS = 2, HEARTS = 4, SPADES = 8
end enum

Visual Basic/VBA

Aufgezählten Datentypen in Visual Basic (bis Version 6) und VBA wird automatisch der LongDatentyp " " zugewiesen und werden auch selbst zum Datentyp:

'Zero-based
Enum CardSuit
    Clubs
    Diamonds
    Hearts
    Spades
End Enum

Sub EnumExample()
    Dim suit As CardSuit
    suit = Diamonds
    MsgBox suit
End Sub

Beispielcode in VB.NET

Enum CardSuit
    Clubs
    Diamonds
    Hearts
    Spades
End Enum

Sub EnumExample()
    Dim suit As CardSuit
    suit = CardSuit.Diamonds
    MessageBox.show(suit)
End Sub

Lispeln

Common Lisp verwendet den Membertyp-Bezeichner, z.

(deftype cardsuit ()
  '(member club diamond heart spade))

das besagt, dass das Objekt vom Typ Cardsuit ist, wenn es sich #'eqlum Kreuz, Karo , Herz oder Pik handelt. Der Membertypbezeichner ist jedoch nicht als Parameterspezialist für Common Lisp Object System (CLOS) gültig . Stattdessen kann (eql atom)das Äquivalent zu (member atom)verwendet werden (d. h., es kann nur ein Mitglied der Menge mit einem eql-Typspezifizierer angegeben werden, es kann jedoch als CLOS-Parameterspezialist verwendet werden.) Mit anderen Worten, um Methoden zu definieren Um einen Aufzählungstyp abzudecken, muss für jedes spezifische Element dieses Typs eine Methode definiert werden.

Zusätzlich,

(deftype finite-element-set-type (&rest elements)
   `(member ,@elements))

kann verwendet werden, um beliebige Aufzählungstypen zur Laufzeit zu definieren. Zum Beispiel

(finite-element-set-type club diamond heart spade)

würde sich auf einen Typ beziehen, der der früheren Definition von cardsuit entspricht, da er natürlich einfach verwendet hätte

(member club diamond heart spade)

kann aber #'memberaus stilistischen Gründen mit der Funktion weniger verwirrend sein.

Algebraischer Datentyp in der funktionalen Programmierung

In funktionalen Programmiersprachen der ML- Abstammung (zB Standard ML (SML), OCaml und Haskell ) kann ein algebraischer Datentyp mit nur nullären Konstruktoren verwendet werden, um einen Aufzählungstyp zu implementieren. Zum Beispiel (in der Syntax von SML-Signaturen):

datatype cardsuit = Clubs | Diamonds | Hearts | Spades
type card = { suit: cardsuit; value: int }
val hand : card list
val trump : cardsuit

In diesen Sprachen ist die kleinzahlige Darstellung dem Programmierer vollständig verborgen, falls eine solche Darstellung tatsächlich von der Implementierung verwendet wird. Haskell verfügt jedoch über die Enum Typklasse, die ein Typ ableiten oder implementieren kann, um eine Zuordnung zwischen dem Typ und zu erhalten Int.

Datenbanken

Einige Datenbanken unterstützen Aufzählungstypen direkt. MySQL bietet einen Aufzählungstyp ENUMmit zulässigen Werten, die beim Erstellen einer Tabelle als Strings angegeben werden. Die Werte werden als numerische Indizes gespeichert, wobei der leere String als 0 gespeichert wird, der erste Stringwert als 1, der zweite Stringwert als 2 gespeichert wird usw. Werte können als numerische Indizes oder Stringwerte gespeichert und abgerufen werden.

Beispiel:

CREATE TABLE shirts (
    name VARCHAR(40),
    size ENUM('x-small', 'small', 'medium', 'large', 'x-large')
);

XML-Schema

XML-Schema unterstützt Aufzählungstypen durch die Aufzählungsfacette, die zum Einschränken der meisten primitiven Datentypen wie Strings verwendet wird.

<xs:element name="cardsuit">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:enumeration value="Clubs"/>
      <xs:enumeration value="Diamonds"/>
      <xs:enumeration value="Hearts"/>
      <xs:enumeration value="Spades"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

Siehe auch

Kontrast eingestellt

Verweise

Externe Links

Languages

In other projects