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 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、定义一个类只能在对上创建
将析构函数私有化
堆对象回收的时候,要再定义一个成员函数来销毁堆对象。
原文链接: https://www.cnblogs.com/cthon/p/9175657.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/275875
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!