C++的new&delete

new的过程

new的过程：先分配memory，再调用ctor

咱们经常使用的建立对象的方法有两种

Complex c(1,2);                 //栈
Complex *pc = new Complex(1,2); //堆

第一种建立出来的对象将保存在栈上，第二种则在堆上，必须手动回收内存空间（经过delete）

为了解释new的过程，咱们先创建一个Complex类

class Complex
{
public:
    Complex(...) {...}//构造函数
    ...
private:
    double real;
    double imag;
};

当咱们使用new构建Complex类对象的时候

Complex *pc = new Complex(1,2);

当咱们使用new这一个动做，在堆上动态建立一个对象时，编译器实际上帮你作了三件事：

Complex *pc;

//1.分配内存
void* memory = operator new(sizeof(Complex));   
//2.转型
pc = static_cast<Complex*>(memory);         
//3.调用构造函数
pc->Complex::Complex(1,2);

1. 分配内存：operator new也是一个函数，其内部调用malloc(n)，拿到sizeof(Complex)大小的内存空间；这时候咱们获得指向内存空间始址的指针memory，它是一个指向viod类型的指针
2. 转型：用static_cast函数，把步骤①获得的指针memory（这是一个pointer to void）转换为pointer to Complex，并将其赋值到pc（步骤①和②能够写在一块儿）
3. 调用构造函数：步骤②获得的指针pc指向的内存空间，即为新对象的起始内存地址；因而编译器将经过指针pc调用对象的构造函数

因此从结果上看，这两段代码是等效的

//代码1.
Complex *pc = new Complex(1,2);
//代码2.
Complex *pc;
void* memory = operator new(sizeof(Complex));   
pc = static_cast<Complex*>(memory);         
pc->Complex::Complex(1,2);

malloc和new的区别在于，当malloc失败时，它不会调用分配内存失败处理程序new_handler，所以咱们仍是要尽量的使用new，除非有一些特殊的需求

delete的过程

delete的过程：先调用dtor，再释放memory

咱们再创建一个包含指针的类String：

class String {
public:
    ...
    ~String()
    {delete[] m_data;}
    ...
private:
    char* m_data;
};

当咱们试用new&delete时：

String* ps = new String("HELLO")；
...
delete ps;

编译器在delete这里实际上帮你作了两件事：

String::~String(ps);    //1.调用析构函数
operator delete(ps);    //2.释放内存

1. 调用析构函数：因为String类是包含指针的，因此设计时不能使用默认析构函数，而是重载一个符合需求的析构函数，在咱们delete ps时，编译器第一步就是调用咱们重载后的析构函数（没有重载则调用默认）
2. 释放内存：operator delete和operator new同样也是一个函数，其内部调用free(ps)

new的三种形态

有的朋友可能被上面的new和operator new搞晕了，实际上在C++中提到new，至少可能表明如下三种含义：new operator，operator new，placement new

new operator

咱们上面所说的new，都是指new operator，也就是咱们平时使用的new

operator new

new operator的第一步分配内存是经过调用operator new来完成的，这里的“new”其实是像加减乘除同样的操做符，所以也是能够重载的

operator new默认状况下首先调用分配内存的代码，尝试获得一段堆上的空间，若是成功就返回，若是失败，则转而去调用一个new_hander，而后继续重复前面过程

若是咱们对这个过程不满意，就能够重载operator new，来设置咱们但愿的行为，例如在Complex类里加入：

class Complex
{
public:
    Complex(...) {...}//构造函数
    ...
    void* operator new(size_t size){
        printf("operator new called\n");
        //经过::operator new调用了原有的全局的new
        return ::operator new(size);
    }
private:
    double real;
    double imag;
};

这里经过::operator new调用了原有的全局的new，在分配内存以前输出一句话

delete也有delete operator和operator delete之分，后者也是能够重载的。而且，若是重载了operator new，就应该也相应的重载operator delete，这是良好的编程习惯。

placement new

placement new是用来实现定位构造的，所以能够实现new operator三步操做中的调用构造函数这一步（在取得了足够内存空间后，在这块内存空间是上构造一个对象）

上面写的pc->Complex::Complex(1,2);这句话并非一个标准的写法，正确的写法是使用placement new：

#include <new.h>

int main()
{
    char memory[sizeof(Complex)];
    Complex* pc = (Complex*)memory;
    new(pc) Complex(1, 2);
}

new(pc) Complex(1, 2);这种奇怪的写法即是placement new了，它实现了在指定内存地址上用指定类型的构造函数来构造一个对象的功能，后面Complex(1, 2)就是对构造函数的显式调用

这里不难发现，这块指定的地址既能够是栈，又能够是堆，placement对此不加区分
除非特别必要，不要直接使用placement new ，这毕竟不是用来构造对象的正式写法，只不过是new operator的一个步骤而已。使用new operator地编译器会自动生成对placement new的调用的代码，所以也会相应的生成使用delete时调用析构函数的代码

若是是像上面那样在栈上使用了placement new，则必须手工调用析构函数，这也是显式调用析构函数的惟一状况

pc->~Complex();

当咱们以为默认的new operator对内存的管理不能知足咱们的须要，而但愿本身手工的管理内存时，placement new就有用了。STL中的allocator就使用了这种方式，借助placement new来实现更灵活有效的内存管理。