Métodos Estáticos

[jssuser]

Em MQL5, funções membro do tipo estático podem ser usadas. O modificador static deve preceder o tipo do retorno de uma função na declaração dentro de uma classe.

class CStack
{
public:
//--- Construtor e destrutor
CStack(void){};
~CStack(void){};
//--- Capacidade mбxima da pilha
static int Capacity();
private:
int m_length; // O nъmero de elementos na pilha
static const int s_max_length; // Capacidade mбxima da pilha
};
//+------------------------------------------------------------------+
//| Retorna o nъmero mбximo de elementos armazenados na pilha |
//+------------------------------------------------------------------+
int CStack::Capacity(void)
{
return(s_max_length);
}
//--- Inicializaзгo da constante estбtica da classe CStack
const int CStack::s_max_length=1000;
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
//--- declare CStack type variable
CStack stack;
//--- call the object's static method
Print("CStack.s_max_length=",stack.Capacity());
//--- it can also be called the following way, as the method is static and does not require the presence of the object
Print("CStack.s_max_length=",CStack::Capacity());
}

Um método com o modificador const é chamado de constante e não pode alterar membros implícitos de sua classe. A declaração de funções constantes de uma classe e parâmetros constantes é chamado de controle const-correção. Através deste controle pode-se assegurar que o compilador garantirá a consistência de valores de objetos e retornará um erro durante a compilação se existir algo errado.

O modificador const é colocado após a lista de argumentos dentro de uma declaração de classe. A definição do lado de fora de uma classe deve também incluir o modificador const:

//+------------------------------------------------------------------+
//| Class "Retângulo" |
//+------------------------------------------------------------------+
class CRectangle
{
private:
double m_width; // Largura
double m_height; // Altura
public:
//--- Construtor e destrutor
CRectangle(void):m_width(0),m_height(0){};
CRectangle(const double w,const double h):m_width(w),m_height(h){};
~CRectangle(void){};
//--- Calculando a área
double Square(void) const;
static double Square(const double w,const double h);// { return(w*h); }
};
//+------------------------------------------------------------------+
//| Retorna a área do objeto "Retângulo" |
//+------------------------------------------------------------------+
double CRectangle::Square(void) const
{
return(Square(m_width,m_height));
}
//+------------------------------------------------------------------+
//| Retorna o produto de duas variáveis |
//+------------------------------------------------------------------+
static double CRectangle::Square(const double w,const double h)
{
return(w*h);
}
//+------------------------------------------------------------------+
//| Programa Script da função start (iniciar) |
//+------------------------------------------------------------------+
void OnStart()
{
//--- Criar um retângulo reto com os lados iguais a 5 e 6
CRectangle rect(5,6);
//--- Procurar a área do retângulo usando um método constante
PrintFormat("rect.Square()=%.2f",rect.Square());
//--- Procurar o produto de números usando o método estático da classe CRectangle
PrintFormat("CRectangle::Square(2.0,1.5)=%f",CRect angle::Square(2.0,1.5));
}

Um argumento adicional a favor do uso do controle de constância é o fato de que neste caso, o compilador gera uma otimização especial, por exemplo, coloca um objeto constante na memória de somente-leitura.

Uma função estática não pode ser determinada com o modificador const, porque este modificar garante a constância dos membros de instância quando chamar esta função. Mas, como mencionado acima, a função estática não pode acessar membros de classe não estática.