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