1,當(dāng)operator new無法滿足內(nèi)存需求時,拋出std::bad_alloc.
下面是一個驗(yàn)證的代碼:

Cpp代碼

1. #include <iostream>   
2. #include <stdexcept>   
3. using namespace std ;   
4.   
5. int main ()   
6. {   
7.     try  
8.     {   
9.         int* p=NULL;   
10.         while(1)   
11.             p=new int[10000];   
12.     }catch(std::bad_alloc&)   
13.     {   
14.         cout<<"no enough mem."<<endl;   
15.     }   
16.     return 0 ;   
17. }  

#include <iostream>
#include <stdexcept>
using namespace std ;
int main ()
{
try
{
int* p=NULL;
while(1)
p=new int[10000];
}catch(std::bad_alloc&)
{
cout<<"no enough mem."<<endl;
}
return 0 ;
}

2,C++的一個公約:
當(dāng)operator new無法滿足需求時,它會在拋出exception前先調(diào)用一個專屬的錯誤處理函數(shù).
我們稱之為:new-handler.

3,當(dāng)operator無法滿足內(nèi)存需求時,它會不只一次的調(diào)用new-handler函數(shù);
它會不斷的重復(fù)調(diào)用,直到找到足夠的內(nèi)存.
一個設(shè)計良好的new-handler函數(shù)必須完成下面幾件事:
(1)讓更多內(nèi)存可用.
例如:事先在程序起始處配置一大塊內(nèi)存,然后在new-handler第一次被調(diào)用時釋放之.
(2)配置另外一個new-handler,其手上握有比較多的資源.
(3)卸除new-handler,set_new_handler(NULL)
將不再調(diào)用專屬函數(shù),而直接拋出exception.
(4)拋出exception.
(5)不回返,直接調(diào)用abort()或exit.

Cpp代碼

1. #include <iostream>   
2. #include <stdexcept>   
3. using namespace std ;   
4.   
5. void noMoreMemory()   
6. {   
7.     cout<<"Unable to satify request for memory."<<endl;   
8.     //原則(5):不回返   
9.     abort();//不加,將會是一個死循環(huán).   
10.     //原則(4):也可以通過拋出一個異常   
11.     //throw std::bad_alloc();   
12. }   
13.   
14. int main ()   
15. {   
16.     //typedef void (*new_handler)();  頭文件中已經(jīng)給出   
17.     //設(shè)定自己的專屬錯誤處理函數(shù).   
18.     //返回之前的new_handler   
19.     new_handler old_new_handler=set_new_handler(noMoreMemory);   
20.     //set_new_handler(NULL); //卸除new-handler,拋出異常.   
21.     try  
22.     {   
23.         int* p=NULL;   
24.         while(1)   
25.             p=new int[10000];   
26.     }catch(std::bad_alloc&)   
27.     {   
28.         cout<<"no more memory."<<endl;   
29.         set_new_handler(old_new_handler);   
30.     }   
31.     set_new_handler(old_new_handler);   
32.     return 0 ;   
33. }  

#include <iostream>
#include <stdexcept>
using namespace std ;
void noMoreMemory()
{
cout<<"Unable to satify request for memory."<<endl;
//原則(5):不回返
abort();//不加,將會是一個死循環(huán).
//原則(4):也可以通過拋出一個異常
//throw std::bad_alloc();
}
int main ()
{
//typedef void (*new_handler)();  頭文件中已經(jīng)給出
//設(shè)定自己的專屬錯誤處理函數(shù).
//返回之前的new_handler
new_handler old_new_handler=set_new_handler(noMoreMemory);
//set_new_handler(NULL); //卸除new-handler,拋出異常.
try
{
int* p=NULL;
while(1)
p=new int[10000];
}catch(std::bad_alloc&)
{
cout<<"no more memory."<<endl;
set_new_handler(old_new_handler);
}
set_new_handler(old_new_handler);
return 0 ;
}

4,設(shè)定類class專屬的new-handler.
一個強(qiáng)大的類模板.

Cpp代碼

1. #include <iostream>   
2. #include <stdexcept>   
3. using namespace std ;   
4.   
5. template<class T>   
6. class NewHandlerSupport   
7. {   
8. public:   
9.     static new_handler set_new_handler(new_handler p);   
10.     static void* operator new(size_t size);   
11.     static void* operator new[](size_t size);   
12. private:   
13.     static new_handler currentHandler;   
14. };   
15.   
16. template<class T>   
17. new_handler NewHandlerSupport<T>::set_new_handler(new_handler p)   
18. {   
19.     new_handler oldHandler=currentHandler;   
20.     currentHandler=p;   
21.     return oldHandler; //返回之前的專屬函數(shù)   
22. }   
23.   
24. template<class T>   
25. void* NewHandlerSupport<T>::operator new(size_t size)   
26. {   
27.     //下面調(diào)用標(biāo)準(zhǔn)的set_new_handler   
28.     new_handler globalHandler=std::set_new_handler(currentHandler);   
29.   
30.     void* memory;   
31.     try  
32.     {   
33.         //使用標(biāo)準(zhǔn)的new.   
34.         memory=::operator new(size);   
35.     }catch(std::bad_alloc)   
36.     {   
37.         std::set_new_handler(globalHandler);   
38.         throw; //繼續(xù)拋出異常   
39.     }   
40.   
41.   
42.     std::set_new_handler(globalHandler); //返回原來的設(shè)置   
43.     return memory; //返回之前的專屬函數(shù)   
44. }   
45.   
46. template<class T>   
47. static void* NewHandlerSupport<T>::operator new[](size_t size)   
48. {   
49.     return operator new(size);   
50. }   
51.   
52. template<class T>   
53. new_handler NewHandlerSupport<T>::currentHandler; //設(shè)置為0   
54.   
55. void noMoreMemory()   
56. {   
57.     cout<<"Unable to satify request for memory."<<endl;   
58.     //abort();   
59.     throw std::bad_alloc();   
60. }   
61.   
62. class X : public NewHandlerSupport<X>   
63. {   
64. };   
65.   
66. int main ()   
67. {   
68.     X::set_new_handler(noMoreMemory);   
69.     try  
70.     {   
71.         X* p=NULL;   
72.         //先調(diào)用專屬函數(shù),然后有專屬函數(shù)拋出異常.   
73.         while(1)   
74.             p=new X[100000];   
75.     }catch(std::bad_alloc&)   
76.     {   
77.         cout<<"no more memory."<<endl;   
78.     }   
79.   
80.     X::set_new_handler(0);   
81.     try  
82.     {   
83.         X* p=NULL;   
84.         //不再調(diào)用專屬函數(shù),直接捕獲異常.   
85.         while(1)   
86.             p=new X[100000];   
87.     }catch(std::bad_alloc&)   
88.     {   
89.         cout<<"no more memory."<<endl;   
90.     }   
91.     return 0 ;   
92. }  

#include <iostream>
#include <stdexcept>
using namespace std ;
template<class T>
class NewHandlerSupport
{
public:
static new_handler set_new_handler(new_handler p);
static void* operator new(size_t size);
static void* operator new[](size_t size);
private:
static new_handler currentHandler;
};
template<class T>
new_handler NewHandlerSupport<T>::set_new_handler(new_handler p)
{
new_handler oldHandler=currentHandler;
currentHandler=p;
return oldHandler; //返回之前的專屬函數(shù)
}
template<class T>
void* NewHandlerSupport<T>::operator new(size_t size)
{
//下面調(diào)用標(biāo)準(zhǔn)的set_new_handler
new_handler globalHandler=std::set_new_handler(currentHandler);
void* memory;
try
{
//使用標(biāo)準(zhǔn)的new.
memory=::operator new(size);
}catch(std::bad_alloc)
{
std::set_new_handler(globalHandler);
throw; //繼續(xù)拋出異常
}
std::set_new_handler(globalHandler); //返回原來的設(shè)置
return memory; //返回之前的專屬函數(shù)
}
template<class T>
static void* NewHandlerSupport<T>::operator new[](size_t size)
{
return operator new(size);
}
template<class T>
new_handler NewHandlerSupport<T>::currentHandler; //設(shè)置為0
void noMoreMemory()
{
cout<<"Unable to satify request for memory."<<endl;
//abort();
throw std::bad_alloc();
}
class X : public NewHandlerSupport<X>
{
};
int main ()
{
X::set_new_handler(noMoreMemory);
try
{
X* p=NULL;
//先調(diào)用專屬函數(shù),然后有專屬函數(shù)拋出異常.
while(1)
p=new X[100000];
}catch(std::bad_alloc&)
{
cout<<"no more memory."<<endl;
}
X::set_new_handler(0);
try
{
X* p=NULL;
//不再調(diào)用專屬函數(shù),直接捕獲異常.
while(1)
p=new X[100000];
}catch(std::bad_alloc&)
{
cout<<"no more memory."<<endl;
}
return 0 ;
}

5,舊的編譯器:
如果內(nèi)存配置失敗不會拋出異常,只是返回0.
測試實(shí)例:
int* p=new (nothrow)int;
if(p==0)
cout<<"memory error;"<<endl;