1 int* p = (int*)malloc(10 * sizeof(int));
2        
3 if( p !=  NULL )
4 {
5     // ... ...
6 }

1 int* p = new int[10];
2        
3 if( p != NULL )
4 {
5     // ... ...
6 }

1 void my_new_handler()
2 {
3     cout << "No enough memory";
4     cout << endl;
5            
6     exit(1);  // 内存不足了，就把当前的程序结束了；
7 }

1 int main(int argc, char* argv[])
2 {
3     set_new_handler(my_new_handler);  // 告诉 C++ 编译器；可以设置自定义的处理函数，处理堆空间不足的情况；
4            
5      // ... ...
6            
7      return 0;
8 }

  1 #include <iostream>
  2 #include <new>
  3 #include <cstdlib>
  4 #include <exception>
  5 
  6 using namespace std;
  7 
  8 class Test
  9 {
 10     int m_value;
 11 public:
 12     Test()
 13     {
 14         cout << "Test()" << endl;
 15         
 16         m_value = 0;
 17     }
 18     
 19     ~Test()
 20     {
 21         cout << "~Test()" << endl;  
 22     }
 23     
 24     void* operator new (unsigned int size) throw()
 25     {
 26         cout << "operator new: " << size << endl;
 27         
 28         // return malloc(size);
 29         
 30         return NULL;  // 这里当没有加上 throw() 时，编译器显示： warning: 'operator new' must not return NULL unless it is declared 'throw()' (or -fcheck-new is in effect)；
 31     }
 32     
 33     void operator delete (void* p)
 34     {
 35         cout << "operator delete: " << p << endl;
 36         
 37         free(p);
 38     }
 39     
 40     void* operator new[] (unsigned int size) throw()
 41     {
 42         cout << "operator new[]: " << size << endl;
 43         
 44         // return malloc(size);
 45         
 46         return NULL;
 47     }
 48     
 49     void operator delete[] (void* p)
 50     {
 51         cout << "operator delete[]: " << p << endl;
 52         
 53         free(p);
 54     }
 55 };
 56 
 57 void my_new_handler()
 58 {
 59     cout << "void my_new_handler()" << endl;
 60 }
 61 
 62 /* 证明 new_handler() 函数存在 */
 63 void ex_func_1()
 64 {
 65     /* 定义 func 变量，其类型为 new_handler 类型，C++ 中 new_handler 是一个预定义的函数指针，指向的函数类型是 void(*)()，调用 set_new_handler() 是将自定义的 my_new_handler() 处理函数设置进去，设置了自定义处理函数后，原来的处理函数就会作为返回值返回到 func，这点和上一节的不同，上一节是返回自定义的处理函数，这一节是返回原来的预定义处理函数； */
 66     new_handler func = set_new_handler(my_new_handler);  
 67     
 68     try
 69     {
 70         cout << "func = " << func << endl;
 71         
 72         if( func )  // 加上 if() 处理语句是因为默认的情况下面可能是没有处理函数的，此时 func 为空；
 73         {
 74             func();
 75         }
 76     }
 77     catch(const bad_alloc&)  // 想证明默认的 new_handler() 处理函数确实是要抛出 bad_alloc 异常；
 78     {
 79         cout << "catch(const bad_alloc&)" << endl;
 80     }
 81 }
 82 
 83 void ex_func_2()
 84 {
 85     Test* pt = new Test();
 86     
 87     cout << "pt = " << pt << endl;
 88     
 89     delete pt;
 90     
 91     pt = new Test[5];
 92     
 93     cout << "pt = " << pt << endl;
 94     
 95     delete[] pt; 
 96 }
 97 
 98 /* 如何在单次申请的时候，告诉编译器，不管结果是什么，都不要抛出异常，如果说申请失败了，直接返回空指针 */
 99 void ex_func_3()
100 {
101     /* 这个语句是 C++ 标准语法，只是之前没见过而已 */
102     int* p = new(nothrow) int[10];  // 现在进行动态内存申请，但是不管结果有没有成功，都不要抛出异常，结果失败，直接返回空；
103     
104     // ... ...
105     
106     delete[] p; 
107     
108     /* 上面 new 的写法也可以写成下面的形式 */
109     
110     int bb[2] = {0}; 
111     
112     struct ST
113     {
114         int x;
115         int y;
116     };
117     
118     ST* pt = new(bb) ST();  // 把 ST 对象创建到 bb[2] 的栈空间中去，即在指定的位置创建一个对象，括号的作用是向编译器指明要在指定的地址上面创建一个对象出来；
119     
120     /* 对创建的对象赋值 */
121     pt->x = 1;
122     pt->y = 2;
123     
124     /* 这里的打印想证明上面创建的对象确实存在 bb[2] 空间当中的 */
125     cout << bb[0] << endl;  // 打印 1
126     cout << bb[1] << endl;  // 打印 2
127     
128     pt->~ST();  // 显示的调用析构函数，因为我们指定了穿件对象的空间，这时必须显示手动调用析构函数；
129 }
130 
131 int main(int argc, char *argv[])
132 {
133     // ex_func_1();  
134     // ex_func_2();
135     // ex_func_3();
136     
137     return 0;
138 }