Discussion :

[katous]

je voudrais verifier que je n'ai auceune fuite de memoire dans mon programme qui ressemble a ca:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
 
 
#include<iostream>
#include<memory>
 
using namespace std;
 
 
 
 
 
class A{
public:
  A() : pa(new int){}
  ~A() {delete pa;}
 
  virtual void fn() {cout << "Class A" << endl;}
 
private:
  int* pa;
}; 
 
 
 
class B : public A{
public:
  B() : pb(new int){}
  ~B() {delete pb;}
 
  void fn() {cout << "Class B" << endl;}
 
private:
  int* pb;
};
 
 
class C :public A{
public:
  C() : pc(new int){}
  ~C() {delete pc;}
 
  void fn() {cout << "Class C" << endl;}
 
private:
  int* pc;
};
 
 
 
int main (){
 
auto_ptr<A> a1(new B());
C c;
A& a2 = c;
a1->fn();
a2.fn();
 
 
system("pause");
return 0;
 
}

le destructeur de A n'est pas virtuel. lorsque je cree a1 j'instancie un objet B derive de A.

auto_ptr s'occupe de liberer la memoire lorsque a1 n'est plus utilise. est ce que cela marche toujours lorsque a1 est instancie comme objet de type B derive de A. faut-il que je declare le destructeur de A virtuel.

en une question . est ce que mon code a des fuite de memoire?



merci.

katous

[Assiobal]

Il existe des API et des logiciels qui répondront mieux à ta question, et ce, même sur des programmes beaucoup plus complexes.

fuite mémoire ou memory leak sur google. (J'avoue, j'ai eu la flemme de chercher).

[Laurent Gomila]

Oui, tu as une fuite mémoire car le destructeur de B ne sera pas appelé (celui de C non plus). Et donc oui, la solution est de déclarer celui de A virtuel

Et attention avec les auto_ptr, c'est très vicieux.

[katous]

si je comprend bien auto_ptr liberera seulement la memoire de a1 en tant qu'objet de type A.

si je declare le destructeur de A virtuel les destructeurs de B et C (objet derives) seront appele lorsque le destructeur de A sera appele



katous

[Jan Rendek]

Tu as surtout du code qui a un comportement indéfini.
Détruire un objet qui a pour type statique une classe de base et pour type dynamique une classe dérivée alors que le destructeur de la classe de base n'est pas virtuel implique un comportement indéfini.
Au mieux, tu as une fuite de mémoire car le destructeur de la classe dérivée n'est pas appelée.
Au pire, tu peux avoir n'importe quoi, mais surement un plantage.

En revanche si tu remplaces la ligne :

Code :

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

auto_ptr<A> a1(new B());

par :

Code :

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

auto_ptr<B> a1(new B());

alors, il n'y a plus de problème.

[Laurent Gomila]

si je comprend bien auto_ptr liberera seulement la memoire de a1 en tant qu'objet de type A.

si je declare le destructeur de A virtuel les destructeurs de B et C (objet derives) seront appele lorsque le destructeur de A sera appele

Tout à fait.

Tu as surtout du code qui a un comportement indéfini

C'est pas si sûr, à mon avis le comportement est bien défini : seul le destructeur de A sera appelé, et pas ceux des classes dérivées.

[Jan Rendek]

@Loulou24
En pratique, tu as raison. En théorie, ce cas est recensé comme menant à un comportement indéfini.