Discussione sull’articolo "Fondamenti di programmazione MQL5: Arrays" - pagina 2

Nuovo commento
 
Un articolo molto utile e ben spiegato, grazie Dmitry Fedoseev.
 
Come restituire un array da una funzione? Ho trovato una soluzione, ma ovviamente ci deve essere un modo per farlo "di petto" )).
 
thejobber:
Come restituire un array da una funzione? Finora ho trovato una soluzione, ma ovviamente ci deve essere un modo per farlo "di petto" )).

Non c'è modo di farlo di petto... se non con un puntatore all'array. Per esempio:

CArrayDouble *Function(void);

Non è un approccio diretto, ma piuttosto standard, come questo, in questa sezione:

void Function(double &_arr_out[]);
In generale, l'array restituito è un riferimento a un parametro...
 

Sì, grazie. Ho provato a fare immediatamente

restituire *x; per abitudine, come in C++ ))

invece di

restituire GetPointer(x)

l'ho capito ))

 
MetaQuotes Software Corp.:

Nuovo articolo Fondamenti di programmazione MQL5: Array è stato pubblicato:

Autore: Dmitry Fedoseev

1 Domanda:

#define  SIZE_X 3;

(...)

int ArrayName[SIZE_X];

Il compilatore vieta questa costruzione. Perché?

 
Molte grazie per questa recensione estesa
 
#import "dll.dll"
  double qwerty(double &q[]);
#importazione

Sto creando una dll e voglio passarle un puntatore ad un array.

Ma non riesco a capire come farlo.

C'è qualcosa che non va.


Ho bisogno di un analogo del C++


doppio qwerty(doppio *q);

doppio *q;

q = nuovo doppio [100];

qwerty(q);


Come farlo in MQL5...

 
In mql, qualsiasi array ci sia, è quello che è, non si può fare nulla con esso. Non dovrebbero esserci problemi. L'errore è da qualche parte vicino alla vostra dll. Forse si dovrebbe passare la dimensione dell'array nella dll.
 

Grazie per il tuo codice che mi ha fatto risparmiare un po' di tempo per scrivere. Ho provato a usare l'oggetto MQL5 Array (double, int ecc.) e mi sono sentito frustrato. Sono arrivato al tuo post e ho trovato il tuo codice per ridimensionare gli array: fantastico, grazie. Ho modificato il tuo codice per adattarlo a qualsiasi tipo di dati. Solo non provare a usare il metodo Contains (Search method) per gli oggetti perché potrebbe non funzionare in quanto gli oggetti potrebbero essere riferimenti, non ne sono sicuro, non l'ho testato. Sto cercando di ricreare C# all'interno di MQL5, quindi le abbreviazioni sono simili :)


Dio ti benedica!!! 



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


// | 
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;     

// Dimensione del pezzo 
   

int 

                m_ReservedSize; 

// Dimensione effettiva dell'array 
   

int 

                m_Size;         

// Numero di elementi attivi nell'array 


public 

 : 


   T Element [];       

// L'array vero e proprio. 
Si trova nella sezione pubblica, 
                                     

// in modo da poterlo usare direttamente, se necessario 
   

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

| 
Costruttore 
   

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

void 

 CDynamicArray ( 

int 

 ChunkSize = 

1024 

 ) 


     { 


      m_Size = 

0 

 ;                             

// Numero di elementi attivi 


       m_ChunkSize = ChunkSize;               

// Dimensione del pezzo 


       m_ReservedSize = ChunkSize;             

// Dimensione effettiva dell'array 
      

ArrayResize 

 (Element, m_ReservedSize); 

// Preparare l'array 


      } 
   

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

// | 
Funzione per aggiungere un elemento alla fine dell'array | 
   

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

void 

 Add (T Value) 


     { 


      m_Size ++; 

// Aumenta il numero di elementi attivi 
      

if 

 (m_Size> m_ReservedSize) 


        { 

// Il numero richiesto è superiore alla dimensione effettiva dell'array 


          m_ReservedSize + = m_ChunkSize; 

// Calcolo della nuova dimensione dell'array 
         

ArrayResize 

 (Element, m_ReservedSize); 

// Aumenta la dimensione effettiva dell'array 


         } 


      Element [m_Size- 

1 

 ] = Value; 

// Aggiungere il valore 


      } 
     
     

void 

 Set ( 

int 

 index, T Value) 


     { 


      m_Size ++; 

// Aumenta il numero di elementi attivi 
      

if 

 (m_Size <index) 


        { 
         

return 

 ; 


        } 


      Element [index] = Value; 

// Aggiungere il valore 


      } 
   

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

// | 
Funzione per ottenere il numero di elementi attivi nell'array | 
   

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

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 

 ; 


   } 


  }; 


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

Allora puoi dichiararli così: 

CDynamicArray 

< 

int 

> 

  *Tickets; 


CDynamicArray 

< 

bool 

> 

 *FixedSLUsed; 


CDynamicArray 

< 

bool 

> 

 *PrevBarSLUsed;

e crearli come: 

                        Tickets = 

new 

 CDynamicArray< 

int 

>(); 


                        FixedSLUsed = 

new 

 CDynamicArray< 

bool 

>(); 


                        PrevBarSLUsed = 

new 

 CDynamicArray< 

bool 

>();

e nel codice le usi come una normale classe: 



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, proviamo la versione inglese di MQL.


Grazie per il tuo post sul codice. Mi ha fatto risparmiare tempo. Ho provato a usare gli array di MQL e mi hanno confuso. Ero molto depresso per il fatto di dover scrivere ancora una volta le strutture di base che avrebbero dovuto esserci, ma poi ho trovato il tuo codice che mi ha fatto risparmiare un po' di tempo di ricerca sugli array e su come farli crescere o aumentare dinamicamente. Fantastico, grazie.

Spero di poter ricambiare! Il codice qui sotto funziona per tutti i tipi di dati. Funzionerà anche sugli oggetti, ma il metodo Contains (search) potrebbe non funzionare. L'ho testato solo su tipi (double, int, bool). Anche le stringhe potrebbero dare problemi e potrebbe essere necessario estendere il codice.


//+------------------------------------------------------------------+
//|CDynamicArray.mqh |
//|Intero |
//| 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;    // Dimensione del pezzo
   int               m_ReservedSize; // Dimensione effettiva dell'array
   int               m_Size;         // Numero di elementi attivi nell'array
public:
   T                 Element[];      // L'array vero e proprio. Si trova nella sezione pubblica, 
                                     // in modo da poterlo usare direttamente, se necessario
   //+------------------------------------------------------------------+
   //| Costruttore|
   //+------------------------------------------------------------------+
   void CDynamicArray(int ChunkSize=1024)
     {
      m_Size=0;                            // Numero di elementi attivi
      m_ChunkSize=ChunkSize;               // Dimensione del pezzo
      m_ReservedSize=ChunkSize;            // Dimensione effettiva dell'array
      ArrayResize(Element,m_ReservedSize); // Preparare l'array
     }
   //+------------------------------------------------------------------+
   //| Funzione per aggiungere un elemento alla fine dell'array |
   //+------------------------------------------------------------------+
   void Add(T Value)
     {
      m_Size++; // Aumenta il numero di elementi attivi
      if(m_Size>m_ReservedSize)
        { // Il numero richiesto è maggiore della dimensione effettiva dell'array
         m_ReservedSize+=m_ChunkSize; // Calcolo della nuova dimensione dell'array
         ArrayResize(Element,m_ReservedSize); // Aumenta la dimensione effettiva dell'array
        }
      Element[m_Size-1]=Value; // Aggiungere il valore
     }
     
     void Set(int index, T Value)
     {
      m_Size++; // Aumenta il numero di elementi attivi
      if(m_Size<index)
        { 
         return;
        }
      Element[index]=Value; // Aggiungere il valore
     }
   //+------------------------------------------------------------------+
   //| Funzione per ottenere il numero di elementi attivi nell'array|
   //+------------------------------------------------------------------+
   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;
   }
  };
//+------------------------------------------------------------------+


Quindi è possibile dichiararlo per tutti i tipi di cui si ha bisogno in questo modo:


//li ho dichiarati nella mia classe in questo modo
   CDynamicArray<int> *Tickets;
   CDynamicArray<bool> *FixedSLUsed;
   CDynamicArray<bool> *PrevBarSLUsed;


// Poi li ho dichiarati nei metodi della mia classe in questo modo

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

// e li ho utilizzati nei metodi della mia classe in questo modo:
      int ticket = PositionGetInteger(POSITION_TICKET);
      int index;
      if(!Tickets.Contains(ticket))
      {
         Tickets.Add(ticket);
         FixedSLUsed.Add(false);
         PrevBarSLUsed.Add(false);
      }
      
      index = Tickets.IndexOf(ticket);  
//altro codice è stato rimosso



Spero che questo aiuti qualcuno

123
Nuovo commento