[C++]: Costruttori e disttrutori

[robs05]

Salve,

se ho questa situazione:

tre classi:

1)

Classe classe_uno
{
    private:
         classe_due *array;

    public:
          classe_uno(){ array = new classe_due[10]; }
          ~classe_uno(){ delete []array; }

          void metodo1()
         { 
          ciclo for che inzializza array
             {
              classe_due *c2 = new classe_due(i)
              array[i] = *c2;
              array[i].metodo2(); //metodo classe 2
             }   
         }
};

2)

Classe classe_due
{
    private:
          int a;
          vector<classe_tre> array2;

    public:

         classe_due(){};
         classe_due(int a){this->a = a;};
         ~classe_due(){};

         void metodo2()
         {
            inserisco alcuni oggetti classe_tre nel vector con push_back
         }
};

3)

Classe classe_tre
{
    private:
        int x;
        int y;

    public:
        classe_tre(){};
        classe_tre(int x, int y){ ... };
        ~classe_tre(){};
};

quindi ho tre classi dove:
Nella prima ci sono oggetti della seconda e nella seconda ci sono oggetti della terza.

adesso se in un main

int main()
{
      classe_uno *var = new classe_uno();
      
      var->metodo1();

     delete var;
}

Con l'istruzione delete[] var distruggo tutti gli oggetti creati?
mi è venuto il dubbio perchè leggendo ho trovato scritto che per deallocare oggetti allocati dinamicamente, ad una new deve corrispondere una delete.

In effetti in questo codice c'è una sola invocazione di delete della classe_uno che dealloca gli oggetti dell'array fomato da classe_due che a loro volta hanno oggetto della classe tre.
In effetti inserendo una frase di uscita per ogni distruttore come:
"distrutto oggetto della classe_x" dove x è uno, due o tre

quando il main arriva a delete var comunque vengono stampate tutte le cout presenti nei rispettivi costruttori.

e' giusta questa deallocazione anche se ad ogni new non corrisponde una delete?

[cionci]

[quote=robs05;25648811]Salve,

se ho questa situazione:

tre classi:

1)

Classe classe_uno
{
    private:
         classe_due *array;

    public:
          classe_uno(){ array = new classe_due[10]; }
          ~classe_uno(){ delete []array; }

          void metodo1()
         { 
          ciclo for che inzializza array
             {
              classe_due *c2 = new classe_due(i)
              array[i] = *c2;
              array[i].metodo2(); //metodo classe 2
             }   
         }
};

[quote=robs05;25648811]
Qui c'è un memory leak grosso come una casa.
Allochi con new e non deallochi la memoria allocata. L'istruzione

array[i] = *c2;

esegue una copia membro a membro della classe *c2 in array[i], che non equivale a mettere *c2 in array[i].
Usa una variabile automatica:

classe_due c2(i);
array[i] = c2;
array[i].metodo2(); //metodo classe 2

In alternativa puoi fare in modo che array sia un vettore di puntatori a classe_due. In tal caso assegni direttamente il puntatore, ma ovviamente li devi deallocare tutti e singolarmente nel distruttore di classe_uno, prima di deallocare array.

[robs05]

Ciao cionci,

ho modificato il mio codice grazie al tuo consiglio....

cmq.... riepilogando al situazione

Classe classe_uno
{
    private:
         classe_due *array;

    public:
          classe_uno(){ array = new classe_due[10]; }
          ~classe_uno(){ delete []array; }

          void metodo1()
         { 
          ciclo for che inzializza array
             {
              classe_due c2(i):
              array[i] = c2;
              array[i].metodo2(); //metodo classe 2
             }   
         }
};

Classe classe_due
{
    private:
          int a;
          vector<classe_tre> array2;

    public:

         classe_due(){};
         classe_due(int a){this->a = a;};
         ~classe_due(){};

         void metodo2()
         {
            classe_tre c3(x,y);
            array2.push_back(c3);
            //inserisco alcuni oggetti classe_tre nel vector con push_back
         }
};

e poi

Classe classe_tre
{
    private:
        int x;
        int y;

    public:
        classe_tre(){};
        classe_tre(int x, int y){ ... };
        ~classe_tre(){};
};

non dovrei più avere memory leak? giusto così?
grazie

[cionci]

Così non ci dovrebbero essere memory leak.