Manual de referencia de MQL5Bases del lenguajeVariables

Variables

Declaración de variables

Las variables tienen que estar declaradas antes de empezar a usarlas. Para identificar las variables se utilizan los nombres únicos. Las descripciones de variables se utilizan para su determinación y declaración de tipos. Las descripciones no son unos operadores.

Los tipos simples son:

char, short, int, long, uchar, ushort, uint, ulong — números enteros;

color — número entero que representa el color RGB;
datetime — fecha y hora es un número sin signo que contiene la cantidad de segundos pasados desde 0 horas del 1 de enero de 1970;

bool — valores lógicos true y false;
double — números de doble precisión en punto flotante;
float — números de precisión sencilla en punto flotante;
string — cadenas de caracteres.

Ejemplos:

string szInfoBox;
int    nOrders;
double dSymbolPrice;
bool   bLog;
datetime tBegin_Data   = D'2004.01.01 00:00';
color    cModify_Color = C'0x44,0xB9,0xE6';

Tipos complejos o compuestos:

Las estructuras son unos tipos de datos compuestos que se construyen con la ayuda de otros tipos.

struct MyTime
  {
   int hour;    // 0-23
   int minute;  // 0-59
   int second;  // 0-59
  };
...
MyTime strTime; // variable del tipo de la estructura MyTime declarada anteriormente

No se puede declarar las variables del tipo de estructuras hasta que la estructura esté declarada.

Arrays

El array es un conjunto indexado de datos del mismo tipo:

int    a[50];       // Array unidimensional de 50 números enteros.
double m[7][50];    // Array bidimensional compuesto por siete arrays,
                    // cada uno de los cuales contiene 50 números.
MyTime t[100];      // array que contiene elementos del tipo MyTime

Sólo un número entero puede ser el índice del array. Se admiten los arrays que no tienen más de cuatro dimensiones. La numeración de los elementos de un array se empieza con 0. El último elemento del array unidimensional tiene el número a 1 menos que el tamaño del array, es decir, la llamada al último elemento del array de 50 números enteros se verá de la siguiente manera a[49]. Lo mismo se puede decir de los arrays multidimensionales, la indexación de una dimensión se realiza de 0 al tamaño de dimensión -1. El último elemento del array bidimensional del ejemplo aparece como m[6][49].

Los arrays estáticos no pueden ser representados como series temporales, es decir, no se les puede aplicar la función ArraySetAsSeries(), que establece el acceso a los elementos del array desde el fin del array a su principio. Si es necesario establecer el acceso al array como en series temporales, hay que usar el objeto del array dinámico.

Al acceder fuera de los límites del array, el subsistema ejecutivo generará un error crítico y la ejecución del programa se detendrá.

Métodos incorporados para trabajar con arrays #

Para trabajar con arrays, podemos utilizar las funciones del apartado Operaciones con arrays, así como los métodos incorporados:

Método	Análogo	Descripción
void array.Fill(const scalar value, const int start_pos=0, const int count=-1);	ArrayFill, ArrayInitialize	Rellena un array con el valor indicado
void array.Free();	ArrayFree	Libera el búfer de un array dinámico y establece el tamaño de la dimensión cero como 0 (cero)
int array.Resize(const int range0_size, const int reserve); int array.Resize(const int range_sizes[], const int reserve);	ArrayResize	Establece un nuevo tamaño en la primera dimensión de un array
int array.Print();	ArrayPrint	Muestra en el diario el valor de un array de tipo simple
int array.Size(const int range=-1);	ArraySize, ArrayRange	Retorna el número de elementos en el array completo (rango=-1) o en la dimensión de array especificada
bool array.IsDynamic();	ArrayIsDynamic	Comprueba si un array es dinámico
bool array.IsIndicatorBuffer();		Comprueba si un array es búfer de indicador
bool array.IsSeries();	ArrayIsSeries	Comprueba si un array es una serie temporal
bool array.AsSeries();	ArrayGetAsSeries	Comprueba la dirección de indexación de un array
bool array.AsSeries(const bool as_series);	ArraySetAsSeries	Establece la dirección de indexación en un array
int array.Copy(const src_array[], const int dst_start, const int src_start, const int cnt);	ArrayCopy	Copia el valor de un array en otro array
int array.Compare(const src_array[], const int dst_start, const int src_start, const int cnt);	ArrayCompare	Retorna el resultado de la comparación de dos arrays de tipos simples o dos estructuras de usuario
int array.Insert(const src_array[], const int dst_start, const int src_start, const int cnt);	ArrayInsert	Inserta en la matriz-receptor el número indicado de elementos, comenzando por el índice establecido
int array.Remove(const int start_pos, const int count);	ArrayRemove	Elimina de un array el número indicado de elementos comenzando por el índice especificado
int array.Reverse(const int start_pos, const int count);	ArrayReverse	Expande el número especificado de elementos en el array, comenzando por el índice especificado
bool array.Swap(array& arr[]);	ArraySwap	Intercambia contenido con otro array dinámico del mismo tipo
void array.Sort(sort_function);	ArraySort	Clasificación de arrays numéricos según la primera dimensión
int array.Search(scalar value, search_function);	ArrayBsearch	Retorna el índice del primer elemento encontrado en la primera dimensión de un array
int array.Find((scalar value, search_function);		Busca un array usando la función transmitida y retorna el índice del primer elemento encontrado.
array array.Select(scalar value, search_function);		Busca un array usando la función transmitida y retorna un array con todos los elementos encontrados

Especificadores de acceso

Los especificadores de acceso indican al compilador cómo se puede realizar el acceso a las variables, elementos de las estructuras o de las clases.

El especificador const declara una variable como una constante y no permite cambiar el valor de esta variable durante el proceso de ejecución del programa. La inicialización de la variable durante su declaración se permite sólo una vez.

Ejemplo

int OnCalculate (const int rates_total,      // tamaño del array price[]
                 const int prev_calculated,  // barras procesadas durante la llamada anterior
                 const int begin,            // de donde se empiezan los datos significativos
                 const double& price[]       // array para el cálculo
   );

Para acceder a los elementos de las estructuras y clases se utilizan los siguientes especificadores:

public — no limita el acceso con nada a la variable o al método de clase;
protected — permite el acceso desde los métodos de la misma clase, y también desde los métodos de las clases que se heredan abiertamente. Otro acceso es imposible;
private — permite el acceso a las variables y métodos de clase únicamente desde los métodos de la misma clase.
virtual — es aplicable sólo a los métodos de clase (en ningún caso a los métodos de estructuras), y comunica al compilador que este método tiene que ser colocado en la tabla de las funciones virtuales de la clase.

Clases de memoria

Existen tres clases de memoria: static, input y extern. Estos modificadores de la clase de memoria indican al compilador de una manera explícita que las variables correspondientes se distribuyen en la zona de memoria predeterminada que se llama el pool global. Además, estos modificadores indican un procesamiento específico de los datos de variables.

Si una variable declarada a nivel local no es estática, entonces la distribución de la memoria para esta variable se realiza de una manera automática en la pila (stack) de programa. La liberación de memoria destinada para un array no estático también se realiza de forma automática cuando se sale fuera de los límites de visibilidad del bloque, en el cual este array ha sido declarado.

Véase también

Tipos de datos, Encapsulación y extensión de tipos, Inicialización de variables, Visibilidad y tiempo de vida de variables, Creación y eliminación de objetos, Miembros estáticos de la clase

Funciones de procesamiento de eventos

Variables locales