Referência MQL5Elementos Básicos da LinguagemVariáveis

Variáveis

Declarando Variáveis

Variáveis devem ser declaradas antes de serem usadas. Nomes únicos são usados para identificar variáveis. Para declarar uma variável, você deve especificar o seu tipo e nome único. Declaração de variável não é um operador.

Os tipos simples são:

char, short, int, long, uchar, ushort, uint, ulong — inteiros;

color — inteiro representando a cor-RGB (red, green, blue);
datetime — a data e hora, um inteiro sem sinal (unsigned) contendo o número de segundos desde a 0 hora de 1 de Janeiro de 1970;

bool — valores booleanos true e false;
double — número de ponto flutuante de dupla precisão;
float — número de ponto flutuante de precisão simples;
string — cadeias de caracteres.

Exemplos:

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 compostos ou complexos:

Estruturas são tipos de dados compostos construídas usando outros tipos.

struct MyTime
  {
   int hour;    // 0-23
   int minute;  // 0-59
   int second;  // 0-59
  };
...
MyTime strTime; // Variável previamente declarada da estrutura MyTime

Não se pode declarar variáveis do tipo estrutura até que se declare a estrutura.

Arrays

Array (ou matriz) é uma seqüência indexada de dados de tipos idênticos:

int    a[50];       // Array de uma dimensão de 50 inteiros.
double m[7][50];    // Array de duas dimensões de sete arrays,
                    // cada um deles constituído de 50 números.
MyTime t[100];      // Array contendo elementos como MyTime

Somente um inteiro pode ser um índice de array. Não são permitidos arrays com mais que quatro dimensões. A numeração de elementos de um array começa com 0. O último elemento de um array de uma dimensão tem o número do índice que é 1 a menos que o tamanho do array. Isso significa que chamar pelo último elemento de um array constituído de 50 aparecerá como a[49]. O mesmo acontece a arrays multidimensionais: uma dimensão é indexada de 0 ao tamanho da dimensão menos 1. O último elemento de um array de duas dimensões aparecerá como m[6][49].

Arrays estáticos não podem ser representados como séries de tempo, isto é, a funçãoArraySetAsSeries() não pode ser aplicada a eles, esta função define o acesso aos elementos de um array do fim para o começo. Se você desejar ter acesso a um array da mesma forma que uma série de tempo, use o objeto de array dinâmico.

Se houver uma tentativa de acesso fora da faixa do array, a execução do subsistema gerará um erro crítico e o programa será interrompido.

Métodos embutidos para trabalhar usando arrays #

Para trabalhar com arrays, você pode usar as funções da seção Operações de arrays, bem como métodos embutidos:

Método	Análogo	Descrição
void array.Fill(const scalar value, const int start_pos=0, const int count=-1);	ArrayFill, ArrayInitialize	Preenche o array com o valor especificado
void array.Free();	ArrayFree	Libera o buffer dinâmico do array e define o tamanho da dimensão zero como 0 (zero)
int array.Resize(const int range0_size, const int reserve); int array.Resize(const int range_sizes[], const int reserve);	ArrayResize	Estabelece um novo tamanho na primeira dimensão do array
int array.Print();	ArrayPrint	Imprime os valores de um array de tipo simples no log
int array.Size(const int range=-1);	ArraySize, ArrayRange	Retorna o número de elementos em todo o array (range=-1) ou na dimensão especificada do array
bool array.IsDynamic();	ArrayIsDynamic	Verifica se o array é dinâmico
bool array.IsIndicatorBuffer();		Verifica se o array é um buffer indicador
bool array.IsSeries();	ArrayIsSeries	Verifica se o array é uma série temporal
bool array.AsSeries();	ArrayGetAsSeries	Verifica a direção de indexação do array
bool array.AsSeries(const bool as_series);	ArraySetAsSeries	Define a direção da indexação no array
int array.Copy(const src_array[], const int dst_start, const int src_start, const int cnt);	ArrayCopy	Copia os valores de um array em outro array
int array.Compare(const src_array[], const int dst_start, const int src_start, const int cnt);	ArrayCompare	Retorna o resultado de uma comparação de dois arrays de tipos simples ou de estruturas personalizadas
int array.Insert(const src_array[], const int dst_start, const int src_start, const int cnt);	ArrayInsert	Insere na matriz de destino o número especificado de elementos da matriz de origem, iniciando no índice especificado
int array.Remove(const int start_pos, const int count);	ArrayRemove	Elimina o número especificado de elementos do array a partir do índice especificado
int array.Reverse(const int start_pos, const int count);	ArrayReverse	Desdobra o número especificado de elementos do array, começando pelo índice especificado
bool array.Swap(array& arr[]);	ArraySwap	Troca de conteúdo com outro array dinâmico do mesmo tipo
void array.Sort(sort_function);	ArraySort	Classificação de arrays numéricos por primeira dimensão
int array.Search(scalar value, search_function);	ArrayBsearch	Retorna o índice do primeiro elemento encontrado na primeira dimensão do array
int array.Find((scalar value, search_function);		Procura o array usando a função passada e retorna o índice do primeiro elemento encontrado
array array.Select(scalar value, search_function);		Procura o array usando a função passada e retorna o array com todos os elementos encontrados

Especificadores de Acesso

Especificadores de acesso definem como o compilador pode acessar variáveis, membros de estruturas ou classes.

O especificador const declara uma variável como uma constante e não permite modificar esta variável durante o tempo de execução. Uma inicialização simples de uma variável é permitida durante sua declaração.

Exemplo:

int OnCalculate (const int rates_total,      // tamanho do array price[]
                 const int prev_calculated,  // barras tratadas na chamada anterior
                 const int begin,            // a partir de onde começam os dados significativos
                 const double& price[]       // array a ser calculado
   );

Para acessar membros de estruturas e classes use os seguintes qualificadores:

public — permite acesso irrestrito às variáveis ou métodos da classe
protected — permite acesso a partir dos métodos desta classe, bem como a partir dos métodos de classes publicamente herdadas. Outro acesso é impossível;
private — permite acesso às variáveis e métodos da classe somente a partir dos métodos da mesma classe.
virtual — aplica-se apenas a métodos de classe (não a métodos de estrutura) e diz ao compilador que este método deve se colocado na tabela de funções virtuais da classe.

Classes de Armazenamento

Existem três classes de armazenamento: static, input e extern. Estes modificadores de classe de armazenamento explicitamente indicam ao compilador que as variáveis correspondentes estão distribuídas em uma área pré-alocada de memória, que é chamada de global pool. Além disso, estes modificadores indicam um processamento especial dos dados da variável. Se uma variável declarada em nível local não for uma variável estática, a memória para tal variável é alocada automaticamente em uma pilha de programa. A liberação de memória alocada para um array não estático (non-static) é também realizada automaticamente quando se passa além da área de visibilidade do bloco em que o array está declarado.

Veja também

Tipos de Dados, Encapsulamento e Extensibilidade de Tipos,Inicialização de Variáveis, Visibilidade Escopo e Tempo de Vida de Variáveis, Criação e Exclusão de Objetos, Membros Estáticos de uma Classe

Funções de Manipulação de Evento

Variáveis Locais