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,