Discussion :

[MABB]

Bonjour

Dans mon programme je place des breakpoints pour vérifier des valeurs, voir si certaines fonctions s'éxécutent , etc...

Seulement, il m'arrive d'arrêter par SHIFT+F5 le débuggeur.

Or les destructeurs des classes ne sont jamais appelées. Est-ce normal ?
Comme j'ai des pointeurs un peu partout, je me demande si interrompre ainsi le programme ne fait pas perdre de la mémoire.

Bien sûr je n'utilise pas partout des pointeurs intelligents. D'ailleurs est-ce qu'en utilisant des pointeurs intelligents, je passerai dans les destructeurs ?

Merci pour vos réponses.

[Noxen]

Si tu utilises des variables automatiques, il n'y a pas de raison que ça ne passe pas par le constructeur. Si tu utilises des pointeurs, n'oublie pas le delete.

Pour les pointeurs intelligents, je ne connais pas assez pour en parler.

Pour la fuite mémoire, en théorie ça devrait effectivement bloquer une partie de la mémoire. Mais il me semble que quand on lance le programme, l'OS lui réserve une plage mémoire, qu'il libère ensuite quand le programme s'arrête, et que ça devrait donc annuler la perte de mémoire ; mais là je n'en suis pas certain, il faudrait quelqu'un qui s'y connait mieux au niveau architecture OS/hardware pour confirmer ou infirmer.

[3DArchi]

Question bête: Tes destructeurs sont virtuels?

[r0d]

Bonjour,

l'utilisation des pointeurs intelligents peut effectivement t'assurer que le destructeur sera bien appelé.

Cela dit, sous visual, quand tu interromp l'execution (shift+F5), le programme ne va pas être fermé proprement. Il va simplement vider la mémoire comme un bourrin. Autrement dit, il n'appelera pas tes destructeurs (ni aucune autre partie de ton code d'ailleurs).

Sinon, comme il a été dit plus haut, si tu n'utilises pas systématiquement des pointeurs intelligent: un new => un (et un seul) delete.

Et enfin, il est toujours bon de le rappeller: en c++, on utilise des pointeurs quand on ne peut pas faire autrement. Aujourd'hui, je n'utilise quasiment plus de pointeurs dans mon code. Et quand je suis obligé, de plus en plus rarement, j'utilise des pointeurs intelligents (perso, j'ai opté pour ceux de boost).

[MABB]

Merci pour vos réponses qui me posent plus de questions.

Variables automatiques ? je ne sais pas ce que c'est.

J'ai besoin de pointeurs car je crée certaines instances de classes qui n'ont pas raison de durer trop longtemps.

Je vais m'inspirer du tutorial sur les pointeurs intelligents qui vient de paraître. En utilisant Boost aussi.

Mes destructeurs sont bien en virtuels.

Cela dit, sous visual, quand tu interromp l'execution (shift+F5), le programme ne va pas être fermé proprement. Il va simplement vider la mémoire comme un bourrin. Autrement dit, il n'appelera pas tes destructeurs (ni aucune autre partie de ton code d'ailleurs).

Donc même avec des pointeurs intelligents il ne passera pas dans les destructeurs si je quitte comme un bourrin. Faut que je teste.

[r0d]

J'ai besoin de pointeurs car je crée certaines instances de classes qui n'ont pas raison de durer trop longtemps.

Je ne vois pas le rapport. Par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
class MonObjet {
//... code de MonObjet
};
 
main(){
   {
      MonObjet o; // creation de o, une instance de MonObjet
   } // destruction de o car on sort de sa portée.
}

Difficile de "faire durer moins longtemps" un objet (une ligne. Bien que dans la vraie vie, cette instance ne sera certainement jamais construit car le compilo voit qu'il ne sert à rien) et pourtant ce n'est pas un pointeur. Enfin je crois que je n'ai pas compris ce que tu voulais dire.

Je vais m'inspirer du tutorial sur les pointeurs intelligents qui vient de paraître. En utilisant Boost aussi.

Excellente initiative

Donc même avec des pointeurs intelligents il ne passera pas dans les destructeurs si je quitte comme un bourrin.

Effectivement.

Faut que je teste.

Excellente initiative

[Noxen]

Variables automatiques ? je ne sais pas ce que c'est.

C'est simplement comme ça qu'on appelle les variables "ordinaires", créées sur la pile, par opposition à celles créées dynamiquement avec pointeur/allocation mémoire. Elles sont crées dans un bloc, et sont automatiquement détruites à la sortie du bloc.

J'ai besoin de pointeurs car je crée certaines instances de classes qui n'ont pas raison de durer trop longtemps.

Justement, si une variable ne doit durer que l'espace d'un bloc, autant utiliser simplement une variable automatique, l'intérêt des pointeurs et de l'allocation dynamique est justement de permettre à une variable d'exister jusqu'à ce qu'elle soit explicitement détruite par le programmeur.

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
 
#include <string>
using namespace std;
 
string f1()
{
    string s("f1"); // Variable automatique détruite à la fin de la fonction
    return s; // C'est une copie qui est renvoyée, la variable elle même est détruite
}
 
string& f2()
{
    string s("f2"); // Variable automatique détruite à la fin de la fonction
    return s; // Un excellent moyen de se faire beaucoup de mal, puisqu'on renvoie une référence sur une variable qui n'existera plus
	// Note : VS fait un warning
}
 
string* f3()
{
    string* s = new string("f3"); // Une variable dynamique, qui survivra à sa fonction créatrice
    return s; // On renvoie l'adresse
}
 
 
int main()
{
    string str("main"); // Variable automatique détruite à la fin du main
 
    {
        string str2("bloc"); // variable automatique, détruite à la fin du bloc
    }
 
    if(1 == 1)
    {
        string str2("if"); // variable automatique, détruite à la fin du if
    }
 
    string * pstr = 0; // Toujours initialiser à null
 
    str = f1(); // Tout va bien
    str = "change1"; // Idem
 
    str = f2(); // Devrait marcher, copie de la variable renvoyée, avant sa destruction
    str = "change2"; // Tout va bien
 
    pstr = &f1(); // Attention les dégâts, récupération de la copie temporaire
    (*pstr) = "change3"; // Vous êtes mort
 
    pstr = &f2(); // Attention les dégâts, récupération d'une variable en sursis
    (*pstr) = "change4"; // Badaboom
 
    pstr = f3(); // Ok!
    (*pstr) = "change4"; // Toujours bon
 
    delete pstr; // Ne pas oublier !!
 
    return 0;
}

Ce code compile, mais attention à l'exécution

[loufoque]

string * pstr = 0; // Toujours initialiser à null

Mauvaise idée, mieux vaut toujours initialiser à une vraie valeur plutôt qu'à une valeur nulle.

delete pstr; // Ne pas oublier !!

Mauvaise idée.
Un delete ne devrait apparaître que dans un destructeur. Le code donné n'est d'ailleurs pas du tout exception-safe, i.e. il va y avoir des fuites quand une exception sera levée.

[Noxen]

C'est un code très très très mauvais, le but ici était plutôt d'exposer les différences entre variable automatique, variable instanciée dynamiquement, et leur durées de vie, ainsi que les problèmes qui sont susceptibles d'apparaître selon ce que l'on utilise.

[Médinoc]

Aucun destructeur n'est appelé quand on tue un processus.

De plus, la norme n'oblige pas non plus à appeler les destructeurs en cas d'exception C++ non-gérée: La fonction terminate() est appelée, c'est tout ce qu'elle demande.