Enumeraciones personalizadas

Las enumeraciones personalizadas se basan estructuralmente en el tipo int y los principios de su uso coinciden completamente con lo que se ha comentado en la sección anterior en la que se abordaron las enumeraciones integradas. Por lo tanto, aquí vamos a describir las enumeraciones personalizadas, si bien, estrictamente hablando, no están integradas.

Ud. habrá de utilizar la palabra clave enum para describir su propia enumeración en el código MQL5. La forma de descripción más sencilla es la siguiente:

enum name
{
  element1,
  element2,
  element3
};

Esta descripción registra en el programa un tipo de enumeración denominado name con elementos encerrados entre llaves y separados por comas (su cantidad sólo está limitada por el valor más alto de int, lo que puede considerarse una ausencia de limitaciones en términos de tareas prácticas). Los identificadores element1, element2 y element3 pueden utilizarse en el programa dentro del contexto en el que se han definido: globalmente (es decir, fuera de todas las funciones) o dentro de una función (véase la sección Contexto, visibilidad y vida útil de las variables).

Fíjese en el punto y coma que sigue a la llave de cierre: es necesario porque la descripción de la enumeración es una sentencia separada, y después de cualquier sentencia de MQL5 debe escribirse punto y coma.

De manera predeterminada, los identificadores toman valores constantes, empezando por 0, y cada valor subsiguiente es 1 mayor que el anterior. Si es necesario, el programador puede definir un valor específico para cada elemento, después de '=' a la derecha del identificador. Por ejemplo, la entrada anterior es equivalente a esta otra:

enum name
{
  element1 = 0,
  element2 = 1,
  element3 = 2
};

Está permitido especificar como valor sólo constantes o expresiones que el compilador pueda calcular en la fase de compilación (para más detalles, consulte el ejemplo siguiente).

Si los valores no están definidos para todos los elementos, los valores omitidos se calculan automáticamente basándose en los más cercanos conocidos (precedentes) mediante la adición de 1. Por ejemplo:

enum name
{
  element1 = 1,
  element2,
  element3 = 10,
  element4,
  element5
};

Aquí, los dos primeros elementos toman los valores 1 y 2 (calculados), mientras que los que empiezan por el tercero toman 10 (especificado explícitamente), 11 y 12 (los dos últimos se calculan a partir de 10).

En el script TypeUserEnum.mq5 hay algunos ejemplos de descripción de enumeraciones personalizadas.

const int zero = 0; // runtime value is not known at compile time

enum
{
  MILLION = 1000000
};

enum RISK
{
  // OFF      = zero, // error: constant expression required
  LOW      = -1,
  MODERATE = -2,
  HIGH     = -3,
};

enum INCOME
{
  LOW      = 1,
  MODERATE = 2,
  HIGH     = 3,
  ENORMOUS = MILLION,
};

void OnStart()
{
  enum INTERNAL
  {
    ON,
    OFF,
  };

  // int x = LOW; // ambiguous access, can be one of
  int x = RISK::LOW;
  int y = INCOME::LOW;
}

La enumeración INTERNAL muestra la posibilidad de describirla dentro de la función y, al hacerlo, limita la región de visibilidad o disponibilidad de este tipo, lo que resulta útil en términos de conflictos entre nombres.

La enumeración RISK muestra que pueden asignarse elementos con valores negativos. El elemento comentado OFF no puede describirse debido al intento de inicializarlo con una expresión no constante: en este caso se especifica la variable zero, cuyo valor no puede ser calculado por el compilador.

En la enumeración INCOME, el valor del elemento MILLION de la otra enumeración definida más arriba inicializa correctamente el elemento ENORMOUS. Las enumeraciones se crean en el momento de la compilación y, por lo tanto, están disponibles en las expresiones de inicialización.

La enumeración con MILLION no tiene nombre; tales enumeraciones se denominan anónimas y su aplicación básica es declarar constantes. Sin embargo, las enumeraciones con nombre se utilizan más a menudo para las constantes, ya que permiten agrupar los elementos por su significado.

Dado que en el ejemplo hay definidas 2 enumeraciones, ambas con elementos de idéntico nombre, especificar el identificador LOW al declarar la variable x da lugar al error de compilación «acceso ambiguo», ya que no queda claro a qué elemento de qué enumeración se refiere. Tenga en cuenta que los identificadores pueden tener (y tienen, en este caso) valores diferentes.

Para resolver este problema existe un operador de contexto especial: Dos dos puntos, '::'. Este operador ayuda a formar el identificador completo del elemento del lenguaje, es decir, el elemento de enumeración, en nuestro caso: en primer lugar se especifica el nombre de la enumeración; a continuación, el operador '::', y después, el identificador del elemento. Ejemplo: RISK::LOW e INCOME::LOW. Descubriremos todos los operadores en la sección correspondiente.

Enumeraciones

Tipo void