Discussão do artigo "Fundamentos básicos da programação MQL5: Arrays" - página 2

Novo comentário
 
Um artigo muito útil e bem explicado, obrigado Dmitry Fedoseev.
 
Como retornar uma matriz de uma função? Encontrei uma solução alternativa, mas obviamente deve haver uma maneira de fazer isso "de frente" )).
 
thejobber:
Como retornar uma matriz de uma função? Encontrei uma solução alternativa até agora, mas obviamente deve haver uma maneira de fazer isso "de frente" )).

Não há nenhuma maneira de fazer isso de frente... exceto por um ponteiro para a matriz. Por exemplo:

CArrayDouble *Function(void);

Não de frente, mas uma abordagem bastante padrão, como esta, nesta seção:

void Function(double &_arr_out[]);
Em geral, a matriz retornada é uma referência de parâmetro...
 

Sim, obrigado. Tentei usar imediatamente

return *x; por hábito, como em C++ ))

em vez de

return GetPointer(x)

descobri isso ))

 
MetaQuotes Software Corp.:

Novo artigo Noções básicas de programação MQL5: Matrizes é publicado:

Autor: Dmitry Fedoseev

1 Questão:

#define  SIZE_X 3;

(...)

int ArrayName[SIZE_X];

O compilador proíbe essa construção. Por quê?

 
Muito obrigado por essa análise detalhada
 
#importar "dll.dll"
  double qwerty(double &q[]);
#importar

Estou criando uma dll e quero passar um ponteiro de matriz para ela.

Mas não consigo descobrir como fazer isso.

Há algo errado.


Preciso de um análogo do C++


double qwerty(double *q);

double *q;

q = new duplo [100];

qwerty(q);


Como fazer isso em MQL5...

 
No mql, qualquer que seja o array, ele é o que é, você não pode fazer nada com ele. Não deve haver nenhum problema. O erro está em algum lugar próximo em sua dll. Talvez você deva passar o tamanho do array na dll.
 

Obrigado por seu código, ele me poupou algum tempo para escrever. Tentei usar o objeto MQL5 Array (double, int etc.) e fiquei frustrado. Cheguei à sua postagem e encontrei seu código para redimensionar as matrizes, o que foi ótimo, obrigado. Modifiquei seu código para atender a qualquer tipo de dados. Apenas não tente usar o método Contains (Search method) para objetos, pois ele pode não funcionar, já que os objetos podem ser referências, não tenho certeza se testei isso. Estou tentando recriar o C# dentro da MQL5, por isso as abreviações são semelhantes :)


Deus o abençoe!!! 



// + ----------------------------------------------- ------------------- + 


// 
CDynamicArray.mqh 


// | 
Integer | 


// | 
https://login.mql5.com/ru/users/Integer | 


// + ----------------------------------------------- ------------------- + 


#property 

copyright  

"Integer" 


#property 

link  

"https://login.mql5.com/en/users/Integer" 


// + - -------------------------------------------------- --------------- + 


// | 
| 


// + ----------------------------------------------- ------------------- + 


template 

< 

typename 

 T> 


class 

 CDynamicArray 


  { 


private 

 : 
   

int 

                m_ChunkSize;     

// Tamanho do pedaço 
   

int 

                m_ReservedSize; 

// Tamanho real da matriz 
   

int 

                m_Size;         

// Número de elementos ativos na matriz 


public 

 : 


   T Element [];       

// A matriz propriamente dita. 
Ele está localizado na seção pública, 
                                     

// para que possamos usá-lo diretamente, se necessário 
   

// + --------------------------- --------------------------------------- + 
   

| 
Constructor | 
   

// + ----------------------------------------------- ------------------- + 
   

void 

 CDynamicArray ( 

int 

 ChunkSize = 

1024 

 ) 


     { 


      m_Size = 

0 

 ;                             

// Número de elementos ativos 


       m_ChunkSize = ChunkSize;               

// Tamanho do pedaço 


       m_ReservedSize = ChunkSize;             

// Tamanho real da matriz 
      

ArrayResize 

 (Element, m_ReservedSize); 

// Preparar a matriz 


      } 
   

// + ----------------------------------------- ------------------------- + 
   

// | 
Função para adicionar um elemento no final da matriz | 
   

// + ----------------------------------------------- ------------------- + 
   

void 

 Add (T Value) 


     { 


      m_Size ++; 

// Aumentar o número de elementos ativos 
      

if 

 (m_Size> m_ReservedSize) 


        { 

// O número necessário é maior que o tamanho real da matriz 


          m_ReservedSize + = m_ChunkSize; 

// Calcular o novo tamanho da matriz 
         

ArrayResize 

 (Element, m_ReservedSize); 

// Aumentar o tamanho real da matriz 


         } 


      Element [m_Size- 

1 

 ] = Value; 

// Adicionar o valor 


      } 
     
     

void 

 Set ( 

int 

 index, T Value) 


     { 


      m_Size ++; 

// Aumentar o número de elementos ativos 
      

if 

 (m_Size <index) 


        { 
         

return 

 ; 


        } 


      Element [index] = Value; 

// Adicionar o valor 


      } 
   

// + ----------------------------------------- ------------------------- + 
   

// | 
Função para obter o número de elementos ativos na matriz 
   

// + ----------------------------------------------- ------------------- + 
   

int 

 Count () 


     { 
      

return 

 (m_Size); 


     } 
   


   T 

operator 

 [] ( 

const  

int 

 index) 

const 

 { 

return 

 Element [index]; 
} 
   
   

bool 

Contains (T itemToFind) 


   { 
      

for 

 ( 

int 

 i = 

0 

 ; i <Count (); i ++) 


        { 
            

if 

 (Element [i] == itemToFind) 


            { 
               

return  

true 

 ; 


            } 


        } 
        
      

return  

false 

 ; 


   } 
   
   

int 

 IndexOf (T itemToFind) 


   { 
      

for 

 ( 

int 

 i = 

0 

 ; i <Count (); i ++) 


        { 
            

if 

 (Element [i] == itemToFind) 


            { 
               

return 

 i; 


            } 


        } 
        
      

return 

 - 

1 

 ; 


   } 


  }; 


// + ----------------------------------------------- ------------------- +

Então você pode declará-los assim: 

CDynamicArray 

< 

int 

> 

  *Tickets; 


CDynamicArray 

< 

bool 

> 

 *FixedSLUsed; 


CDynamicArray 

< 

bool 

> 

 *PrevBarSLUsed;

e criá-los como: 

                        Tickets = 

new 

 CDynamicArray< 

int 

>(); 


                        FixedSLUsed = 

new 

 CDynamicArray< 

bool 

>(); 


                        PrevBarSLUsed = 

new 

 CDynamicArray< 

bool 

>();

e no código você as usa como uma classe normal: 



int 

 ticket = 

PositionGetInteger 

 ( 

POSITION_TICKET 

 ); 


int 

 index; 


if 

 (!Tickets.Contains(ticket)) // If Ticket Object does NOT contains ticket then we go into the if 


{ 


        Tickets.Add(ticket); 


        FixedSLUsed.Add( 

false 

); 


        PrevBarSLUsed.Add( 

false 

); 


} 
      


index = Tickets.IndexOf(ticket);  
 

Ok, vamos tentar a versão em inglês do MQL.


Obrigado por sua postagem de código. Isso me poupou tempo. Tentei usar as matrizes MQL e elas eram confusas. Fiquei muito deprimido por ter que escrever novamente as estruturas básicas que deveriam estar lá, MAS então encontrei seu código que me poupou algum tempo de pesquisa sobre matrizes e como fazê-las crescer\aumentar dinamicamente. Muito obrigado.

Espero poder retribuir a você! O código abaixo funciona para todos os tipos de dados. Ele também funcionará em objetos, mas o método Contains (pesquisa) talvez não funcione. Eu o testei apenas em tipos (double, int, bool). O String também pode apresentar problemas e o código talvez precise ser estendido.


//+------------------------------------------------------------------+
//|CDynamicArray.mqh
//|Inteiro
//| https://login.mql5.com/ru/users/Integer
//+------------------------------------------------------------------+
#property copyright "Integer"
#property link "https://login.mql5.com/ru/users/Integer"
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
template <typename T>
class CDynamicArray
  {
private:
   int               m_ChunkSize;    // Tamanho do pedaço
   int               m_ReservedSize; // Tamanho real da matriz
   int               m_Size;         // Número de elementos ativos na matriz
public:
   T                 Element[];      // A matriz propriamente dita. Ele está localizado na seção pública, 
                                     // para que possamos usá-lo diretamente, se necessário
   //+------------------------------------------------------------------+
   //| Construtor|
   //+------------------------------------------------------------------+
   void CDynamicArray(int ChunkSize=1024)
     {
      m_Size=0;                            // Número de elementos ativos
      m_ChunkSize=ChunkSize;               // Tamanho do pedaço
      m_ReservedSize=ChunkSize;            // Tamanho real da matriz
      ArrayResize(Element,m_ReservedSize); // Preparar a matriz
     }
   //+------------------------------------------------------------------+
   //| Função para adicionar um elemento no final da matriz
   //+------------------------------------------------------------------+
   void Add(T Value)
     {
      m_Size++; // Aumentar o número de elementos ativos
      if(m_Size>m_ReservedSize)
        { // O número necessário é maior do que o tamanho real da matriz
         m_ReservedSize+=m_ChunkSize; // Calcular o novo tamanho da matriz
         ArrayResize(Element,m_ReservedSize); // Aumentar o tamanho real da matriz
        }
      Element[m_Size-1]=Value; // Adicionar o valor
     }
     
     void Set(int index, T Value)
     {
      m_Size++; // Aumentar o número de elementos ativos
      if(m_Size<index)
        { 
         return;
        }
      Element[index]=Value; // Adicionar o valor
     }
   //+------------------------------------------------------------------+
   //| Função para obter o número de elementos ativos na matriz
   //+------------------------------------------------------------------+
   int Count()
     {
      return(m_Size);
     }
   
   T operator[](const int index) const { return Element[index]; }
   
   bool Contains(T itemToFind)
   {
      for(int i=0;i<Count();i++)
        {
            if(Element[i] == itemToFind)
            {
               return true;
            }
        }
        
      return false;
   }
   
   int IndexOf(T itemToFind)
   {
      for(int i=0;i<Count();i++)
        {
            if(Element[i] == itemToFind)
            {
               return i;
            }
        }
        
      return -1;
   }
  };
//+------------------------------------------------------------------+


Em seguida, você pode declará-lo para todos os tipos de que precisar, dessa forma:


//Eu os declarei em minha classe da seguinte forma
   CDynamicArray<int> *Tickets;
   CDynamicArray<bool> *FixedSLUsed;
   CDynamicArray<bool> *PrevBarSLUsed;


// Em seguida, eu os declarei nos métodos de minha classe da seguinte forma

   Tickets = new CDynamicArray<int>();
   FixedSLUsed = new CDynamicArray<bool>();
   PrevBarSLUsed = new CDynamicArray<bool>();

// e eu os usei em meus métodos de classe da seguinte forma:
      int ticket = PositionGetInteger(POSITION_TICKET);
      int index;
      if(!Tickets.Contains(ticket))
      {
         Tickets.Add(ticket);
         FixedSLUsed.Add(false);
         PrevBarSLUsed.Add(false);
      }
      
      index = Tickets.IndexOf(ticket);  
//mais código foi removido



Espero que isso ajude a todos

123
Novo comentário