Discussione sull’articolo "Le Basi della Programmazione Orientata agli Oggetti" - pagina 3

[bivmail]

1) Ho pensato che ci fosse un errore qui:

Sezione: Passaggio di parametri al costruttore

"La funzione Init() è messa da parte nella sezione privato per garantire che la classe possa essere reinizializzata".

possibile:

La funzione Init() è accantonata nella sezione pubblica per garantire la possibilità di reinizializzare la classe.

2) Si prega di fornire un esempio di utilizzo della funzione"crea un array con istanze di classe (oggetti)" per la sezione "ObjectArray". Purtroppo non riesco a capire "a cosa serva".

3) Nella sezione "Approfondimenti sull'incapsulamento (privato, protetto, pubblico)", viene menzionato di sfuggita il discendente classe base->classe. Forse questo dato(classe Class: public CBase) dovrebbe essere spiegato all'inizio della sezione, perché me ne sono accorto dopo.

4) non ho trovato:Fig.6. La visibilità della funzione "extra" (freccia rossa) è determinata dal tipo di puntatore con cui è caricata la classe. Questo esempio si trova in appendice nel file OOP_sDefaultVirtual_1.mq5.

5) Non ho trovato una chiara indicazione di cosa sia una libreria. Apparentemente, un modo per memorizzare le classi delle funzioni? Cioè, simile al file di inclusione, solo che il file di inclusione è memorizzato come sorgente e la libreria come una dll compilata?

Grazie mille per l'articolo! Mi ha fatto particolarmente piacere la presentazione coerente del materiale.

[Dmitry Fedoseev]

bivmail:

1) Ho pensato che ci fosse un errore qui:

Sezione: Passaggio di parametri al costruttore

"La funzione Init() è messa da parte nella sezione privato per garantire che la classe possa essere reinizializzata".

possibile:

La funzione Init() è accantonata nella sezione pubblica per garantire la possibilità di reinizializzare la classe.

2) Si prega di fornire un esempio di utilizzo della funzione"crea un array con istanze di classe (oggetti)" per la sezione "ObjectArray". Purtroppo non riesco a capire "a cosa serva".

3) Nella sezione "Approfondimenti sull'incapsulamento (privato, protetto, pubblico)", viene menzionato di sfuggita il discendente classe base->classe. Forse questo dato(classe Class: public CBase) dovrebbe essere spiegato all'inizio della sezione, perché me ne sono accorto dopo.

4) non ho trovato:Fig.6. La visibilità della funzione "extra" (freccia rossa) è determinata dal tipo di puntatore con cui è caricata la classe. Questo esempio si trova in appendice nel file OOP_sDefaultVirtual_1.mq5.

5) Non ho trovato una chiara indicazione di cosa sia una libreria. Apparentemente, un modo per memorizzare le classi delle funzioni? Cioè, simile al file di inclusione, solo che il file di inclusione è memorizzato come sorgente e la libreria come una dll compilata?

Grazie mille per l'articolo! Mi ha fatto particolarmente piacere la presentazione coerente del materiale.

1. Sì.

2. C'è un esempio nella sezione "Array di oggetti", in realtà l'intera sezione è un esempio con una descrizione.

3. È considerato nella sezione "Utilizzo dell'OOP per modificare la logica di funzionamento del programma".

4. La dicitura "Questo esempio si trova in appendice nel file..." significa che il file contiene un esempio per la sezione indicata dall'intestazione della sezione. Ciò non significa che gli esempi riproducano tutto ciò che è scritto nell'articolo. Questi esempi potrebbero non esistere affatto, tutto è scritto nell'articolo. Ma gli esempi ci sono, potete prenderli come base e sperimentare. L'articolo è primario, gli esempi sono secondari.

5. Уже давно указано: http://ru.wikipedia.org/wiki/%C1%E8%E1%EB%E8%EE%F2%E5%EA%E0_(%EF%F0%EE%E3%F0%E0%EC%EC%E8%F0%EE%E2%E0%ED%E8%E5)

[[Eliminato]]

grazie. buon articolo.

[[Eliminato]]

Articolo molto interessante, scritto in un linguaggio competente e "accessibile".

Grazie all'autore.

[Heinz Traub]

Grazie amico. Questo articolo mi ha aiutato molto. Stavo migrando il mio EA verso l'OOP e avevo un problema particolare con gli array di classi. I puntatori dinamici sono spiegati in modo chiaro e perfetto. Grazie ancora.

[Марков Виталий]

Articolo molto ben scritto! Finalmente l'ho capito grazie all'autore.

[wulidancing]

Ho due esempi di codice basati/copiati da questo articolo. Entrambi creano un array di puntatori a una classe e poi li cancellano all'uscita. Tuttavia, uno esce con una perdita di memoria e l'altro esce senza una perdita di memoria. L'unica differenza è che il secondo esempio ha l'"Alert" nel distruttore commentato. Quando l'alert nel distruttore viene rimosso, si verifica una perdita di memoria. Questo è molto strano. Qualcuno può spiegarlo?? Per favore, aiutatemi, questo mi sta facendo impazzire.

Alla fine degli esempi di codice di questo articolo ho incluso un esempio estremamente semplice di codice che ho scritto e che presenta anch'esso una perdita di memoria. Ancora una volta, perché???? Non c'è nulla di complicato in questo esempio finale di codice...

---

Questo codice funziona senza perdite di memoria:

class CName
  {
private:
   int               m_arg; // Variabile per l'istanza
public:
                     CName(int aArg)
     { // Costruttore
      m_arg=aArg;
      //Alert("Costruttore "+IntegerToString(m_arg));
     }
                    ~CName()
     { // Distruttore
      Alert("Destructor "+IntegerToString(m_arg));
     }
  };
//---
CName *cname[]; // Array

void OnInit()
  {
// Preparare l'array per caricare dieci istanze della classe
   ArrayResize(cname,10);

   for(int i=0;i<10;i++)
     { // Caricare le istanze
      cname[i]=new CName(i);
     }
  }
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   for(int i=0;i<10;i++)
     { // Alla fine scarica tutte le istanze dalla memoria
      delete(cname[i]);
     }
}

Messaggi dal log dell'esperto, si noti che non c'è alcuna perdita di memoria:

PI 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 0

KP 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 1

JG 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 2

IT 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 3

LF 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 4

OM 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 5

FD 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 6

IK 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 7

HS 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 8

CJ 0 OOP_sConstDestr_2 (EURUSD,M1) 13:57:59 Distruttore 9

Questo codice esce CON una perdita di memoria!!!! Perché????????? L'unica differenza è il commento di 'Alert' nel distruttore...

class CName
     {
private:
   int               m_arg; // Variabile per l'istanza
public:
                     CName(int aArg)
     { // Costruttore
      m_arg=aArg;
      //Alert("Costruttore "+IntegerToString(m_arg));
     }
                    ~CName()
     { // Distruttore
      //Alert("Distruttore "+IntegerToString(m_arg));
     }
  };
//---

CName *cname[]; // Array

void OnInit()
  {
// Preparare l'array per caricare dieci istanze della classe
   ArrayResize(cname,10);

   for(int i=0;i<10;i++)
     { // Caricare le istanze
      cname[i]=new CName(i);
     }
  }

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   for(int i=0;i<10;i++)
     { // Alla fine scarica tutte le istanze dalla memoria
      delete(cname[i]);
     }
}

Messaggi dal log dell'esperto, notare la perdita di memoria:

FM 1 OOP_sConstDestr_2 (EURUSD,M1) 13:51:19 10 oggetti non cancellati rimasti

EG 1 OOP_sConstDestr_2 (EURUSD,M1) 13:51:19 Restano 10 oggetti di tipo CName

GO 1 OOP_sConstDestr_2 (EURUSD,M1) 13:51:19 200 byte di memoria persa

Esempio finale , il mio codice, molto semplice ma che esce con una perdita di memoria....

class CCandleStick
{
public:
   CCandleStick() { };
  ~CCandleStick() { };
};

CCandleStick *cCandleArray[];

//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'esperto|
//+------------------------------------------------------------------+
void OnInit()
  {
   ArrayResize(cCandleArray, 10);
   for (int i = 0; i < 10; i++) {
      cCandleArray[i] = new CCandleStick();
   }   
  }
//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'esperto|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   for (int i = 0; i < 10; i++) {
      delete(cCandleArray[i]);
   }   
   Print("Last Error- ", GetLastError(), "   Current time: ", TimeCurrent());
  }

Messaggi dal log di expert, si noti la perdita di memoria:

MR 0 tester (EURUSD,M1) 14:07:23 Ultimo errore - 0 Ora attuale: 2013.02.06 23:07:23

FL 1 tester (EURUSD,M1) 14:07:23 10 oggetti non cancellati rimasti

KN 1 tester (EURUSD,M1) 14:07:23 10 oggetti di tipo CCandleStick lasciati

JS 1 tester (EURUSD,M1) 14:07:23 160 byte di memoria persa

[Dmitry Fedoseev]

wulidancing:

Ho due esempi...

Ho controllato tutti e tre i varaint. Tutti e tre sono identici. Sono tutti normali. Nessuna dà perdite. In questi esempi, non può essere - abbiamo l'array, in ogni elemento dell'array abbiamo un'istanza, quando finiamo cancelliamo tutti gli oggetti. Gli oggetti non creano copie di se stessi, non si può non cancellare qualcosa. Se l'oggetto crea una copia di se stesso, allora possiamo avere difficoltà con la cancellazione, è molto facile perdere qualcosa. Mostrare le varianti che hanno realmente delle perdite.

Utilizzare il pulsante SRC per inserire il codice (meglio - allegare i file).

Scusate per il mio inglese:)

[khai hoan nguyen]

L'OOP è un linguaggio di programmazione moderno, ma per comprenderlo e scrivere codice abbiamo bisogno di molto tempo e impegno. Grazie buon articolo

[wulidancing]

Integer:

Ho controllato tutti e tre i varaint. Tutte e tre sono identiche. Sono tutte normali. Nessuna dà delle perdite. In questi esempi, non può essere - abbiamo l'array, in ogni elemento dell'array abbiamo un'istanza, quando finiamo cancelliamo tutti gli oggetti. Gli oggetti non creano copie di se stessi, non si può non cancellare qualcosa. Se l'oggetto crea una copia di se stesso, allora possiamo avere difficoltà con la cancellazione, è molto facile perdere qualcosa. Mostrare le varianti che hanno realmente delle perdite.

Utilizzare il pulsante SRC per inserire il codice (meglio - allegare i file).

Scusate per il mio inglese:)

Grazie mille per aver trovato il tempo di rispondere. Non sono sicuro che tu abbia visto la mia domanda successiva. Era in un commento separato che probabilmente è stato cancellato perché non ho molta dimestichezza con questo forum. Comunque, ho provato ad eseguire tutti e tre gli esempi su un vecchio computer con una vecchia versione di MetaTrader. Nella vecchia versione tutti e tre sembravano funzionare bene. Non ha generato un errore di 'memory leak' nel log di expert, credo fosse la build 560???Credo fosse la build 560, non ricordo, e ho aggiornato la 560 alla nuova build 756. Dopo la nuova build ho gli stessi problemi di memory leak. È possibile che la vecchia build non segnalasse i problemi di memory leak perché non era una funzione? Quale build state usando? Grazie ancora.