Aiuto con OOP

Nuovo commento
 

Sto facendo una classe come questa.

class Strategy1
{
        Strategy1();
 };

class Strategy2
{
        Strategy (string sym);
}

Ora voglio chiamare un array di oggetti:

Strategy1 S[10];  // компилируется 
Strategy2 Z("EURUSD")[10]; // не компилируется

Come creare rapidamente un array di oggetti se il costruttore ha parametri a livello globale?

Per esempio? Creare prima gli oggetti cambiando il costruttore e poi come faccio a sostituire gli oggetti con i simboli in OnInit?

Forse c'è una soluzione più semplice?

 

Personalmente, uso la funzione Init() sugli oggetti in questi casi.

Prima viene creato un array e poi viene chiamata la funzione Init() per tutti gli oggetti nell'array, dove tutti i parametri possono essere impostati.

L'inizializzazione con una funzione separata permette di reinizializzare gli oggetti, e se si inizializza nel costruttore, non si può reinizializzare l'oggetto.

 
Georgiy Merts #:

Personalmente, uso la funzione Init() sugli oggetti in questi casi.

Prima viene creato un array e poi viene chiamata la funzione Init() per tutti gli oggetti dell'array, dove tutti i parametri possono essere impostati.

L'inizializzazione con una funzione separata permette di reinizializzare gli oggetti, e se la inizializzi nel costruttore, è impossibile reinizializzare l'oggetto.

Beh, è così che me lo immaginavo. Grazie!

 

Un altro punto. È meglio creare array di oggetti per mezzo di un puntatore. Altrimenti otterrete un array nella memoria dello stack, che è molto piccolo:

Strategy2 *pZ[]; 
if (ArrayResize(pZ, 10) != 10)
{
   Alert("Memory allocation error");
   return;
}

for (int i = 0; i < 10; ++i)
{
   pZ[i] = new Strategy2("EURUSD"); 
   if (CheckPointer(pZ) == POINTER_INVALID)
   {
      Alert("Class instantiation error");
      return;
   }
}
 
Ihor Herasko #:

Un altro punto. È meglio creare array di oggetti per mezzo di un puntatore. Altrimenti otterrete un array nella memoria dello stack che è molto basso:

Un esempio di un potenziale problema sarebbe carino.

 
Ihor Herasko #:

Un altro punto. È meglio creare array di oggetti per mezzo di un puntatore. Altrimenti otterrete un array nella memoria dello stack che è molto piccolo:

Ahi.

 
Non è un grosso problema.
 
fxsaber #:

Un esempio di un potenziale problema andrebbe bene.

Non è un problema, e certamente non è un problema potenziale. Sono solo le peculiarità della gestione della memoria in MT. Qui c'è un array statico:

#define               ARRAY_SIZE           int(60000000)
class Test
{
public:
   int               nA;
   double            fB;
   datetime          dtC;

                     Test(void)
                       : nA(0)
                       , fB(1.0)
                       , dtC(__DATETIME__)
                     {
                     };
};

Test classTest[ARRAY_SIZE];                   // 'classTest' - global variables section is too large
 
void OnStart()
{
}

Ed ecco un array dinamico:

#define               ARRAY_SIZE           int(60000000)
class Test
{
public:
   int               nA;
   double            fB;
   datetime          dtC;

                     Test(void)
                       : nA(0)
                       , fB(1.0)
                       , dtC(__DATETIME__)
                     {
                     };
};

Test *pClassTest[];
 
void OnStart()
{
   if (ArrayResize(pClassTest, ARRAY_SIZE) != ARRAY_SIZE)
   {
      Alert("Not enought memory");
      return;
   }
   
   for (int i = 0; i < ARRAY_SIZE; ++i)
   {
      pClassTest[i] = new Test();
      if (CheckPointer(pClassTest[i]) == POINTER_INVALID)
      {
         Alert("Class instantiation error");
         return;
      }
   }

   for (int i = 0; i < ARRAY_SIZE; ++i)
      delete pClassTest[i];
}

In questo caso, tutto si compila e funziona.

 
Ihor Herasko #:

Non è un problema, tanto meno un problema potenziale. Sono solo le peculiarità della gestione della memoria in MT. Qui c'è un array statico:

Ed ecco un array dinamico:

In questo caso tutto si compila e funziona.

Cosa c'entra la pila? Nel primo caso, avete cercato di allocare staticamente (in fase di compilazione) un grande blocco di memoria in un heap e il compilatore vi ha giustamente dato un calcio in fronte perché non è molto chiaro in realtà se potete allocare tutta quella memoria o no.

Nel secondo caso state allocando un grosso pezzo di memoria già in runtime. Ed è subito chiaro se si può allocare o meno, perché il programma sta già lavorando con una risorsa specifica della macchina (la memoria).

E cosa c'entrano i puntatori? Gli array in mql sono di due tipi, predefiniti in fase di compilazione e dinamici. Non solo i puntatori *, ma anche i normali campi di classe possono puntare ad array dinamici. Quindi usare i puntatori qui non è assolutamente giustificato.

s.e. Strana impressione del codice, come puntatori, classi, macro - con completa mancanza di comprensione di ciò che sta succedendo.

 
Ihor Herasko #:

Non è un problema, tanto meno un problema potenziale. Sono solo le peculiarità della gestione della memoria in MT. Qui c'è un array statico:

Ed ecco un array dinamico:

In questo caso, tutto si compila e funziona.

Esempio sbagliato, è solo una limitazione del compilatore che non dice nulla e gli sviluppatori hanno deciso così.

Se ci fossero due versioni - una ha un grande array statico e l'altra ne ha uno piccolo e, ecco, quando il programma funziona, i problemi si verificano in un caso, per esempio, quando si chiama ricorsivamente una funzione, mentre nell'altro caso, nelle stesse condizioni, no. È allora che si potrebbe trarre una conclusione ... sul danno del succo appena spremuto)))

 
Vasiliy Sokolov #:

Cosa c'entra la pila? Nel primo caso, avete cercato di allocare staticamente (in fase di compilazione) un grande blocco di memoria nell'heap e il compilatore vi ha meritatamente preso a calci in testa perché non è affatto chiaro nel mondo reale se potete allocare così tanta memoria o no.

Nel secondo caso state allocando un grosso pezzo di memoria già in runtime. Ed è subito chiaro se si può allocare o meno, perché il programma sta già lavorando con una risorsa specifica della macchina (la memoria).

E cosa c'entrano i puntatori? Gli array in mql sono di due tipi, predefiniti in fase di compilazione e dinamici. Non solo i puntatori *, ma anche i normali campi di classe possono puntare ad array dinamici. Quindi usare i puntatori qui non è assolutamente giustificato.

s.e. Strana impressione del codice, come puntatori, classi, macro - con completa mancanza di comprensione di ciò che sta succedendo.

Se alteriamo un po' l'esempio, lo dichiariamo localmente e mettiamo un numero non così brutto, il compilatore ci dice direttamente qual è il problema:

#property strict
#define               ARRAY_SIZE           int(140000)

class Test
{
   
public:
   int               nA;
   double            fB;
   datetime          dtC;

                     Test(void)
                       : nA(0)
                       , fB(1.0)
                       , dtC(__DATETIME__)
                     {
                     };
};
 
void OnStart()
{
   Test classTest[ARRAY_SIZE];    // the size of local variables is too large
}
Se vuoi discutere con Renate, sei il benvenuto a farlo.
the size of local variables is too large (more than 512kb)
the size of local variables is too large (more than 512kb)
  • 2014.02.08
  • www.mql5.com
Здравствуйте! Написал индикатор на mql4. Все работало...
123456789
Nuovo commento
Motivazione: