C++的new&delete

标签：cal   free   hand   amp   size_t   转型   void   失败   call   

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>

C++的new&delete

标签：cal   free   hand   amp   size_t   转型   void   失败   call   

原文地址：https://www.cnblogs.com/zhxmdefj/p/12292669.html