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、定义一个类只能在对上创建
将析构函数私有化
堆对象回收的时候，要再定义一个成员函数来销毁堆对象。