C++之new和delete

new 和 delete 是 C++ 用于管理 堆内存 的两个运算符，对应于 C 语言中的 malloc 和 free，但是 malloc 和 free 是函数，new 和 delete 是运算符。除此之外，

new 在申请内存的同时，还会调用对象的构造函数，而 malloc 只会申请内存；

delete 在释放内存之前，会调用对象的析构函数，而 free 只会释放内存。

new 运算符的内部实现分为两步：

• 内存分配

  调用相应的 operator new(size_t) 函数，动态分配内存。如果 operator new(size_t) 不能成功获得内存，则调用 new_handler() 函数用于处理new失败问题。如果没有设置 new_handler() 函数或者 new_handler() 未能分配足够内存，则抛出 std::bad_alloc 异常。“new运算符”所调用的 operator new(size_t) 函数，按照C++的名字查找规则，首先做依赖于实参的名字查找（即ADL规则），在要申请内存的数据类型T的 内部（成员函数）、数据类型T定义处的命名空间查找；如果没有查找到，则直接调用全局的 ::operator new(size_t) 函数。

• 构造函数

  在分配到的动态内存块上 初始化 相应类型的对象（构造函数）并返回其首地址。如果调用构造函数初始化对象时抛出异常，则自动调用 operator delete(void*, void*) 函数释放已经分配到的内存。

delete 运算符的内部实现分为两步：

• 析构函数

  调用相应类型的析构函数，处理类内部可能涉及的资源释放。

• 内存释放

  调用相应的 operator delete(void *) 函数。调用顺序参考上述 operator new(size_t) 函数（ADL规则）。

class T{
public:
    T(){
        cout << "构造函数。" << endl;
    }

    ~T(){
        cout << "析构函数。" << endl;
    }

    void * operator new(size_t sz){
        T * t = (T*)malloc(sizeof(T));
        cout << "内存分配。" << endl;
        return t;
    }

    void operator delete(void *p){
        free(p);
        cout << "内存释放。" << endl;
        return;
    }
};

int main()
{
    T * t = new T(); // 先 内存分配 ，再 构造函数
    delete t; // 先 析构函数， 再 内存释放
    return 0;
}

　　

在函数执行时，new和delete的调用顺序（工作机制）

使用new表达式时发生的三个步骤：

　　1、调用名为operator new的标准库函数，分配足够大的原始的未类型化的内存，以保存指定类型的一个对象（自定义的new)

　　2、运行该类型的一个构造函数去初始化对象

　　3、返回指向新分配并构造的构造函数对象的指针

使用delete表达式时，发生的步骤：

　　1、调用对象的析构函数

　　2、调用名为operator delete的标准库函数释放该对象所用的内存（自定义的delete）

注意：

free只能释放基础类型的内存资源；

delete在free功能的基础上，增加了对类资源内存空间的处理。

operator new和delete的库函数

operator new 和operator delete函数有两个重载版本

void * operator new (size_t);

void * operator new[](size_t);

void operator delete(void *);

void operator delete[](void *);

高级用法

只能生成栈对象

只能生成栈对象，就是说不能生成堆对象，亦即不能通过new表达式[在类之外]生成对象。

不能生成堆对象能想到的方法：

　　1、将构造函数放入private区域（不使用这种）

　　2、operator new函数 放入到private区域

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

class Student
{
public:
    int iId;
    char szName[10];
public:
    Student()    {
        std::cout << "Student 构造函数被调用" << std::endl;
    }

    ~Student()
    {
        std::cout << "Student 析构函数被调用" << std::endl;
    }

private:
    static void* operator new(std::size_t nSize);
    static void operator delete(void *pVoid);

/*
    static void* operator new(std::size_t nSize)
    {
        std::cout << "new 操作符被调用, size = " << nSize << std::endl;
        //void *pRet = new char[nSize];
        void *pRet = malloc(nSize);
        return pRet;
    }
    static void operator delete(void *pVoid)
    {
        std::cout << "delete操作符被调用." << std::endl;
        free(pVoid);
    }
    */
};

int main(void)
{
    Student *pstu = new Student;
    pstu->iId = 101;
    strcpy(pstu->szName, "Tony");
    std::cout << std::endl;
    delete pstu;

    //std::cout << std::endl;
    //Teacher *pt = new Teacher();

    //delete pt;
    return 0;
}　　

只能生成堆对象

只能生成堆对象，就是说不能生成栈对象，亦即在创建栈对象时，不能[在类之外]调用构造函数或者析构函数。

不能生成栈对象能想到的方法：

　　1、将构造函数放到private区域（不使用这种）

　　2、将析构函数放到private区域 a)对于堆对象而言，执行delete表达式无法通过编译 b)在public区域定义一个destroy()

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

class Student
{
public:
    int iId;
    char szName[10];
public:
    Student()
    {
        std::cout << "Student 构造函数被调用" << std::endl;
    }

    void destroy()
    {
        //(*this).~Student();//不能清理自定义new开辟的空间
        delete this;
    }

private://不能生成栈对象
    ~Student()
    {
        std::cout << "Student 析构函数被调用" << std::endl;
    }

};

class Teacher
{

};

int main(void)
{
    Student *pstu = new Student;
    pstu->iId = 101;
    strcpy(pstu->szName, "Tony");

    pstu->destroy();
    delete pstu;

    //Student stu;

    return 0;
}　　

小结:

1、创建栈对象

　栈对象的生成同时需要构造函数和析构函数都是public的。

　　Point pt(1,2);//ok

　　Poiint * p =new Point(1,2);//error

2、定义一个类，只能在栈上创建

　把operator new/delete放在private区域

　　Point pt(1,2);//error

3、定义一个类只能在对上创建

　将析构函数私有化

　堆对象回收的时候，要再定义一个成员函数来销毁堆对象。