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.