Discussion :

[Grasshoper]

Bonjour à toutes et à tous,

Comment faire pour libérer la mémoire d'un tableau de double qui est dans une classe dérivée d'une classe abstraite 'Base' et instanciée suivant cette dernière ? Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Class Animal {
protected :
public :
    virtual int GetPoils() = 0;
};
 
Class Chat:public Animal{
  public: 
    int GetPoils() { return toto[0];}
    Chat(){
        toto = (double *) malloc(2 * sizeof(double));
        toto[0] = 1.0; 
        toto[1] = 2.0;
    }
    ~Chat(free(toto));
  private:
    double * toto;
 
};
 
Class Simulation {
  private:
    Animal * mon_animal;
 
  public:
    int main(void){
      mon_animal = &Chat();
    }
};

Ici, le destructeur de Chat() est bien appelé mais le free(toto) génère un dump core. Si je supprime free(toto); pas de problème, mais je suppose que je génère une fuite mémoire (toto n'étant pas désalloué). Je suppose que c'est lié au fait que Simulation détruit le pointeur 'mon_animal' dans la foulée.

Bien sur il existe la solution d'utiliser un std::vector mais si on se réfère à ce problème en particulier, il faudrait que j'appelle le destructeur de la classe dérivée avant qu'il ne soit appelé par défaut lors de la destruction de la classe l'utilisant (provoquant alors une fuite mémoire) ? je ne suis pas sur de comprendre l'origine du problème.

Merci pour votre aide!

[foetus]

1. En C++, ne jamais utiliser malloc - realloc free (ou seulement en cas de force majeur, justement parce que, par exemple, realloc n'existe pas en C++)
2. En C++, il faut utiliser le couple new delete. Je te laisse chercher mais il y a 2 delete et cette question revient souvent dans les tests pour noobs des recruteurs
3. En C++, le destructeur peut être virtuel. Je te laisse chercher

[Grasshoper]

1. Bien recu!
2. Pour l'instant je ne vois pas (je vais creuser, probablement un delete de mon_animal (après un new *) et un delete de toto?)
3. Il suffirait d'écrire virtual ~Animal{free(toto)}; dans la classe abstraite après avoir mis toto comme membre de Animal? Mais comment faire pour les classes dérivées qui ne possède pas toto en membre? La vérité doit être ailleurs Mulder...

Je ne cherche pas à me faire recruter (ou en tout cas je doute d'être débauché par des boites info! ).

[foetus]

2. Pour l'instant je ne vois pas

delete[]

Mais comment faire pour les classes dérivées qui ne possède pas toto en membre? La vérité doit être ailleurs Mulder...

Je ne comprends pas le truc
Si à un moment tu as mis un membre dans une classe, toutes les classes dérivées vont l'avoir, même en héritage privé.

Et justement le destructeur virtuel permet d'appeler les destructeurs dans le sens inverse des constructeurs, et non pas seulement le destructeur de la classe mère.
Dans un autre sens, il faut bien qu'il y ait ce système, sinon tu ne pourrais jamais ajouter de pointeurs dans les classes dérivées

[Grasshoper]

J'essaye de comprendre: sur l'exemple que je donne le free(toto) me fait un core dump. Je constate que le bon destructeur est appelé (celui de la classe fille donc) mais pourquoi est-ce que ca ne marche pas?
Commet tu le suggères il doit me manquait un delete quelque part, le delete[] est celui de free(toto) et l'autre devrait être un delete mon_Animal ?

Bien sur je suis d'accord avec ce que tu dis: le fait que les classes dérivées vont aussi avoir le membre de la classe mère, mais dans mon exemple je pensais plutôt à une autre classe Oiseau::Animal() qui ne posséderait pas le membre toto.

[Bousk]

mon_animal = &Chat(); je crois que tu tiens pas loin de la palme du pointeur le plus daubé au monde. Un problème sur le free toto est un moindre mal à ce stade.
Où donc as-tu vu cette syntaxe pour avoir un pointeur de chat dans un animal ? Et tu peux jeter cette source dans la foulée.

Bien sur il existe la solution d'utiliser un std::vector mais si on se réfère à ce problème en particulier, il faudrait que j'appelle le destructeur de la classe dérivée avant qu'il ne soit appelé par défaut lors de la destruction de la classe l'utilisant (provoquant alors une fuite mémoire) ? je ne suis pas sur de comprendre l'origine du problème.

Qu'est-ce donc que ce charabia ?
Ton problème a quoi de particulier au juste ?
vector sert aux collections, malloc devrait resté au C, et la première chose à savoir quand on espère faire de l'héritage c'est virtual.

[Grasshoper]

Merci pour ton retour et tes commentaires, pour la syntaxe je me suis inspiré de:
http://www.cplusplus.com/doc/tutorial/polymorphism/

J'ai bien une classe abstraite et ai donc remplacé ce pointeur maudit par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
  public:
    int main(void){
      mon_animal = new Chat();
    }

mais ici c'est le destructeur de la classe de base Animal() qui est appelé, donc je ne libère pas toto().
Edit: Ok j'ai pigé le destructeur peut être virtuel! merci

[foetus]

Je te réponds sur le delete puisque tu n'as pas réagi

En C++, si tu veux créer 1 seul objet de type XXX, tu vas utiliser le couple new delete.
Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
XXX* one_XXX = new XXX(/*params*/);
// or XXX* one_XXX = new XXX; - default constructor
 
// ...
 
delete one_XXX;

Par contre si tu veux 1 tableau d'objets de type XXX, tu vas utiliser le couple new delete[].
Exemple avec un tableau de 16 éléments :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
XXX* one_XXX = new XXX[16];
 
// ...
 
delete[] one_XXX;

[Médinoc]

Pourquoi utiliser new et delete quand on peut utiliser vector et unique_ptr?

[Grasshoper]

Ok, merci, oui j'avais bien saisit pour le couple new delete[], ce que j'avais mal compris c'est que le destructeur peut être virtuel également,
maintenant ca fonctionne très bien, c'est juste que l'appel à la vtable est affreusement lent (je fais beaucoup de simulations et grosso modo je prends 43% de temps en plus dans la figure, mais bon il faudra que je teste avec un bon compilateur, je suis sur une vieille charrette à l'heure actuelle).
merci encore!

[Bousk]

virtual est un moyen parmi d'autres de faire des l'objet mais pas le seul. CRTP en est un autre. Si les perfs sont un problème il faudrait poster plus de code et définir ton vrai objectif. Perdre 43% de perf en ajoutant une vtable, j'en doute.