Discussion :

[Krishna]

Bonjour!
J'aimerais instancié des objets qui auraient la faculté de "s'auto-détruire".
J'ai essayé dans dans un petit code de test mais je n'obtiens pas le résultat désiré puisque les objets sont toujours accessibles après leur destruction explicite:

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
/*  Test sur les destructeurs   */
 
#include <iostream>
 
class Test
{
    public:
    Test(int v=0):val(v){}
    virtual ~Test(){std::cout<<"Appel destructeur\n";}
 
    void _val(){std::cout<<"val="<<val<<"\n";}
 
    protected:
    int val;
};
 
int main()
{
    Test t;
    Test t1(1);
    Test t2(2);
 
    /*  Appel de la fonction d'acces    */
    t._val();
    t1._val();
    t2._val();
 
    /*  Appel explicite des destructeurs    */
    t.~Test();
    t1.~Test();
 
    /*  Appel de la fonction d'acces    */
    t._val();
    t1._val();
    t2._val();
 
    return 0;
}

Ce que je cherche à faire est-il possible?Comment?

Merci à tous.

[Krishna]

Euh... désolé j'aurai du lire la faq avant de poster.

[Bakura]

Tu n'as qu'à mettre les lignes entre { }, ainsi dès que tu sors du bloc, la portée de tes variables se termine et les objets sont détruits.

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
int main()
{
 
    {
    Test t;
    Test t1(1);
    Test t2(2);
 
    /*  Appel de la fonction d'acces    */
    t._val();
    t1._val();
    t2._val();
 
    /*  Appel explicite des destructeurs    */
    // t.~Test();
    // t1.~Test();
 
    }
 
    /*  Appel de la fonction d'acces   - IMPOSSIBLE car plsu dans la portée */
    //t._val();
    //t1._val();
    //t2._val();
 
    return 0;
}

Tu veux faire quoi au juste ?

[LittleWhite]

Bonjour,

Premièrement, on appelle jamais un destructeur à la main ( enfin on ne voit jamais de objet.~Objet dans le code ).

Le seul moment on l'on se doit d'appeler un constructeur et un destructeur, c'est lorsque l'on "joue" avec des pointeurs. Et encore on ne le fait pas directement, on passe par 'new' et 'delete'.

De plus, lorsque l'on essaie d'utiliser une variable que l'on a détruit, le comportement du programme est indéterminé ( normalement, il crash tout de suite ). Car certes il a detruit l'objet, mais au final il a juste dit au système, je n'ai plus besoin de cette espace mémoire.
L'objet est toujours là ( du moins très souvent ), mais le système, très rigoureux, va dire, que fais tu, tu essaie d'acceder à de la mémoire qui n'est pas à toi ( et qu'il peut avoir réutiliser pour autre chose entre temps ) d'ou le comportement indeterminé .

[Goten]

Soit dit en passant et pour être tout à fait rigoureux il y'a quand même un cas où on doit appellé explicitement le destructeur . (placement new)