C++operator new、operator delete

一、 operator new的三种形式：

operator new有三种形式：

throwing (1)	void* operator new (std::size_t size) throw (std::bad_alloc);
nothrow (2)	void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) throw();
placement (3)	void* operator new (std::size_t size, void* ptr) throw();

(1)(2)的区别仅是是否抛出异常，当分配失败时，前者会抛出bad_alloc异常，后者返回null，不会抛出异常。它们都分配一个固定大小的连续内存。

new operator/delete operator就是new和delete操作符，而operator new/operator delete是函数。

new operator
（1）调用operator new分配足够的空间，并调用相关对象的构造函数
（2）不可以被重载

operator new
（1）只分配所要求的空间，不调用相关对象的构造函数。当无法满足所要求分配的空间时，则
        ->如果有new_handler，则调用new_handler，否则
        ->如果没要求不抛出异常（以nothrow参数表达），则执行bad_alloc异常，否则
        ->返回0
（2）可以被重载
（3）重载时，返回类型必须声明为void*
（4）重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为size_t
（5）重载时，可以带其它参数

delete 与 delete operator类似

用法示例：

A* a = new A; //调用throwing(1)

A* a = new(std::nothrow) A; //调用nothrow(2)

（3）是placement new，它也是对operator new的一个重载，定义于<new>中，它多接收一个ptr参数，但它只是简单地返回ptr。

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <string>  
3. using namespace std;  
4. void* operator new(size_t size)  
5. {  
6.     void *p = malloc(size);  
7.     return p;  
8. }  
9.   
10. void operator delete(void* p)  
11. {  
12.     free(p);  
13. }  
14. void* operator new[](size_t size)  
15. {  
16.     void *p = malloc(size);  
17.     return p;  
18. }  
19.   
20. void operator delete[](void* p)  
21. {  
22.     free(p);  
23. }  
24. void* operator new(size_t,int *d,int pos)  
25. {  
26.     return &d[pos];  
27. }  
28. class String  
29. {  
30. public:  
31.     String(const char *str = "")  
32.     {  
33.         cout << "Create String Object!" << endl;  
34.         if (str == NULL)  
35.         {  
36.             data = new char[1];  
37.             data[0] = '\0';  
38.         }  
39.         else  
40.         {  
41.             data = new char[strlen(str) + 1];  
42.             strcpy(data,str);  
43.         }  
44.           
45.     }  
46.     ~String()   
47.     {   
48.         cout << "Free String Object!" << endl;  
49.         delete[]data;  
50.         data = NULL;  
51.     }  
52.   
53. private:  
54.     char *data;  
55. };  
56.   
57. void main()  
58. {  
59.     String *p = new String("Hello");  
60.     delete p;  
61.     // 模拟上面过程  
62.     /* 
63.     String *p =(String *)operator new (sizeof(String)); 
64.     new(p)String("Hello"); 
65.     p->~String(); 
66.     operator delete(p); 
67.     */  
68.     // 不会调用析构函数,会造成内存泄露  
69.     void *ps = new String("Hello");  
70.     delete ps;  
71.     //  
72.     String *q = new String[10];  
73.     delete []q;  
74.     //placement new  
75.     int ar[10];  
76.     new(ar,3)int(10);  
77. }