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.
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; } }
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.
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.
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)))
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.
- 2014.02.08
- www.mql5.com
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso
Sto facendo una classe come questa.
Ora voglio chiamare un array di oggetti:
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?