Programación D - Enums

Se utiliza una enumeración para definir valores constantes con nombre. Un tipo enumerado se declara utilizando elenum palabra clave.

La sintaxis de enum

La forma más simple de una definición de enumeración es la siguiente:

enum enum_name {  
   enumeration list 
}

Dónde,

• El enum_name especifica el nombre del tipo de enumeración.

• La lista de enumeración es una lista de identificadores separados por comas.

Cada uno de los símbolos de la lista de enumeración representa un valor entero, uno mayor que el símbolo que lo precede. De forma predeterminada, el valor del primer símbolo de enumeración es 0. Por ejemplo:

enum Days { sun, mon, tue, wed, thu, fri, sat };

Ejemplo

El siguiente ejemplo demuestra el uso de la variable enum:

import std.stdio;

enum Days { sun, mon, tue, wed, thu, fri, sat };

int main(string[] args) {
   Days day;

   day = Days.mon;
   writefln("Current Day: %d", day); 
   writefln("Friday : %d", Days.fri); 
   return 0;
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Current Day: 1 
Friday : 5

En el programa anterior, podemos ver cómo se puede usar una enumeración. Inicialmente, creamos una variable llamada día de nuestros días de enumeración definidos por el usuario. Luego lo configuramos en mon usando el operador de punto. Necesitamos usar el método writefln para imprimir el valor de mon que se ha almacenado. También necesita especificar el tipo. Es del tipo integer, por lo que usamos% d para imprimir.

Propiedades de enumeraciones con nombre

El ejemplo anterior usa un nombre Días para la enumeración y se denomina enumeraciones con nombre. Estas enumeraciones con nombre tienen las siguientes propiedades:

• Init - Inicializa el primer valor de la enumeración.

• min - Devuelve el valor más pequeño de enumeración.

• max - Devuelve el mayor valor de enumeración.

• sizeof - Devuelve el tamaño de almacenamiento para enumeración.

Modifiquemos el ejemplo anterior para hacer uso de las propiedades.

import std.stdio;

// Initialized sun with value 1 
enum Days { sun = 1, mon, tue, wed, thu, fri, sat };

int main(string[] args) { 
   writefln("Min : %d", Days.min); 
   writefln("Max : %d", Days.max);
   writefln("Size of: %d", Days.sizeof); 
   return 0; 
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Min : 1
Max : 7
Size of: 4

Enum anónimo

La enumeración sin nombre se llama enumeración anónima. Un ejemplo paraanonymous enum se da a continuación.

import std.stdio; 
 
// Initialized sun with value 1 
enum { sun , mon, tue, wed, thu, fri, sat }; 
 
int main(string[] args) { 
   writefln("Sunday : %d", sun); 
   writefln("Monday : %d", mon); 
   return 0; 
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Sunday : 0
Monday : 1

Las enumeraciones anónimas funcionan de la misma manera que las enumeraciones con nombre, pero no tienen las propiedades max, min y sizeof.

Enum con sintaxis de tipo base

La sintaxis para la enumeración con tipo base se muestra a continuación.

enum :baseType {  
   enumeration list 
}

Algunos de los tipos básicos incluyen long, int y string. A continuación se muestra un ejemplo de uso de long.

import std.stdio;
  
enum : string { 
   A = "hello", 
   B = "world", 
} 
  
int main(string[] args) { 
   writefln("A : %s", A); 
   writefln("B : %s", B); 
   
   return 0; 
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

A : hello
B : world

Más características

La enumeración en D proporciona características como la inicialización de múltiples valores en una enumeración con múltiples tipos. A continuación se muestra un ejemplo.

import std.stdio;
  
enum { 
   A = 1.2f,  // A is 1.2f of type float 
   B,         // B is 2.2f of type float 
   int C = 3, // C is 3 of type int 
   D          // D is 4 of type int 
}
  
int main(string[] args) { 
   writefln("A : %f", A); 
   writefln("B : %f", B); 
   writefln("C : %d", C); 
   writefln("D : %d", D);  
   return 0; 
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

A : 1.200000
B : 2.200000
C : 3
D : 4