[C++] Distruttore Classe Ereditata

[MegaAlchimista]

Salve a tutti, sto facendo dei test ma la situazione non mi è molto chiara.
Supponiamo di avere

class Base{
public:
     Base() {v = new double;}
     virtual ~Base() {delete v;}
      void unMetodo() =0;
     //più costruttore di copia, operatore assegnamento, eccetera
protected:
     doulbe* v;
}

class Ereditata: public Base{
public:
     Ereditata() : Base(){}
     ~Ereditata() {  //non ci scrivo niente }
     double nuovoMetodo(int i) const;
}

Da quello che ho capito e che mi risulta effettivamente dai test quando chiamo il distruttore della classe figlia viene chiamato anche quello della classe padre, quindi se per caso io scrivessi

~Ereditata() {  delete v;}

lo cancellerei due volte?
Non riesco a trovare questa informazione espressa in modo esplicito da alcuna parte, la cosa che mi inghippa è il "virtual", in teoria se metto virtual nella classe padre, il distruttore della classe padre non dovrebbe essere invocato giusto? O vengono comunque invocati entrambi?

Se nella classe figlia non inserisco puntatori fra le proprietà, e tolgo il virtual dal distruttore della classe padre, *v verrà cancellato perchè verrà invocato automaticamente ~Base() ?

[Xaratroom]

Non è compito della classe figlia, quello di deallocare le risorse gestite/allocate dalla classe padre.
delete non cancella ma dealloca... in particolare dopo aver deallocato non setta a null il puntatore, pertanto se tu facessi:

int* ptr = new int;
delete ptr;
delete ptr;

Genereresti un runtime error

http://www.cplusplus.com/reference/s...ator%20delete/

EDIT Il seguente codice non genera errore (perché delete su puntatore NULL non esegue nessuna operazione):

int* ptr = new int;
delete ptr;
ptr = NULL;
delete ptr;

[MegaAlchimista]

scusa ho sbagliato termine.
Quindi mi confermi che anche se è protected, quindi la classe figlia può accedervi, se il decostruttore della classe figlia è vuoto, viene automaticamente chiamato anche il decostruttore della classe padre ed il puntatore viene deallocato?
Ma in teoria, se io definisco il metodo virtual, quello di Base non dovrebbe essere chiamato.

Cioè se io ho:

class Base{
public:
     Base() {v = new double;}
     virtual ~Base() {delete v;}
      virtual int unMetodo() const {return 0;}
protected:
     doulbe* v;
}

class Ereditata: public Base{
public:
     Ereditata() : Base(){}
     ~Ereditata() {}
      int unMetodo() const {return 1;};
}

int main(...)
{
Base* b = new Base();
Base* e = new Ereditata();
int x = b->unMetodo();
int y = e->unMetodo();
}

x vale 0 ed y vale 1, cioè il metodo della classe base non viene chiamato, in quanto virtuale. Il distruttore invece fa eccezione e viene chiamato comunque? In questo caso, l'oggetto e dealloca double* v?

[Xaratroom]

No, assolutamente:

#include <iostream>
using namespace std;

class Base {
	public:
		virtual ~Base() { cout<<"Distruttore di Base\n"; }
};


class Derived : public Base {
	public:
		~Derived() { cout<<"Distruttore di Derived\n"; }
};

int main() {
	Derived* d = new Derived();
	delete d;
	return 0;
}

[MegaAlchimista]

facendo come hai suggerito, chiamando:

    Base* v = new Derived();
    delete v;

mi stampa:
"distruttore di Derivata"
"distruttore di Base"

in pratica li chiama entrambi.
Idem scrivendo:

    Derived* v = new Derived();
    delete v;

(il distruttore di base è virtual)

EDIT:

Mettendo il costruttore non virtuale invece ottengo risultati diversi.

    Base* v = new Derived();
    delete v;

chiama solo il distruttore di Base.
Questo invece

    Derived* v = new Derived();
    delete v;

li chiama entrambi

[Xaratroom]

E quale sarebbe il problema?
Stai programmando ad oggetti e, come ti dicevo poco fa, non è compito della classe derivata quello di deallocare le risorse della classe base.

[MegaAlchimista]

ok. Non ho nessun problema infatti volevo solo capire bene.
Ora sono sicuro di ciò che faccio.
Grazie degli hint

[MItaly]

Tip: se ti aspetti che da una classe erediterà qualcuno, imposta sempre il distruttore virtuale. In questa maniera verranno automaticamente richiamati prima il distruttore della classe derivata, poi quello della classe base, analogamente a come viene automaticamente richiamato prima il costruttore della classe base, poi quello della classe derivata. Ogni distruttore si occupa della "sua" roba - quello della classe base delle risorse allocate dalla classe base, quello della derivata delle risorse della classe derivata.

[shodan]

E il perché è spiegato qui:
http://www.eptacom.net/pubblicazioni/pub_it/iso_8.html