Tipo enumerado

En Pascal , un tipo enumerado se puede declarar implícitamente enumerando los valores en una lista entre paréntesis:

var traje : ( tréboles , diamantes , corazones , picas ) ;

La declaración aparecerá a menudo en una declaración de sinónimo de tipo, de modo que pueda utilizarse para múltiples variables:

tipo cardsuit = ( tréboles , diamantes , corazones , picas ) ; carta = registro palo : cardsuit ; valor : 1 .. 13 ; fin ; var mano : matriz [ 1 .. 13 ] de carta ; triunfo : cardsuit ;

El orden en que se dan los valores de enumeración importa. Un tipo enumerado es un tipo ordinal, y las predfunciones succy darán el valor anterior o siguiente de la enumeración, y ordpueden convertir valores de enumeración a su representación entera. Sin embargo, Pascal estándar no ofrece una conversión de tipos aritméticos a enumeraciones. Pascal extendido ofrece esta funcionalidad a través de una succfunción extendida. Algunos otros dialectos de Pascal lo permiten a través de conversiones de tipo. Algunos descendientes modernos de Pascal, como Modula-3 , proporcionan una sintaxis de conversión especial usando un método llamado VAL; Modula-3 también trata BOOLEANy CHARcomo tipos enumerados predefinidos especiales y usa ORDy VALpara la decodificación y codificación ASCII estándar.

Los lenguajes de estilo Pascal también permiten que la enumeración se utilice como índice de matriz:

var suitcount : array [ cardsuit ] of integer ;

En Ada , la definición de tipos enumerados es similar a la de Pascal, reemplazando el uso de "=" con "is":

El tipo de palo de cartas es ( tréboles , diamantes , corazones , picas );

Además de Pred, Succ, Valy PosAda también admite conversiones de cadena simples a través de Imagey Value.

De forma similar a los lenguajes de estilo C, Ada permite especificar la representación interna de la enumeración:

para uso de palos de cartas ( tréboles => 1 , diamantes => 2 , corazones => 4 , picas => 8 );

Ada también permite especificar el número de bits de la enumeración de forma sencilla, a diferencia de los lenguajes de estilo C que tienen un soporte inconsistente que a menudo conduce a sutiles errores de compilación . ^{[ 1 ]} Por ejemplo:

para Cardsuit ' Size use 4 ; -- 4 bits

Además, se pueden usar enumeraciones como índices para arreglos, como en Pascal, pero hay atributos definidos para las enumeraciones.

Barajar : matriz constante ( Cardsuit ) de Cardsuit := ( Clubs => Cardsuit ' Succ ( Clubs ), -- ver atributos de enumeraciones 'First, 'Last, 'Succ, 'Pred Diamonds => Hearts , -- un valor explícito Hearts => Cardsuit ' Last , -- primer valor de enumeración de tipo Cardsuit, por ejemplo, clubs Spades => Cardsuit ' First -- último valor de enumeración de tipo Cardsuit, por ejemplo, spades );

Al igual que Modula-3, Ada trata Booleany Charactercomo tipos enumerados especiales predefinidos (en el paquete " Standard"). A diferencia de Modula-3, también se pueden definir tipos de caracteres propios:

El tipo de tarjetas es (' 7 ', ' 8 ', ' 9 ', ' X ', ' J ', ' Q ', ' K ', ' A ');

Ni el PL/I original ni el ANSI X3.53–1976 tienen enumeraciones, pero el IBM Enterprise PL/I ^{[ 2 ]} tiene tipos ordinales.

Una variable ordinal no se puede usar directamente como subíndice o como límite de DO TO . Sin embargo,

1. Las funciones de tipo first y last , y las funciones integradas binaryvalue , ordinalpred y ordinalsucc , lo permiten indirectamente.
2. HACER HACIA ARRIBA y HACER HACIA ABAJO apoyan los ordinales

define ordinal foo ( verde , con , envidia ) ; declare ix ordinal foo , bar ( first ( : foo :) : last ( : foo :)) fixed bin ; do i = first ( : foo :) to last ( : foo :) ; bar ( i )= 13 ; end ; do ix = first ( : foo :) upthru last ( : foo :) ; i = binaryvalue ( ix ) ; bar ( i ) = bar ( i ) + 1 ; end ; do ix = first ( : foo :) repeat ordinalsucc ( ix ) until ( ix = first ( : foo :)) /* detenerse al volver a la normalidad. */ ; i = binaryvalue ( ix ) ; display ( bar ( i ) || ' en ' || ix ) ; end ;

El dialecto K&R original del lenguaje de programación C no tenía tipos enumerados. ^{[ 3 ]} En C, las enumeraciones se crean mediante definiciones explícitas (la enumpalabra clave por sí sola no causa asignación de almacenamiento) que utilizan la enumpalabra clave y recuerdan a las definiciones de struct y union :

typedef enum { CLUBS , DIAMONDS , HEARTS , SPADES , } CardPait ;typedef struct { CardSuit traje ; short int valor ; } Carta ;Mano de cartas [ 13 ]; Palo de triunfo ;

C expone la representación entera de los valores de enumeración directamente al programador. Los enteros y los valores de enumeración se pueden combinar libremente, y se permiten todas las operaciones aritméticas sobre los valores de enumeración. Incluso es posible que una variable de enumeración contenga un entero que no represente ninguno de los valores de enumeración. De hecho, según la definición del lenguaje, el código anterior definirá Clubs, Diamonds, Hearts, y Spadescomo constantes de tipo int, que solo se convertirán (silenciosamente) a enum CardSuitsi se almacenan en una variable de ese tipo.

C también permite al programador elegir explícitamente los valores de las constantes de enumeración, incluso sin especificar el tipo. Por ejemplo,

enum CardSuit { CLUBS = 1 , DIAMONDS = 2 , HEARTS = 4 , SPADES = 8 , };

podría utilizarse para definir un tipo que permita representar conjuntos matemáticos de palos mediante enum CardSuitoperaciones lógicas bit a bit.

Desde C23 , el programador puede especificar el tipo subyacente de una enumeración, con la misma sintaxis que en C++. ^{[ 4 ]} Esto permite a los programadores crear enumeraciones optimizadas eligiendo un tipo subyacente menos costoso.

enum CardSuit : char { CLUBS = 1 , DIAMONDS = 2 , HEARTS = 4 , SPADES = 8 , };

En C, las enumeraciones no tienen ámbito ni están calificadas, porque C carece de características de espacios de nombres . Antes de la introducción de la constexprpalabra clave en C23, las enumeraciones se usaban a menudo para declarar constantes en tiempo de compilación sin usar el preprocesador de C.

Los tipos enumerados en el lenguaje de programación C# conservan la mayor parte de la semántica de "entero pequeño" de los enums de C. En C#, todos los enums son clases que extienden System.Enum. ^{[ 5 ]} Algunas operaciones aritméticas no están definidas para los enums, pero un valor de enum se puede convertir explícitamente a un entero y viceversa, y una variable de enum puede tener valores que no fueron declarados por la definición del enum. Por ejemplo, dado

enum CardSuit { Clubs , Diamonds , Spades , Hearts , }

Las expresiones CardSuit.Diamonds + 1y CardSuit.Hearts - CardSuit.Clubsestán permitidas directamente (porque puede tener sentido recorrer la secuencia de valores o preguntar cuántos pasos hay entre dos valores), pero CardSuit.Hearts * CardSuit.Spadesse considera que tiene menos sentido y solo está permitida si los valores se convierten primero a enteros.

C# también ofrece la característica, similar a la de C, de poder definir valores enteros específicos para enumeraciones. De esta forma, es posible realizar operaciones binarias sobre enumeraciones, tratando así los valores de enumeración como conjuntos de indicadores. Estos indicadores se pueden comprobar mediante operaciones binarias o con el HasFlag()método integrado del tipo enum. ^{[ 6 ]}

La definición de enumeración define nombres para los valores enteros seleccionados y es azúcar sintáctico , ya que es posible asignar a una variable de enumeración otros valores enteros que no están dentro del ámbito de la definición de enumeración. ^{[ 7 ] [ 8 ] [ 9 ]}

C++ tiene tipos de enumeración que se heredan directamente de los de C y funcionan de forma muy similar, excepto que una enumeración es un tipo real en C++, lo que proporciona comprobaciones adicionales en tiempo de compilación. Además (al igual que con las estructuras), la enumpalabra clave de C++ se combina con un typedef , de modo que en lugar de referirse al tipo como , se puede simplemente referirse a él como . Esto se puede simular en C usando un typedef:enumMyEnumMyEnumtypedefenum{VALUE_1,VALUE_2}MyEnum;

C++11 también proporciona un segundo tipo de enumeración, denominada enumeración con ámbito . Estas son seguras en cuanto a tipos: los enumeradores no se convierten implícitamente a un tipo entero. Entre otras cosas, esto permite definir la transmisión de E/S para el tipo de enumeración. Otra característica de las enumeraciones con ámbito es que los enumeradores deben estar calificados por el nombre de la enumeración, por lo que su uso requiere anteponer el nombre de la enumeración (por ejemplo, Color::REDpara el primer enumerador en el ejemplo siguiente), a menos que se haya utilizado una declaración (introducida en C++20 ) para incorporar los enumeradores al ámbito actual. Una enumeración con ámbito se especifica mediante la frase (o ). Por ejemplo:usingenumenumclassenumstruct

// Enumeración sin ámbito de estilo C enum CardSuit { CLUBS , DIAMONDS , SPADES , HEARTS , };// Enumeración con ámbito al estilo C++11 clase Color { ROJO , VERDE , AZUL , };int main ( int argc , char * argv []) { Color c = Color :: RED ;// Enumeración estilo C sin ámbito CardSuit card1 = Clubs ; // Puede ser sin ámbito CardSuit card2 = CardSuit :: SPADES ; // Normalmente se declara con ámbito }

El tipo subyacente de una enumeración es un tipo entero definido por la implementación que es lo suficientemente grande como para contener todos los valores enumerados; no tiene por qué ser el tipo más pequeño posible. El tipo subyacente se puede especificar directamente, lo que permite las "declaraciones anticipadas" de enumeraciones:

// debe ajustarse en tamaño y disposición de memoria al tipo enum 'long' clase Color : long { ROJO , VERDE , AZUL , };// Declaración anticipada. Si posteriormente se definen valores // que no caben en 'char', se produce un error. enum class Shapes : char ;

Go utiliza el iotaidentificador para crear constantes enumeradas. ^{[ 10 ] [ 11 ]}

tipo ByteSize intconst ( _ = iota // ignora el primer valor asignándolo a un identificador en blanco; 0 KB ByteSize = 1 << ( 10 * iota ) // 1 << (10 * 1) == 1 << 10 == 1024; en binario 10000000000 MB // 1 << (10 * 2) == 1048576; en binario 1000000000000000000000 GB // 1 << (10 * 3) == 1073741824; en binario 10000000000000000000000000000000 )

La versión 5.0 de J2SE del lenguaje de programación Java añadió tipos enumerados cuya sintaxis de declaración es similar a la de C :

enum CardSuit { Tréboles , Diamantes , Picas , Corazones , };Triunfo del palo de la carta ;

El sistema de tipos de Java, sin embargo, trata las enumeraciones como un tipo separado de los enteros, y no se permite la mezcla de valores enum e enteros. De hecho, un tipo enum en Java es en realidad una clase especial generada por el compilador en lugar de un tipo aritmético, y los valores enum se comportan como instancias pregeneradas globales de esa clase. Los tipos enum pueden tener métodos de instancia y un constructor (cuyos argumentos se pueden especificar por separado para cada valor enum). Todos los tipos enum extienden implícitamente la Enumclase abstracta, por lo que un enum no puede extender nada más. La clase java.lang.Enum<E>está restringida como Un tipo enum no se puede instanciar directamente. ^{[ 12 ]}Enum<EextendsEnum<E>>

Internamente, cada valor enum contiene un entero, correspondiente al orden en que se declaran en el código fuente, comenzando desde 0. El programador no puede establecer un entero personalizado para un valor enum directamente, pero se pueden definir constructores sobrecargados que luego pueden asignar valores arbitrarios a miembros autodefinidos de la clase enum. Definir getters permite entonces el acceso a esos miembros autodefinidos. El entero interno se puede obtener de un valor enum usando el ordinal()método, y la lista de valores enum de un tipo de enumeración se puede obtener en orden usando el values()método. Generalmente se desaconseja a los programadores convertir enums a enteros y viceversa. ^{[ 13 ]} Los tipos enumerados son java.lang.Comparable<T>, usando el entero interno; como resultado, se pueden ordenar.

La biblioteca estándar de Java proporciona clases de utilidad para trabajar con enumeraciones. La EnumSetclase implementa una lista java.util.Set<E>de valores de enumeración; se implementa como un array de bits , lo que la hace muy compacta y tan eficiente como la manipulación explícita de bits, pero más segura. La EnumMapclase implementa una lista java.util.Map<K, V>de valores de enumeración para un objeto. Se implementa como un array, donde el valor entero del valor de enumeración sirve como índice.

A diferencia de C++, las enumeraciones de Java pueden tener métodos, constructores y campos como cualquier otra clase.

public enum Planet { // Planeta, seguido de masa y radio MERCURIO ( 3.303e+23 , 2.4397e6 ), VENUS ( 4.869e+24 , 6.0518e6 ), TIERRA ( 5.976e+24 , 6.37814e6 ), MARTE ( 6.421e+23 , 3.3972e6 ), JÚPITER ( 1.9e+27 , 7.1492e7 ), SATURNO ( 5.688e+26 , 6.0268e7 ), URANO ( 8.686e+25 , 2.5559e7 ), NEPTUNO ( 1.024e+26 , 2.4746e7 );public static final double G = 6.67300E-11 ;masa doble final privada ; radio doble final privado ;Planeta ( doble masa , doble radio ) { esta.masa = masa ; este.radio = radio ; }​​​​private double mass () { return mass ; }private double radio () { return radio ; }double surfaceGravity () { return G * masa / ( radio * radio ); }double surfaceWeight ( double otherMass ) { return otherMass * surfaceGravity (); }public static void main ( String [] args ) { double earthWeight = Double . parseDouble ( args [ 0 ] ); double mass = earthWeight / EARTH . surfaceGravity (); for ( Planet p : Planet . values ​​()) { System . out . printf ( "Tu peso en %s es %f%n" , p , p . surfaceWeight ( mass ) ); } } }

Los lenguajes de tipado dinámico en la tradición sintáctica de C (por ejemplo, Perl o JavaScript ) no proporcionan, en general, enumeraciones. Pero en la programación en Perl se puede obtener el mismo resultado con las cadenas abreviadas listas y hashes (posiblemente slices ):

mi @enum = qw(Clubs Diamonds Hearts Spades) ; mi ( %set1 , %set2 ); @set1 { @enum } = (); # todo borrado @set2 { @enum } = ( 1 ) x @enum ; # todo establecido a 1 $set1 { Clubs } ... # falso $set2 { Diamonds } ... # verdadero

Raku (anteriormente conocido como Perl 6) admite enumeraciones. Existen varias formas de declarar enumeraciones en Raku, todas ellas creando un mapa en el backend.

enum Gato <sphynx siamés bengalí de pelo corto otro> ; # Usando "comillas"

enum Cat ( 'sphynx' , 'siamese' , 'bengal' , 'shorthair' , 'other' ); # Usando una lista

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

enum Cat (: sphynx ( 0 ), : siamese ( 1 ), : bengal ( 2 ), shorthair ( 3 ), : other ( 4 )); # Otra forma de usar Pairs, también puedes usar `:0sphynx`

Las enumeraciones se añadieron en la versión 8.1 de PHP.

enum CardSuit { case Corazones ; case Diamantes ; case Tréboles ; case Picas ; }

Los enumeradores pueden estar respaldados por valores de cadena o enteros para facilitar la serialización:

enum CardSuit : string { case Hearts = 'H' ; case Diamonds = 'D' ; case Clubs = 'C' ; case Spades = 'S' ; }

La interfaz de la enumeración expone un método que devuelve una colección de sus enumeradores y sus nombres. Las enumeraciones que utilizan cadenas o enteros como referencia también exponen el valor subyacente y los métodos para intentar la deserialización. Los usuarios pueden añadir métodos adicionales.

Aunque Rust utiliza la enumpalabra clave `enum` como C, la usa para describir uniones etiquetadas , de las cuales los enums pueden considerarse una forma degenerada. Por lo tanto, los enums de Rust son mucho más flexibles y pueden contener variantes de estructuras y tuplas.

enum Message { Quit , Move { x : i32 , y : i32 }, // struct Write ( String ), // tupla de un solo elemento ChangeColor ( i32 , i32 , i32 ), // tupla de tres elementos }

Al igual que C, Rust también admite la especificación de los valores de cada variante,

pub enum Weekday { Domingo = 1 , Lunes = 2 , Martes = 4 , Miércoles = 8 , Jueves = 16 , Viernes = 32 , Sábado = 64 , }

En C, las enumeraciones asignan nombres relacionados a un conjunto de valores enteros. En Swift , las enumeraciones son mucho más flexibles y no requieren un valor para cada caso. Si se proporciona un valor (denominado valor sin procesar ) para cada caso, este puede ser una cadena de caracteres, un carácter o un valor de cualquier tipo entero o de coma flotante.

Alternativamente, los casos de enumeración pueden especificar valores asociados de cualquier tipo que se almacenarán junto con cada valor de caso diferente, de forma similar a como lo hacen las uniones o variantes en otros lenguajes. Se puede definir un conjunto común de casos relacionados como parte de una enumeración, cada uno de los cuales tiene asociado un conjunto diferente de valores de tipos apropiados.

En Swift, las enumeraciones son un tipo de dato de primera clase. Adoptan muchas características que tradicionalmente solo admitían las clases, como las propiedades calculadas para proporcionar información adicional sobre el valor actual de la enumeración y los métodos de instancia para ofrecer funcionalidad relacionada con los valores que representa. Las enumeraciones también pueden definir inicializadores para proporcionar un valor inicial para cada caso y pueden extenderse para ampliar su funcionalidad más allá de su implementación original; además, pueden ajustarse a protocolos para ofrecer funcionalidad estándar.

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

A diferencia de C y Objective-C , en Swift los casos de enumeración no tienen un valor entero predeterminado al crearse. En el ejemplo CardSuit anterior, los palos de tréboles, diamantes, corazones y picas no equivalen implícitamente a 0, 1, 2 y 3. En cambio, los diferentes casos de enumeración son valores completos por derecho propio, con un tipo CardSuit definido explícitamente.

En una misma línea pueden aparecer varios casos, separados por comas:

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

Cuando se trabaja con enumeraciones que almacenan valores enteros o de cadena sin procesar, no es necesario asignar explícitamente un valor sin procesar para cada caso, ya que Swift asignará automáticamente los valores.

Por ejemplo, cuando se utilizan números enteros para valores sin procesar, el valor implícito para cada caso es uno más que el caso anterior. Si el primer caso no tiene un valor asignado, su valor es 0. Para el ejemplo CardSuit, los palos se pueden numerar comenzando desde 1 escribiendo:

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

TypeScript añade un tipo de datos 'enum' a JavaScript.

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

Por defecto, los enumeradores numeran sus miembros comenzando en 0; esto se puede anular estableciendo el valor del primero:

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

Todos los valores se pueden configurar:

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

TypeScript admite la asignación de un valor numérico a su nombre. Por ejemplo, esto encuentra el nombre del valor 2:

enum CardSuit { Clubs = 1 , Diamonds , Hearts , Spades };var suitName : string = CardSuit [ 2 ];alerta ( trajeName );

enumEn la versión 3.4 se añadió un módulo a la biblioteca estándar de Python. Este módulo introduce una clase Enumque se puede extender para definir tipos enumerados.

from enum import Enumclase CardSuit ( Enum ): Tréboles : int = 1 Diamantes : int = 2 Corazones : int = 3 Picas : int = 4

También existe una API funcional para crear enumeraciones con índices generados automáticamente (que comienzan con uno):

Cartas : Enumeración = Enumeración ( "Cartas" , "Tréboles, Diamantes, Corazones, Picas" )

Las enumeraciones de Python no imponen la corrección semántica (una comparación sin sentido con una enumeración incompatible siempre devuelve False en lugar de generar un TypeError ):

Color : Enum = Enum ( "Color" , "ROJO VERDE AZUL" ) Forma : Enum = Enum ( "Forma" , [ "CÍRCULO" , "TRIÁNGULO" , "CUADRADO" , "HEXÁGONO"] )def has_vertices ( shape : Enum ) -> bool : return shape != Shape . CIRCLEif __name__ == "__main__" : has_vertices ( Color . GREEN ) # muestra "True"

Dart admite la forma más básica de enumeraciones y tiene una sintaxis similar a la de otros lenguajes que admiten enumeraciones.

enumeración CardSuit {Clubes ,Diamantes ,Corazones ,Espadas}void main () {CardPalo carta = CardPalo.Tréboles ;​​// Dart utiliza el operador "switch" para hacer coincidir el valor de una enumeración con la salida deseada.interruptor ( tarjeta ) {Caso CardPalo.Tréboles : {​imprimir ( "Clubes" );}romper ;Caso CardSuit . Diamantes: {imprimir ( "Diamantes" );}romper ;Caso CardPalo . Corazones: {imprimir ( "Corazones" );}romper ;Caso CardPalo . Picas: {imprimir ( "Picas" );}romper ;por defecto : {imprimir ( "Desconocido" );}romper ;}}

Tenga en cuenta que antes de Dart 3, ^{[ 14 ]} el operador switch no garantizaba la completitud de los casos. Esto significa que si omite un caso, el compilador no generará un error.

En COBOL, una variable de condición es una variable normal con campos subordinados de nivel 88, conocidos como nombres de condición. Cada nombre de condición debe tener una cláusula VALUE. La cláusula VALUE de una condición puede especificar un único valor o una lista de valores.

Fortran 2003 introdujo enumeradores para la interoperabilidad con C; por lo tanto, la semántica es similar a la de C y, como en C, los valores de enumeración son simplemente enteros y no se realiza ninguna comprobación de tipo adicional. El ejemplo de C anterior se puede escribir en Fortran como

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

Fortran 2023 introdujo un verdadero tipo de enumeración. Los valores se ordenan secuencialmente según lo especificado. Las funciones intrínsecas intadmiten hugeenumeraciones. Las funciones nexty previoustambién están disponibles.

enumeration type :: days_of_week enumerador :: monday , tuesday , wednesday , thursday , friday enumerador :: saturday , sunday end enumeration typetipo ( días_de_la_semana ) :: dow : si ( dow == miércoles ) entonces  imprimir * , 'día de mitad de semana' fin si : seleccionar caso ( dow ) caso ( lunes : viernes ) imprimir * , 'día de semana' caso ( sábado , domingo ) imprimir * , 'fin de semana' fin seleccionar

Common Lisp utiliza el especificador de tipo de miembro, por ejemplo,

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

que indica que el objeto es de tipo cardsuit si es #'eqlde club, diamante, corazón o pica. Sin embargo, el especificador de tipo de miembro no es válido como un especializador de parámetros del Common Lisp Object System(eql atom) (CLOS). En su lugar, se puede usar , que es el equivalente a (member atom)(es decir, solo se puede especificar un miembro del conjunto con un especificador de tipo eql, sin embargo, se puede usar como un especializador de parámetros CLOS). En otras palabras, para definir métodos que cubran un tipo enumerado, se debe definir un método para cada elemento específico de ese tipo.

Además,

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

puede utilizarse para definir tipos enumerados arbitrarios en tiempo de ejecución. Por ejemplo

( conjunto de elementos finitos tipo club diamante corazón pica )

se referiría a un tipo equivalente a la definición anterior de palo de cartas, como por supuesto simplemente habría estado usando

( club de miembros diamante corazón pica )

pero puede resultar menos confuso con la función #'memberpor razones estilísticas.