Quelle est la valeur du pointeur si new échoue ?
Bonjour à tous,
J'ai pas mal cherché sur internet, mais n'ai rien trouvé de très clair à ce sujet.
Code:
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:
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:
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,
