Thread: 
AssinarIndexação ( [] )
Ao endereçar o i-ésimo elemento de um array, o valor da expressão é o valor da variável com o número serial i.
Exemplo:
array[i] = 3; // Atribui o valor de 3 ao i-ésimo elemento do array.
Somente um inteiro pode ser índice de um array. São permitidos arrays com 4 dimensões ou menos. Cada medida é indexada de 0 ao tamanho da medida - 1. Em particular, para um array de uma dimensão consistindo de 50 elementos, a referência ao primeiro elemento se assemelhará a array[0], e a referência ao último elemento será array[49].
Ao endereçar além do array, o subsistema em execução gerará um erro crítico, e o programa será interrompido.
Chamando Função com argumentos x1, x2 ,..., xn
Cada argumento pode representar uma constante, variável, ou expressão do correspondente tipo. Os argumentos passados são separados por vírgula e devem estar dentro dos parênteses, o parêntese de abertura deve seguir o nome da função chamada.
O valor da expressão é o valor retornado pela função. Se o valor retornado é do do tipo void, a chamada da função não pode ser colocada a direita de um operador de atribuição. Repare que a ordem de execução x1, ..., xn é garantida.
Exemplo:
int length=1000000;
string a="a",b="b",c;
//--- Outras Operações
int start=GetTickCount(),stop;
long i;
for(i=0;i<length;i++)
{
c=a+b;
}
stop=GetTickCount();
Print("tempo para 'c = a + b' = ",(stop-start)," milissegundos, i = ",i);
Operação Vírgula ( , )
Expressões separadas por vírgulas são executadas da esquerda para direita. Todos os efeitos colaterais do cálculo da expressão a esquerda podem aparecer antes da expressão a direita ser calculada. O tipo do resultado e o valor coincidem com aqueles da expressão a direita. A lista de parâmetros a ser passada (seja acima) pode ser considerada como um exemplo.
Exemplo:
for(i=0,j=99; i<100; i++,j--) Print(array[i][j]);
Operador Ponto ( . )
Para o acesso direto a membros públicos de estruturas e classes, a operação ponto é usada. Sintaxe:
Nome_da_variável_do_tipo_estrutura.Nome_do_membro
Exemplo:
struct SessionTime
{
string sessionName;
int startHour;
int startMinutes;
int endHour;
int endMinutes;
} st;
st.sessionName="Asian";
st.startHour=0;
st.startMinutes=0;
st.endHour=9;
st.endMinutes=0;
Operação de Resolução de Escopo ( :: )
Cada função em um programa MQL5 tem seu próprio escopo de execução. Por exemplo, a função de sistema Print() é realizada em um escopo global. Funções Importadas são chamadas no escopo do correspondente import. Métodos de funções de classes têm o escopo da correspondente classe. A sintaxe do operador de resolução de escopo é o seguinte:
[Scope_name]::Function_name(parameters)
Se não existir nenhum nome de escopo, isto é uma orientação explícita para usar o escopo global. Se não existir nenhuma operação de resolução de escopo, a função é procurada no escopo mais próximo. Se não existir nenhuma função no escopo local, a procura é conduzida no escopo global.
A resolução de escopo é também usada para definir funções membros de classe.
type Class_name::Function_name(parameters_description)
{
// corpo da função
}
O uso de várias funções do mesmo nome a partir de contextos de execução diferentes em um programa pode causar ambigüidade. A ordem de prioridade das chamadas da função sem especificação de escopo explícita é a seguinte:
Métodos de classe. Se nenhuma função com o nome especificado for definida na classe, mova para o próximo nível.
Funções do MQL5. Se o idioma não tiver essa função, vá para o próximo nível.
Funções globais definidas pelo usuário. Se nenhuma função com o nome especificado for encontrada, mova para o próximo nível.
Funções importadas. Se nenhuma função com o nome especificado for encontrada, o compilador retornará um erro.
Para evitar a ambigüidade de chamadas de função, sempre explicitamente especificar o escopo de função usando a operação de resolução de escopo.
Exemplo:
#property script_show_inputs
#import "kernel32.dll"
int GetLastError(void);
#import
class CCheckContext
{
int m_id;
public:
CCheckContext() { m_id=1234; }
protected:
int GetLastError() { return(m_id); }
};
class CCheckContext2 : public CCheckContext
{
int m_id2;
public:
CCheckContext2() { m_id2=5678; }
void Print();
protected:
int GetLastError() { return(m_id2); }
};
void CCheckContext2::Print()
{
::Print("Terminal GetLastError",::GetLastError());
::Print("kernel32 GetLastError",kernel32::GetLastError());
::Print("parent GetLastError",CCheckContext::GetLastError());
::Print("our GetLastError",GetLastError());
}
//+------------------------------------------------------------------+
//| Programa Script da função start (iniciar) |
//+------------------------------------------------------------------+
void OnStart()
{
//---
CCheckContext2 test;
test.Print();
}
//+------------------------------------------------------------------+
Operação de Obtenção do Tamanho do Tipo de Dados ou Tamanho do Objeto de Qualquer Tipo de Dados ( sizeof )
Usando a operação sizeof o tamanho de memória correspondente a um identificador ou tipo pode ser definido. A operação sizeof é do seguinte formato:
Exemplo:
sizeof(expression)
Qualquer identificador, ou nome de tipo entre colchetes pode ser usado como uma expressão. Observe que o nome tipo void não pode ser usado, e o identificar não pode pertencer ao campo de bits, ou ser um nome de função.
Se a expressão for o nome de um array estático (isto é, a primeira dimensão é dada), então o resultado é o tamanho do array inteiro (isto é, o produto do número de elementos e o comprimento do tipo. Se a expressão é o nome de um array dinâmico (a primeira dimensão não é especificada), o resultado será o tamanho do objeto do array dinâmico.
Quando sizeof é aplicado ao nome de um tipo de estrutura ou classe, ou ao identificador do tipo de uma estrutura ou classe, o resultado é tamanho real da estrutura ou classe.
Exemplo:
struct myStruct
{
char h;
int b;
double f;
} str;
Print("sizeof(str) = ",sizeof(str));
Print("sizeof(myStruct) = ",sizeof(myStruct));
O tamanho é calculado na etapa de compilação.
