Discussion :

[MicBeastKiller]

Bonjour,

je suis face à un question que je n'arrive à répondre.
Voici le code :

Code C++ :

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
64
65
66
67
68
69
70
71
72
73
74
#include <iostream>
#include <new>
 
class Test
{
    private:
    int * m_nbr;
 
    public:
    Test( void ): m_nbr( 0 )
    {
        m_nbr = new( std::nothrow ) int;
        if( 0 != m_nbr )
            *m_nbr = 0;
    }
    Test( int aNbr ): m_nbr( 0 )
    {
        m_nbr = new( std::nothrow ) int;
        if( 0 != m_nbr )
            *m_nbr = aNbr;
    }
    Test( Test const & aTest ): m_nbr( 0 )
    {
        m_nbr = new( std::nothrow ) int;
        if( 0 != m_nbr )
            *m_nbr = *aTest.m_nbr;
    }
    ~Test( void )
    {
        std::cout << "delete" << std::endl; // rajouté pour indiquer que les instances sont bien supprimées.
        delete( m_nbr );
    }
    int getNbr( void ) const
    {
        if( 0 == m_nbr )
            return( 0 );
        else
            return( *m_nbr );
    }
    int * getPtNbr( void ) const
    {
        return( m_nbr );
    }
    void print( void )
    {
        std::cout << "(" << m_nbr << "," << *m_nbr << ")";
    }
};
 
int main( void )
{
    int * thePtNbr( 0 );
    {
        Test theTest1;
        std::cout << "Test1: ";
        theTest1.print();
        std::cout << std::endl;
 
        thePtNbr = theTest1.getPtNbr();
 
        Test theTest2( 2 );
        std::cout << "Test2: ";
        theTest2.print();
        std::cout << std::endl;
 
        theTest1 = theTest2;
        std::cout << "Test1: ";
        theTest1.print();
        std::cout << std::endl;
    }
    std::cout << "(" << thePtNbr << "," << *thePtNbr << ")" << std::endl;
 
    return( 0 );
}

Je ne comprends pas pourquoi l'affection "theTest1 = theTest2;" fonctionne alors que l'opérateur "=" n'est pas définie pour cette classe Test. Cela provoque de surcroit une fuite mémoire (comme le montre la ligne avant le return du main). Par ailleurs, cela ne pose aucun problème lors de la destruction de "theTest2" de détruire "m_nbr" qui a normalement été détruit lors de la destruction de "theTest1".

J'ai par ailleurs essayé en ne mettant uniquement le constructeur par défaut de la classe Test : "Test( void )", mais j'ai le même résultat.
Pour informations, je compile avec MinGW, g++ version 4.7.2.

Merci beaucoup pour vos indications.

[Ehonn]

Bonjour
Tout est expliqué dans la FAQ
http://cpp.developpez.com/faq/cpp/?p...GE_affectation

La seconde chose à savoir est que le compilateur génère un opérateur d'affectation automatiquement si vous ne le faites pas, et que celui-ci sera suffisant dans la plupart des cas. Vous pouvez donc parfois tout simplement éviter de l'écrire.

Il faudra écrire explicitement un opérateur d'affectation dès lors qu'une simple affectation membre à membre des données de votre classe n'est plus suffisante, par exemple si elle gère une ressource (un pointeur brut, une connexion à une base de données, une texture en mémoire vidéo, ...).

Il existe également des situations où l'on ne veut pas de l'opérateur d'affectation généré par le compilateur, notamment pour les classes dont les instances ne doivent pas être copiées (une base de données, un singleton, etc.). Dans ce cas, une bonne pratique est d'en interdire l'utilisation en le déclarant privé et en ne le définissant pas (ie. ne pas écrire son corps). Il en va d'ailleurs de même pour le constructeur par copie, les deux allant généralement de paire.

[MicBeastKiller]

Ok, merci de l'information pour l'opérateur d'affectation.
Par contre pour le problème de destructeur ?

[oodini]

Par ailleurs, cela ne pose aucun problème lors de la destruction de "theTest2" de détruire "m_nbr" qui a normalement été détruit lors de la destruction de "theTest1".

theTest1 et theTest2 ont chacun leur membre m_nbr. Chacun détruit donc le sien.

[MicBeastKiller]

theTest1 et theTest2 ont chacun leur membre m_nbr. Chacun détruit donc le sien.

Il me semble, et c'est ce que l'on voit à l'affichage, qu'après l'affectation, "theTest1" et "theTest2" partagent la même adresse pour "m_nbr". Peut-on donc faire un delete sur une adresse qui a déjà eu un delete ?

[Médinoc]

Non on ne peut pas, c'est un comportement indéfini.
Voilà pourquoi dans ton code il est indispensable de soit implémenter l'opérateur = , soit l'interdire.

PS: Ta fonction membre print() devrait être déclarée const, vu qu'elle ne modifie pas l'objet.
PPS: Par contre, getPtNbr() ne devrait peut-être pas l'être. Ceci peut être plus approprié:

Code :

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

1
2
3
4
5
6
7
8
    int const * getPtNbr( void ) const
    {
        return( m_nbr );
    }
    int       * getPtNbr( void )
    {
        return( m_nbr );
    }

[MicBeastKiller]

Merci beaucoup pour les informations.

[Ehonn]

Selon ce que tu veux faire, tu peux peut-être utiliser std::shared_ptr (existe aussi dans boost) :
- http://www.cplusplus.com/reference/m...?kw=shared_ptr
- http://en.cppreference.com/w/cpp/memory/shared_ptr
- http://www.boost.org/doc/libs/1_52_0...shared_ptr.htm

L'opérateur = par défaut devrait être correct et tu n'as pas besoin de delete car le dernier shared_ptr détruira lui-même l'allocation dynamique.

[MicBeastKiller]

Ok, merci de l'info.