重识new

元始天尊

一、new primer
    new操作符并不是c++的专属，c运行库有new.h头文件。
    C++中的new操作符，众所周知是用来分配动态内存的，而要能达到“动态”这种灵活性的特征，非堆区莫属，因为堆区支持手动分配。如果内存空间不够，new操作符返回空，或抛出异常（下面会讲述3种new操作符，常规new操作符、定位new操作符和禁止抛出异常的new操作符，如果禁止抛异常，那么只好返回空了）
下面代码为MSDN中的，检测new分配是否成功，内存分配失败处理还可以通过_set_new_handler注册分配异常函数结果

1. 
   
2. // insufficient_memory_conditions.cpp
   
3. // compile with: /EHsc
   
4. #include <iostream>
   
5. using namespace std;
   
6. #define BIG_NUMBER 100000000
   
7. int main() {
   
8.    int *pI = new int[BIG_NUMBER];
   
9.    if( pI == 0x0 ) {
   
10.       cout << "Insufficient memory" << endl;
    
11.       return -1;
    
12.    }
    
13. }
    

复制代码

    对于对象使用new操作符的情况，生成的代码执行的流程一般为：先调用内部合适的new函数，该函数最终调用内存分配API进行堆内存分配，同时初始化一些方便内存管理的结构体和数据。成功分配后，将该地址视为this，如有必要则设置虚表指针，之后调用构造函数对该地址处对象进行构造。构造函数一般也是执行初始化功能而已，修改修改数据啥的。这些都是老生常谈不再赘述。
    即使请求的空间是0字节大小，new也会返回不同的地址，也就说总是在不同区域分配。这里注意和空类的区别，空类的大小是1，传给new函数（该函数在之后给出）之后，new函数接受到的参数只会>=1，而对于特殊情况：char* pch=new char[0];new函数接受的参数确实是0，不过分配的空间并不是0字节，因为存在内存管理相关的结构体也会占用内存。
    new操作符有2种作用域，一种是全局new，一种是类作用域new。用户在自定义类中可以重载自定义new函数。代码如下：

1. 
   
2. #include <malloc.h>
   
3. #include <memory.h>
   
4. 
   
5. class Blanks
   
6. {
   
7. public:
   
8.     Blanks(){}
   
9.     void *operator new( size_t stAllocateBlock, char chInit );
   
10. };
    
11. void *Blanks::operator new( size_t stAllocateBlock, char chInit )
    
12. {
    
13.     void *pvTemp = malloc( stAllocateBlock );
    
14.     if( pvTemp != 0 )
    
15.         memset( pvTemp, chInit, stAllocateBlock );
    
16.     return pvTemp;
    
17. }
    
18. // 对于Blanks对象，全局new操作符已被替换，因此下面的代码将分配sizeof(Blanks)大小的空间并把数据赋值为0xa5
    
19. int main()
    
20. {
    
21.    Blanks *a5 = new(0xa5) Blanks;
    
22.    return a5 != 0;
    
23. }
    

复制代码

二、new primer plus
new和delete操作符是通过一种称为自由存储区的内存池分配内存的，而new和delete操作符本身在编译时会由编译器选择合适的new函数和delete函数进行实现。
C运行库的new函数会在失败时抛出std::bad_alloc异常，如果要使用不抛出异常的new版本，则需要链接nothrownew.obj，然而一旦链接了该文件，标准C++库中的new就不起作用了
new有2种语法形式
[::] new [placement] new-type-name [new-initializer]
[::] new [placement] ( type-name ) [new-initializer]

2种new函数原型为：
void* operator new( std::size_t _Count ) throw(bad_alloc);
void* operator new( std::size_t _Count, const std::nothrow_t& ) throw( );
void* operator new( std::size_t _Count, void* _Ptr ) throw( );


void *operator new[]( std::size_t _Count ) throw(std::bad_alloc);
void *operator new[]( std::size_t _Count, const std::nothrow_t& ) throw( );
void *operator new[]( std::size_t _Count, void* _Ptr ) throw( );


其用法如下：

1. 
   
2. // new_op_new.cpp
   
3. // compile with: /EHsc
   
4. #include<new>
   
5. #include<iostream>
   
6. 
   
7. using namespace std;
   
8. 
   
9. class MyClass
   
10. {
    
11. public:
    
12.    MyClass( )
    
13.    {
    
14.       cout << "Construction MyClass." << this << endl;
    
15.    };
    
16. 
    
17.    ~MyClass( )
    
18.    {
    
19.       imember = 0; cout << "Destructing MyClass." << this << endl;
    
20.    };
    
21.    int imember;
    
22. };
    
23. 
    
24. int main( )
    
25. {
    
26.    // The first form of new delete
    
27.    MyClass* fPtr = new MyClass;
    
28.    delete fPtr;
    
29. 
    
30.    // The second form of new delete
    
31.    MyClass* fPtr2 = new( nothrow ) MyClass;
    
32.    delete fPtr2;
    
33. 
    
34.    // The third form of new delete
    
35.    char x[sizeof( MyClass )];
    
36.    MyClass* fPtr3 = new( &x[0] ) MyClass;
    
37.    fPtr3 -> ~MyClass();
    
38.    cout << "The address of x[0] is : " << ( void* )&x[0] << endl;
    
39. }
    

复制代码

Construction MyClass.000B3F30
Destructing MyClass.000B3F30
Construction MyClass.000B3F30
Destructing MyClass.000B3F30
Construction MyClass.0023FC60
Destructing MyClass.0023FC60
The address of x[0] is : 0023FC60

1. 
   
2. // new_op_alloc.cpp
   
3. // compile with: /EHsc
   
4. #include <new>
   
5. #include <iostream>
   
6. 
   
7. using namespace std;
   
8. 
   
9. class MyClass {
   
10. public:
    
11.    MyClass() {
    
12.       cout << "Construction MyClass." << this << endl;
    
13.    };
    
14. 
    
15.    ~MyClass() {
    
16.       imember = 0; cout << "Destructing MyClass." << this << endl;
    
17.       };
    
18.    int imember;
    
19. };
    
20. 
    
21. int main() {
    
22.    // The first form of new delete
    
23.    MyClass* fPtr = new MyClass[2];
    
24.    delete[ ] fPtr;
    
25. 
    
26.    // The second form of new delete
    
27.    char x[2 * sizeof( MyClass ) + sizeof(int)];
    
28.    
    
29.    MyClass* fPtr2 = new( &x[0] ) MyClass[2];
    
30.    fPtr2[1].~MyClass();
    
31.    fPtr2[0].~MyClass();
    
32.    cout << "The address of x[0] is : " << ( void* )&x[0] << endl;
    
33. 
    
34.    // The third form of new delete
    
35.    MyClass* fPtr3 = new( nothrow ) MyClass[2];
    
36.    delete[ ] fPtr3;
    
37. }
    

复制代码

Construction MyClass.00311AEC
Construction MyClass.00311AF0
Destructing MyClass.00311AF0
Destructing MyClass.00311AEC
Construction MyClass.0012FED4
Construction MyClass.0012FED8
Destructing MyClass.0012FED8
Destructing MyClass.0012FED4
The address of x[0] is : 0012FED0
Construction MyClass.00311AEC
Construction MyClass.00311AF0
Destructing MyClass.00311AF0
Destructing MyClass.00311AEC


他们是怎么实现的呢？请听下回分解

0xAA55

哈哈 卖关子