In MQL5 c'è sempre spazio per un exploit! ;) - pagina 3

[---]

mql5:
Brevemente.
Le funzioni delle librerie di sistema per i processi x86 (32 bit) hanno un wrapper speciale attraverso il quale vengono passate a x64, eseguite e restituite a x86.

Windows a 64 bit ha una cartella chiamata SysWOW64. Questa cartella è destinata alle applicazioni a 32 bit lanciate nel sistema operativo a 64 bit, mentre le librerie e i driver regolari a 64 bit sono memorizzati nella cartella System32. Se il programma è lanciato come un 32 bit, i riferimenti alla cartella System32 sono reindirizzati a SysWOW64.

Per farla breve, il problema dei 32/64 bit è diventato acuto in MT5.

questa è una questione molto importante ed è ora che venga affrontata.

o aggiungere una cartella libraries64 in modo che il terminale sappia da dove prendere le librerie
o aggiungere qualche modo per disperdere le DLL nelle cartelle system32/SysWow64
o usare #ifdef

https://www.mql5.com/ru/forum/6729#comment_199764

ZS.
applicazione a SD #381730

[Yury Kulikov]

MetaDriver:

Array di qualsiasi dimensione (per chiarezza, diciamo che lo limitiamo a ^16).

La dimensionalità è impostata alla creazione dal numero di parametri, come per gli array normali.

XXArray  xx2(5,7),  xx5(12,12,16,16,8);

Gli indicizzatori dovrebbero funzionare per tutte le dimensioni ( A[i][j][k][n][m]....)

Bene, visto che la comunità tace, continuerò...

Uno schema di una classe di array N-dimensionale (doppio) e un test per testarlo.

La dimensionalità è descritta da (int) array nel costruttore.

//+------------------------------------------------------------------+
class CNXdouble
{
        double                 value[];
        int                    size[];
        int                    index;
        int                    ivalue;
public:
                               CNXdouble(const int &n[]);
                              ~CNXdouble()   { ArrayFree(value); ArrayFree(size);}
        double      operator[]   (long x_);
        CNXdouble  *operator[]  (int x_)      { ivalue+=x_*size[index++]; return(GetPointer(this));}
        void         operator=    (double d)    { value[ivalue]=d; index=0; ivalue=0;}
};
//+------------------------------------------------------------------+
CNXdouble::CNXdouble(const int &n[])
{
        int m=1, k=ArraySize(n);
        ArrayResize(size,k);
        size[k-1]=1;
        for(int i=k-2; i>=0; i--) size[i]=n[i+1]*size[i+1];
        for(int i=0; i<k; i++) m*=n[i];
        ArrayResize(value,m);
        index=0;
        ivalue=0;
}
//+------------------------------------------------------------------+
double CNXdouble::operator[] (long x_) 
{
        index=0;
        int i=ivalue;
        ivalue=0;
        return(value[i+(int)x_]);
}
//+------------------------------------------------------------------+
void OnStart()
{
   int n[]={2,3,4,2};      //описание 4-х мерного массива
   int a1=n[0], a2=n[1], a3=n[2], a4=n[3];
   CNXdouble d2(n);
   //запись в массив
   int c=0;
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++) 
               for(int y=0; y<a4; y++)
                   d2[i][j][x][y]=(double)c++;
   //чтение из массива
   string s="";
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++)
               for(long y=0; y<a4; y++)
                   s+=(string)d2[i][j][x][y]+" ";
   Print(s);
}
//+------------------------------------------------------------------+

[Yury Kulikov]

La seconda variante è una matrice N-dimensionale (doppia). La struttura dell'array è anche specificata nel costruttore da un altro array (int).

Questa variante è un po' più veloce della precedente. E in questa variante è più facile creare operazioni con i subarray.

class CNArray
{
        CNArray                    *array[];
        double                      value[];
        bool                        last;
        int                         ivalue;
public:
                                   CNArray(const int &n[]);
                                  ~CNArray();
        double      operator[]      (long x);
        CNArray*   operator[]      (int x);
        void        operator=       (double d) { if(last)value[ivalue]=d;}
};
//+------------------------------------------------------------------+
CNArray::CNArray(const int &n[])
{
        int k=ArraySize(n);
        if(k>1)
        {
                ArrayResize(array,n[0]);
                int n1[];
                ArrayResize(n1,k-1);
                for(int i=0; i<k-1; i++) n1[i]=n[i+1];
                for(int i=0; i<n[0]; i++) array[i]=new CNArray(n1);
                ArrayFree(n1);
                last=false;
        }else if(k==1)
        {
                ArrayResize(value,n[0]);
                last=true;
        }
}
//+------------------------------------------------------------------+
CNArray::~CNArray()
{ 
        if(!last)
        {
                int n=ArraySize(array);
                for(int i=0; i<n; i++) delete array[i];
                ArrayFree(array);
        }else ArrayFree(value);
}
//+------------------------------------------------------------------+
double CNArray::operator[](long x) 
{
        if(last) return(value[(int)x]); else return(0);
}
//+------------------------------------------------------------------+
CNArray* CNArray::operator[](int x)
{ 
        if(last)
        {
                ivalue=x; 
                return(GetPointer(this));
        }else return(array[x]);
}

[Vladimir Gomonov]

Yurich:

La seconda variante è una matrice N-dimensionale (doppia). La struttura dell'array è anche specificata nel costruttore da un altro array (int).

Questa variante è un po' più veloce della precedente. E in questa variante, è più facile creare operazioni con i subarray.

Yurich, sei un tipo in gamba, sono stato distratto dal forum per un paio di giorni e tu hai già fatto un paio di varianti.

Prima impressione - la prima variante è piena di intoppi alla chiamata errata con meno numero di indici: per esempio double x=A[i][j][k]; "chiamata tridimensionale" per array quadridimensionale restituirà double come niente di che, ma da qualsiasi altra posizione dell'array che l'utente voleva.E non è ovvio come rintracciare e gestire tali errori. Ma il vantaggio indiscutibile della prima implementazione è l'economia di memoria. Il secondo modo è molto più dispendioso. Ma, come hai giustamente notato, puoi provare a passare ai subarray in esso e tutte le difficoltà sono abbastanza gestibili in questo caso.

Ho alcune idee, ma non avrò tempo libero fino alla sera prima, se ci arrivo. Ma ci arriveremo, lo prometto. :)

--

Idea di base: usare un'altra classe, qualcosa come "left indexes controller", e l'indice più a destra da processare dalla classe principale (se funziona, altrimenti un'altra classe per l'indice destro). Così facendo, l'array base double (unidimensionale e l'unico) dovrebbe essere reso un membro della classe principale CNArray. Qualcosa del genere.

[Igor Makanu]

MetaDriver

Tx. prima impressione - la prima variante è irta di glitch alla chiamata errata con meno numero di indici: cioè per esempio doppio x=A[i][j][k]; "chiamata tridimensionale" per array quadridimensionale restituirà doppio come se nulla fosse successo, ma allo stesso tempo dalla posizione dell'array che l'utente voleva. Inoltre, per rintracciare e gestire tali errori non è visibile in che modo.

Ho giocato con il primo metodo di Yurich e sembra che sia possibile controllare il rango dell'array in questo modo:

class DinArr_Double{
        double                 value[];
        int                    size[];
        int                    index;
        int                    ivalue;
        int                    range;
        bool                   checkerror;
public:
                               DinArr_Double(const int &n[]);
                              ~DinArr_Double()   { ArrayFree(value); ArrayFree(size);}
        double          operator[](long x_);
        DinArr_Double*  operator[](int x_);
        void            operator= (double d)    { value[ivalue]=d; index=0; ivalue=0;}
};
//+------------------------------------------------------------------+
DinArr_Double::DinArr_Double(const int &n[]){
        int m=1, k=ArraySize(n);
        range = ArraySize(n);
        ArrayResize(size,k);
        size[k-1]=1;
        for(int i=k-2; i>=0; i--) size[i]=n[i+1]*size[i+1];
        for(int i=0; i<k; i++) m*=n[i];
        ArrayResize(value,m);
        index=0;
        ivalue=0;
        checkerror = false;
}
//+------------------------------------------------------------------+
double DinArr_Double::operator[](long x_){
        index=0;
        int i=ivalue;
        ivalue=0;
        return(value[i+(int)x_]);
}
//+------------------------------------------------------------------+
DinArr_Double*  DinArr_Double::operator[](int x_){
      ivalue+=x_*size[index++];

      if(index!=range)checkerror = true; else checkerror = false;
 
      return(GetPointer(this));
}
//+------------------------------------------------------------------+
void OnStart(){
   int n[]={2,3,4,2};      //описание 4-х мерного массива
   int a1=n[0], a2=n[1], a3=n[2], a4=n[3];
   DinArr_Double d2(n);
   //запись в массив
   int c=0;
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++) 
               for(int y=0; y<a4; y++)
                   d2[i][j][x][y]=(double)c++;
   //чтение из массива
   string s="";
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++)
               for(long y=0; y<a4; y++)
                   s+=(string)d2[i][j][x][y]+" ";
   Print(s);
}
//+------------------------------------------------------------------+

[---]

Compito:

- Per passare un array di numeri dall'Expert Advisor all'indicatore.

Requisiti.

Non usare
- eventi del grafico,
- file,
- variabili globali (note anche come file),
- dll

[Alexander Bereznyak]

sergeev:

Compito:

- Per passare un array di numeri dall'Expert Advisor all'indicatore.

Requisiti.

- Non usare eventi del grafico, file, dll per il trasferimento dei dati

Levariabili globali del terminale funzionano?

[Alexander Bereznyak]

Poi rimangono i canali nominati.

[---]

sandex:
Poi rimangono i canali nominati.

chi è il server?

[Yury Kulikov]

sergeev:

Compito:

- Per passare un array di numeri dall'Expert Advisor all'indicatore.

Condizioni.

Non usare
- eventi del grafico,
- file,
- variabili globali (alias file),
- dll

Non c'è nessuno che lo faccia :)

Allora propongo un'altra variante - usare la sottocartina e le funzioniChartSetString()eChartGetString().