photo
+ Responder ao Tópico
Resultados de 1 a 1 de 1

Thread: Modelos de classes

  1. #1 Fechar a publicação
    Banned
    Data de afiliação
    Aug 2018
    Postagens
    343
    Obrigado
    91
    Agradecimentos 216 Tempos em 141 Postagens

    Modelos de classes

    O modelo de classe é declarado usando a palavra-chave template, seguida pelos colchetes angulares <>, nos quais são listados os parâmetros formais com a palavra-chave typename. Este registro indica ao compilador que está perante uma classe genérica na com o parâmetro formal T que especifica o tipo real da variável ao implementar a classe. Por exemplo, criamos uma classe vector para armazenar a matriz com elementos do tipo T:



    #define TOSTR(x) #x+" " // macro para exibir o nome do objeto
    //+------------------------------------------------------------------+
    //| Classe vector para armazenar elementos do tipo T |
    //+------------------------------------------------------------------+
    template <typename T>
    class TArray
    {
    protected:
    T m_array[];
    public:
    //--- por padrão, o construtor cria uma matriz de 10 elementos
    void TArray(void){ArrayResize(m_array,10);}
    //--- construtor para criar um vetor com o tamanho definido da matriz
    void TArray(int size){ArrayResize(m_array,size);}
    //--- retorna o tipo e número de dados que são armazenados no objeto do tipo TArray
    string Type(void){return(typename(m_array[0])+":"+(string)ArraySize(m_array));};
    };


    Em seguida, no programa, criamos de maneiras diferentes três objetos TArray para trabalhar com diferentes tipos



    void OnStart()
    {
    TArray<double> double_array; // por padrão, o tamanho do vetor é 10
    TArray<int> int_array(15); // o tamanho do vetor é 15
    TArray<string> *string_array; // ponteiro para o vetor TArray<string>
    //--- criamos o objeto dinâmico
    string_array=new TArray<string>(20);
    //--- no Diário, exibimos o nome do objeto, tipo de dados e tamanho do vetor
    PrintFormat("%s (%s)",TOSTR(double_array),double_array.Type());
    PrintFormat("%s (%s)",TOSTR(int_array),int_array.Type());
    PrintFormat("%s (%s)",TOSTR(string_array),string_array.Type());
    //--- excluímos o objeto dinâmico antes de encerrar o programa
    delete(string_array);
    }


    Resultado do script:



    double_array (double:10)
    int_array (int:15)
    string_array (string:20)


    Como resultado, foram criados 3 vetores com diferentes tipos de dados: double, int e string.

    Os modelos de classes são adequados para desenvolver recipientes, isto é, os objetos destinados a encapsular qualquer tipo de objeto. Os objetos dos recipientes são coleções que já contêm objetos de um tipo particular. Normalmente, o recipiente imediatamente é integrado e implementado para trabalhar com dados que são armazenados nele.

    Por exemplo, é possível criar um modelo de classe que não permita acessar um elemento fora da matriz e, assim, evitar o erro crítico "out of range".



    //+------------------------------------------------------------------+
    // | Classe para acessar com segurança um elemento da matriz |
    //+------------------------------------------------------------------+
    template<typename T>
    class TSafeArray
    {
    protected:
    T m_array[];
    public:
    //--- construtor por padrão
    void TSafeArray(void){}
    //--- construtor para criar a matriz do tamanho especificado
    void TSafeArray(int size){ArrayResize(m_array,size);}
    //--- tamanho de matriz
    int Size(void){return(ArraySize(m_array));}
    //--- alteração do tamanho da matriz
    int Resize(int size,int reserve){return(ArrayResize(m_array,size,reserve)) ;}
    //--- libertação da matriz
    void Erase(void){ZeroMemory(m_array);}
    //--- operador de acesso ao elemento da matriz de acordo com o índice
    T operator[](int index);
    //--- operador de atribuição para obter imediatamente todos os elementos a partir da matriz
    void operator=(const T &array[]); // matriz do tipo T
    };
    //+------------------------------------------------------------------+
    //| Operação de obtenção do elemento segundo o índice |
    //+------------------------------------------------------------------+
    template<typename T>
    T TSafeArray::operator[](int index)
    {
    static T invalid_value;
    //---
    int max=ArraySize(m_array)-1;
    if(index<0 || index>=ArraySize(m_array))
    {
    PrintFormat("%s index %d is not in range (0-%d)!",__FUNCTION__,index,max);
    return(invalid_value);
    }
    //---
    return(m_array[index]);
    }
    //+------------------------------------------------------------------+
    //| Operação de atribuição para a matriz |
    //+------------------------------------------------------------------+
    template<typename T>
    void TSafeArray::operator=(const T &array[])
    {
    int size=ArraySize(array);
    ArrayResize(m_array,size);
    //--- o tipo T deve suportar o operador de cópia
    for(int i=0;i<size;i++)
    m_array[i]=array[i];
    //---
    }
    //+------------------------------------------------------------------+
    //| Script program start function |
    //+------------------------------------------------------------------+
    void OnStart()
    {
    int copied,size=15;
    MqlRates rates[];
    //--- copiamos a matriz de cotações
    if((copied=CopyRates(_Symbol,_Period,0,size,rates) )!=size)
    {
    PrintFormat("CopyRates(%s,%s,0,%d) retornou o código de erro %d",
    _Symbol,EnumToString(_Period),size,GetLastError()) ;
    return;
    }
    //--- criamos o recipiente e colocamos nele a matriz dos valores MqlRates
    TSafeArray<MqlRates> safe_rates;
    safe_rates=rates;
    //--- índice nos limites da matriz
    int index=3;
    PrintFormat("Close[%d]=%G",index,safe_rates[index].close);
    //--- índice fora dos limites da matriz
    index=size;
    PrintFormat("Close[%d]=%G",index,safe_rates[index].close);
    }


    Note-se que, na descrição dos métodos fora da declaração da classe, também é necessário utilizar a declaração de modelo:



    template<typename T>
    T TSafeArray::operator[](int index)
    {
    ...
    }
    template<typename T>
    void TSafeArray::operator=(const T &array[])
    {
    ...
    }


    Os modelos de classes e funções permitem especificar vários parâmetros formais, separados por vírgulas, por exemplo, coleção Map para armazenar os pares "chave - valor":



    template<typename Key, template Value>
    class TMap
    {
    ...
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  2. The Following User Says Thank You to forumforex For This Useful Post:

    Não registrado (1 )

+ Responder ao Tópico

Permissões de postagens

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts