Discussion :

[Stobbyo]

Bonjour à tous,

J'ai pas mal cherché sur internet, mais n'ai rien trouvé de très clair à ce sujet.

Code :

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

1
2
int * a = 0; 
a = new int;

Je sais que si l'allocation de la mémoire échoue, new renverra une exception de type std::bad_alloc. Mais si c'est le cas, quelle sera la valeur du pointeur ?

J'ai cru comprendre qu'il serait du type "bad ptr".

Puis-je faire un delete sur un tel pointeur ?

Je me pose la question parce que j'ai fait un petit "système", qui gére la création de modules, au début du programme, dont voici le code :

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
class Application;
 
template <class C>
class Module //: Uncopyable
{
    friend class Application;
 
private :
 
    static C * the_instance;
 
    static void Construct( void )
    {
        the_instance = new C;
    }
 
    static void Destruct( void )
    {
        delete the_instance;
 
        // juste au cas où ...
        the_instance = 0;
    }
 
protected :
 
    Module( void )
    { }
 
    ~Module( void )
    { }
 
public :
 
    static C& GetInstance( void )
    {
        return (*the_instance) ;
    }
 
};
 
template <class C>  C * Module<C>::the_instance = 0;
 
 
class Renderer : Module<Renderer>
{
    friend class Module<Renderer>;
 
    // code sans importance ...
};
 
class Application
{
private :
 
    Application( void )
    { }
 
    void ConstructModules( void )
    {
        Module<Renderer>::Construct();
        // etc...
    }
 
public :
 
    ~Application( void )
    {
        // etc...
        Module<Renderer>::Destruct();
    }
 
    static void Initialize( void ) // sensé être appelée une seule fois :)
    {
        static Application instance;
 
        try
        {
            instance.ConstructModules();
        }
        catch( std::bad_alloc )
        {
            throw std::runtime_error("Failed to allocate memory...");
        }
    }
};
 
int main( void )
{
    try
    {
        Application::Initialize();
    }
    catch( std::exception )
    {
        return 1; // appel du destructeur de application
    }
 
    Module<Renderer>::GetInstance().Render();
 
    return 0;
}

Désolé, ça fait un peu beaucoup de "code", pour pas grand chose.
Mais, si new échoue, et que le destructeur de la classe Application, est appelé. Que va t-il se passer pour le pointeur sur lequel new a échoué ?

Je sais que je pourrais utiliser la version de new qui n'envoie pas d'exceptions.

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <new> 
 
int * a = new(std::nothrow) int;
 
if( !a )
{
    return false;
}
 
return true;

Mais je préférerais, utiliser le mécanisme d'exceptions.

Merci pour votre aide,

[Flob90]

Bonsoir,

Dans ton cas absolument rien, ca fera juste un delete sur un pointeur nul.

Ton instruction "the_instance = new C;" n'est pas atomique, (écrire C() serait d'ailleurs un peu mieux, tu assures ainsi une initialisation pas defaut quelque soit le type C), elle se décompose en plusieurs instructions :
- new C()
- affectation du retour de new à the_instance
(ces 2 opérations ne sont pas non plus nécessairement atomiques).

Si new C() lance une exception il n'y a pas de retour à la fonction new, le "flux" d'instructions est coupé et reprend au bloc catch le plus "proche". Ainsi la valeur de the_instance est toujours 0, et finalement lors de la destruction de l'objet statique de type Application, le destructeur appel Destruct qui ne va faire qu'un delete sur un pointeur nul.

PS: Les singleton c'est assez laid et sans grand interet ... (cf l'article de Emmanuel Deloget sur son blog par exemple).

[Stobbyo]

Bonsoir Flob90,

Understood.

En ce qui concerne le Singleton, j'avoue avoir encore un peu de mal.
Je voulais utiliser cette méthode pour construire tous les modules nécessaires au programme, à un seul endroit.

Mais bon, là n'est pas le sujet

Merci en tout cas,