Domande da un "manichino" - pagina 107

[[Eliminato]]

mql5:
I distruttori in MQL5 sono sempre virtuali. Tutto è cancellato correttamente, provate a mettere Print(__FUNCSIG__); nei distruttori.

L'ho fatto in VC++, ma penso che i meccanismi di rilascio della memoria siano gli stessi, giusto?

[Ilyas]

220Volt:
L'ho fatto in VC++, ma penso che i meccanismi di rilascio della memoria siano gli stessi?

No, in C++ dovete specificare il distruttore virtuale per eliminare correttamente l'oggetto tramite la cancellazione.

Ma il tuo esempio funzionerà correttamente, perché puoi specificare il distruttore virtuale solo per la classe base.

[[Eliminato]]

Cercherò di mettere l'idea in un modo leggermente diverso:

Dato:

• Classe #1 - occupa 100 byte di memoria.
• Classe #2 - è un discendente della classe #1 e occupa 200 byte di memoria.
• Puntatore alla classe #1.

Azioni:

• Scrivere nel puntatore l'indirizzo della sezione di memoria dove si trova un'istanza della classe #2 (chiamare new)
• Libera l'area di saldatura passando la funzione di cancellazione all'indirizzo memorizzato nel puntatore.

P.S.: la figura mostra il modello di memoria )

[[Eliminato]]

Ho dei dubbi perché il puntatore alla classe numero uno, ma in realtà la classe numero due è in memoria. È importante nel caso dei distruttori, quindi mi chiedevo se ci potesse essere un problema anche qui. Penso che in questa situazione la corretta liberazione della memoria possa avvenire solo se ci sono alcune etichette in memoria (come char con null-terminator) o qualcosa del genere, ecco perché ho chiesto dell'allocazione della memoria.

[Mykola Demko]

220Volt:
Dubbi perché il puntatore alla classe numero uno ed effettivamente in memoria la classe numero due. È importante nel caso dei distruttori, quindi mi chiedevo se ci può essere un problema anche qui. Penso che in tale situazione la corretta liberazione della memoria possa avvenire solo se ci sono alcune etichette in memoria (come char con zero-terminatore) o qualcosa del genere, ecco perché ho chiesto dell'allocazione della memoria.

Il tuo dubbio è perché non hai specificato i costruttori (è importante capire cosa succede in questo caso), prova ad eseguire questo esempio e capirai tutto:

class CFoo
  {
public:
                     CFoo() { Print(__FUNCSIG__); }
                    ~CFoo() { Print(__FUNCSIG__); }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CBar : public CFoo
  {
public:
                     CBar() { Print(__FUNCSIG__); }
                    ~CBar() { Print(__FUNCSIG__); }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   CFoo *f=new CBar();

   delete f;
  }
//+------------------------------------------------------------------+

HZ la costruzione stessa così come la cancellazione è scaglionata, e tutte queste informazioni sono memorizzate (il puntatore virtuale stesso ricorda che la classe è stata costruita come un composito dalla base e dal discendente), e quando si cancella, i distruttori sono chiamati in ordine inverso, dal successivo al precedente.

[[Eliminato]]

Non si tratta di distruttori, ma della classe stessa, e più precisamente di quanti byte occupa. Si scopre che si allocano 200 byte, e poi mi si dice di liberare la memoria, che è puntata da un puntatore che rappresenta un oggetto di dimensioni 100 byte.

[Ilyas]

220Volt:
Non si tratta di distruttori, ma della classe stessa, e più precisamente di quanti byte occupa. Si scopre che si allocano 200 byte e poi mi si dice di liberare la memoria indicata dal puntatore che rappresenta l'oggetto con la dimensione di 100 byte.

Immagino che la tua domanda sia legata al modo in cui funziona il pool di memoria.
Sì, il pool di memoria sa per quanto tempo un pezzo di memoria sarà liberato da una chiamata di cancellazione.
Dove vengono memorizzate queste informazioni dipende dall'implementazione del pool.

Per esempio, se date un puntatore a un oggetto in C++ che non è allocato tramite new, vedrete come la vostra applicazione andrà in crash.

[Mykola Demko]

220Volt:
Non si tratta di distruttori, ma della classe stessa, e più precisamente di quanti byte occupa. Si scopre che si allocano 200 byte e poi mi si dice di liberare la memoria indicata dal puntatore che rappresenta l'oggetto con la dimensione di 100 byte.

Immagino che tu non abbia analizzato il mio campione. Altrimenti non avresti fatto queste domande.

[[Eliminato]]

Stavo pensando, mi sono ricordato che si può allocare memoria per un array di int per esempio e poi cancellarli tutti, nonostante il fatto che un int sia piccolo, probabilmente lo stesso con le classi. Grazie per le risposte.

[[Eliminato]]

mql5:
Ho capito che la tua domanda ha a che fare con il modo in cui funziona il pool di memoria.
Sì, il pool di memoria sa per quanto tempo un pezzo sarà liberato da una chiamata di cancellazione.
Dove vengono memorizzate queste informazioni dipende dall'implementazione del pool.

Per esempio, se date un puntatore a un oggetto in C++ che non è stato allocato tramite new, vedrete come la vostra applicazione andrà in crash.

Questo è tutto, grazie.