【c++深入系列】：new和delete运算符详解

🔥 本文专栏：c++
🌸作者主页：努力努力再努力wz

💪 今日博客励志语录： “生活不会向你许诺什么，尤其不会向你许诺成功。它只会给你挣扎、痛苦和煎熬的过程。但只要你坚持下去，终有一天，你会站在最亮的地方，活成自己曾经渴望的模样。”

★★★ 本文前置知识：

类和对象（上）

类和对象（中）

类和对象（下）

---

new

1.认识new运算符

那么我们之前在学习c语言的时候，如果我们要在堆上申请空间，那么我们可以调用malloc函数，那么malloc函数会在堆上开辟连续的空间并且返回这个空间的首元素的地址，那么此时在堆上申请的这片空间的生命周期就和程序是一样长，并且它的生命周期可以由我们用户在自己控制，通过调用free函数来释放在堆上申请的空间

那么在学习了c++之后，引入了类和对象，那么我们此时在堆上申请开辟的空间存储的数据类型不仅只有内置类型，还有自定义类型

那么此时就要注意创建堆对象和创建栈对象的区别，那么所谓的堆对象，就是我们调用malloc函数在堆上申请了一片空间，那么这个空间存储的数据类型是自定义类型，而栈对象就是我们在函数内部所定义的局部的自定义类型的变量

//创建堆对象
type* A=(type*)malloc(sizeof(type));
//创建栈对象
type A;

那么对于栈对象来说，那么栈对象的生命周期则是由编译器来控制，那么一旦你定义了一个局部的自定义类型的变量，那么在对象实例化的同时，那么编译器会自动调用该对象的无参或者全缺省的构造函数，而一旦函数调用结束，那么函数栈帧会被销毁，那么此时编译器会清理在函数内定义的局部变量，其中就包括该局部对象，那么编译器会自动的调用其析构函数来清理该局部对象的资源

而对于堆对象来说，那么堆对象的生命周期则是由我们用户自己来决定，那么我们可以在任意一个时刻来调用free函数来释放在堆上开辟的对象，而对于堆对象来说，编译器便不会在自动调用该堆对象的无参或者全缺省的构造函数，那么意味着当我们创建好一个堆对象的时候，那么此时这个对象的内容是随机值，未初始化的，那么为了解决这个问题，我们可以去定义一个完成对象内容的初始化的函数，调用malloc创建完对象之后再调用该初始化的函数来完成初始化

那么这个方式肯定是没问题，但是如果硬要说一个缺点的话，那么就是需要我们程序员去自己定义一个初始化函数，并且还要手动调用它，所以c++在malloc的基础上优化得到了new运算符，虽然new运算符的作用和malloc一样，那么就是在堆上申请空间，但是其中对于在堆上创建对象的时候，那么new与malloc的不同的地方就体现出来了，那么new运算符在申请开辟完空间的时候，会自动调用该对象的构造函数来完成该对象的初始化，也就意味着我们如果采取的原始的malloc的方式来创建一个堆对象的话，那么我们还得分为两步，也就是先malloc创建出一个对象，然后再调用比如init初始化函数，但是对于new来说，那么它则是一步到位，完成空间的开辟以及对象的初始化

我们知道c++是兼容c语言的，你可以在你的c++代码中继续调用malloc在堆上申请空间，但是随着new的诞生，那么malloc就可以逐渐淡出历史舞台了，那么接下来我将会从new如何使用以及其使用的相关细节和new调用的本质等多个维度带你全面剖析new运算符，那么相信你看完之后一定会对new爱不释手的

2.new运算符如何使用

那么知道了什么是new运算符之后，那么接下来我们就得知道在语法层面上如何使用new，那么我们使用new在堆上开辟空间，那么就要指明开辟空间的类型，那么就需要在new运算符后面跟上你要开辟的数据类型，那么这个数据类型可以是内置类型也可以是自定义类型，那么开辟成功之后会返回得到一个你在堆上开辟的连续空间的首元素的地址

那么我们认识最基本的，也就是如何new一个内置类型：

 //new一个int类型
int* ptr=new int;
//new一个double类型
double* ptr=new double;
//new一个float类型
float* ptr=new float;

那么new相比于malloc强大的就是我们可以在new的同时对申请的空间的内容进行初始化，而对于malloc来说，这些内容都在malloc开辟之后来完成，那么初始化的方式就是后面跟上一个括号，括号里面的内容就是你要初始化的值：

int* ptr=new int(10);
doublue* ptr=new double(20.5);

而我们知道有时候我们在堆上开辟单个变量的需求，还要堆上开辟一个动态的数组，那么这里我们的new也可以实现，那么语法上实现的方式则是：

//开辟一个int类型的长度为10的动态的数组
int* ptr=new int[10];
//开辟一个double类型的长度为10的动态的数组
double* ptr=new double[10];

并且对于数组来说，new也同样支持创建的同时给值进行初始化，那么只不过这里对于数组的各个元素的初始化的值是在花括号当中：

//int
int* ptr=new int[10]{1,2,3,4,5,6,7,8,9,10};
//double
double* ptr=new double[10]={1.2,2.2,3.2,4.2,5.2,6.2,7.2,8.2,9.2,10.2};

那么对于内置类型的数组的初始化不完全，只给部分长度的初始值，那么剩余未初始化的元素的值便是随机值

那么说完了内置类型，我们再来说自定义类型：

那么自定义类型同样可以分为开辟单个自定义类型以及一个自定义类型的数组，那么首先对于开辟单个自定义类型的话，那么语法声明则是和之前内置类型一样，没有什么差别：

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age=20, int height=168, const char* name="WangZhe"):_age(age), _height(height), _name(name){}
};
int main()
{person* a = new person;cout << a->_name << endl;return 0;
}

但是要注意的是一旦我们的类中没有提供无参数或者全缺省的构造函数的话，那么此时我们在new的同时就得带参数的构造函数传递参数：

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age, int height, const char* name):_age(age), _height(height), _name(name){}
};
int main()
{person* a = new person;cout << a->_name << endl;return 0;
}

正确做法：

person* a=new person(20,166,"WangZhe");

其次我们也可以使用new运算符来创建一个自定义类型的一个数组，那么自定义类型的数组和内置类型数组的定义差别不大，关键是自定义类型的数组中，每一个元素的初始化，那么如果该自定义类型提供了无参数或者全缺省的构造函数，那么我们new一个自定义类型的数组，那么其会自动调用这个数组中每一个对象的无参数或者全缺省的构造函数，那么我们可以写一段简单的代码来验证这个行为：

那么我们这里在类中定义的全缺省的构造函数中定义一个打印语句，那么只要其执行了该全缺省的构造函数，那么便会执行了打印语句，所以如果我们new一个长度为10的自定义类型的数组，那么如果其自动调用该数组每一个元素的全缺省构造函数，那么便会执行10次打印语句：

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age=20 ,int height=166, const char* name="WangZhe"):_age(age), _height(height), _name(name){cout << "person()" << endl;}
};
int main()
{person* a = new person[10];return 0;
}

其次如果说该类没有提供无参数或者全缺省的构造函数的话，那么我们定义一个自定义类型的数组就得显示初始化每一个元素，那么初始化的方式就可以通过匿名对象来实现，那么此时它会先调用构造函数来生成每一个匿名对象，然后再调用拷贝构造函数来初始化数组中的每一个元素，但是现代的编译器都会对此模式进行一个优化，也就是调用一次构造和拷贝构造函数优化成了直接调用构造函数，那么我们还是可以写一个代码来验证一下：

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age,int height, const char* name):_age(age), _height(height), _name(name){cout << "person()" << endl;}person(const person& p1){_age = p1._age;_height = p1._height;_name = p1._name;cout << "const person()" << endl;}
};
int main()
{person* a = new person[2]{person(20,166,"WangZhe"),person(18,170,"luoyi")};return 0;
}

而如果我们类中既有无参数或者全缺省的构造函数又有带参数的构造函数，那么这里我们初始化数组的每一个元素，那么可以不用初始化数组的全员元素，可以显示初始化数组的部分元素，然后剩下的元素就自动调用无参数或者全缺省的构造函数来完成

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age,int height, const char* name):_age(age), _height(height), _name(name){}person():_age(20),_height(180),_name("WangZhe"){cout << "person()" << endl;}
};
int main()
{person* a = new person[4]{person(20,166,"WangZhuo"),person(18,170,"luoyi")};return 0;
}

3.new运算符补充

1.new运算符的本质

那么知道了new运算符如何使用之后，我们知道在堆上new一个对象，那么开辟完空间的同时会对调用该对象的构造函数进行初始化，那么你感觉开辟空间以及调用构造函数这两个动作是new的时候同时完成的，但是实则不是，其实new一个对象的本质还是分为了两步来完成的，也就是先在堆上申请开辟空间然后再调用构造函数

而其中对于一个步骤，也就是先在堆上申请开辟空间则是交给了operator new运算符重载函数来完成，而operator new的作用就是在堆上开辟空间但是没有进行初始化，那么一听这个operator new的作用和malloc那么的相似，其实operator new运算符重载函数内部封装了malloc函数，而对于malloc函数来说，那么一旦我们调用malloc函数失败，那么malloc函数则是返回一个错误码，也就是返回NULL，而对于c++这门面向对象的语言来说，那么它不再是采取返回错误码的方式，而是采取抛异常的方式，那么抛出异常，意味着需要外界来接收，那么一旦收到异常，那么就需要对该异常进行特定逻辑的处理，那么其中就会涉及到try catch语句，那么本文肯定不会详细介绍异常，而异常是我c++系列的博客之后的内容了，所以对于不了解的读者来说，你只需知道operator new运算符重载函数内部封装了malloc，但是由于malloc是返回错误码而不是抛异常，所以operator new函数在内部对此进行了抛出异常的逻辑处理

那么我们也可以写一段简单的代码，来验证一下operator new运算符重载函数，那么注意的是operator new函数底层是封装了malloc函数，那么也就意味着operator new函数内部会调用malloc函数，所以我们调用operator new函数的时候，那么一定要传递要开辟的空间的大小，如果operator new调用成功会返回开辟空间的首元素的地址，但是其类型是void* ，所以还要强制类型转化：

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age,int height, const char* name):_age(age), _height(height), _name(name){}person():_age(20),_height(180),_name("WangZhe"){}
};
int main()
{person* a = (person*)operator new(sizeof(person));            return 0;
}

那么这里可以从调试窗口可以看到a指向的对象的值都是随机值，那么验证了operator new只是开辟空间而不进行初始化

而对于第二个步骤，也就是调用构造函数，那么这个过程就是交给了placement new来完成，那么所谓的placement new是一种特殊的new语法，那么它的作用就是为已经开辟好空间的对象显示的调用其构造函数进行初始化，所以在刚才第一个过程，我们调用了operator new函数得到了开辟好的空间的首元素的地址，那么接下来，就可以调用placement new来调用其构造函数进行初始化

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age,int height, const char* name):_age(age), _height(height), _name(name){}person():_age(20),_height(180),_name("WangZhe"){}
};
int main()
{person* a = (person*)operator new(sizeof(person));a = new(a)person(20, 180, "WangZhuo");cout << a->_name << endl;return 0;
}

placement new的语法：

 myclass* a=(myclass*)malloc(sizeof(myclass));myclass* b=new(a)myclass(type);

在你的视角下，你使用new运算符来创建一个对象，你看到的结果是既开辟了对象的空间又对开辟的空间进行了初始化，但是在编译器的视角下，那么它则是将new运算符转换成了两步，第一步则是调用operator new函数，然后第二步再是调用placement new来完成初始化

//你的视角
myclass* ptr= new myclass;
//编译器的视角
myclass ptr=(myclass*)operator new(sizeof(myclass));
ptr=new(ptr)myclass();

2.placement new补充

而对于placement new来说，那么它不仅对堆对象显示调用其构造函数，并且对于栈对象以及静态对象来说，也同样可以显示调用其构造函数，那么之前我那期介绍类与对象的博客提到过，一旦你定义了一个局部对象，那么调用其构造函数的时机就是在对象刚被创建实例化的那一刻，并且由编译器来完成调用，那么一旦实例化之后，便不允许再有二次调用构造函数的行为，并且我们无法通过对象以及指针都再来调用构造函数，那么现在引入placement new之后，其实我们可以创建一个局部的对象，然后通过使用placement new来达到二次调用构造函数的效果

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age=20,int height=180, const char* name="WangZhe"):_age(age), _height(height), _name(name){}
};
int main()
{person s1;new(&s1)person(25,180,"pengyuyan");cout << s1._name << endl;return 0;
}

而对象的初始化规定就是在实例化对象的那一刻完成的，你之后如果再调用构造函数会覆盖之前的对象的内容，那么这样做其实没有任何意义，就好比幼儿园本应该是你小时候5到6岁的年纪去上，那么现在正在上大学的年纪的你已经没必要去再读一次幼儿园了，但是如果你说你就想再回味一下童年，那么其实也没有人会阻拦你去重新上一遍幼儿园，而这里如果说你需要再调用构造函数，那么除非你是先对该对象调用了一次析构函数清理了该对象的资源，那么你可以用placement new来二次调用构造函数

并且对于析构函数来说，那么编译器是允许我们多次调用析构函数，那么可以通过指针或者直接通过对象来调用析构函数然后清理对象的资源，接着在调用placement new对其进行所谓的二次初始化

但是placement new真正的应用场景其实不在这里，而是在内存池中，那么我们知道我们调用malloc以及new都是在堆上申请内存空间，而内存空间是由操作系统来进行管理，那么其中我们直接向操作系统去申请内存空间的话，那么会涉及操作系统会去查找相应的空闲的物理内存然后再建立虚拟内存到物理内存的页表映射等等动作，意味着直接找操作系统申请内存是有一定的成本，所以我们会预先先向操作系统申请一批内存，那么malloc申请的内存不会再去找操作系统而是直接从这预先申请好的内存中获取，那么我们只需要对这些已经获取到的内存的内容进行初始化即可，所以就涉及到placement new，而内存池是一个具体的项目，那么我会在后面的博客讲到，那么如果看不懂我刚才说的内容其实没有关系，那么这部分内容只是作为了解，那么掌握我前面所讲的知识便足矣

3.new和malloc的对比

那么new和malloc的对比是面试是十分喜欢问到的一个知识点，那么除了知道new和malloc最显著的区别，也就是一个会调用构造函数一个只是开辟空间，那么new和malloc的不同其实不仅仅是在这一个方面上：

1.自动计算开辟的空间

那么对于malloc函数来说，那么它会以字节为单位来开辟空间，那么在调用malloc开辟空间的时候，那么我们就得在调用之前计算一下开辟空间的大小，那么虽然有sizeof运算符能够简化计算，但是总之我们还是要给malloc函数传递一个开辟空间的字节数，而对于new来说，那么我们只需要告诉它要开辟的类型的数量，比如是开辟是一个int类型还是10个int类型的数组，那么编译器会自己识别到类型，然后自己会调用sizeof运算符，然后交给operator new函数作为参数，也就是说编译器在转化

2.可以同时进行初始化

那么new可以同时进行初始化，而malloc则只能开辟空间，然后在之后的代码中来对开辟的空间进行初始化，而对于new来说，那么它则是一行代码能够办到两件事，虽然我们知道其实底层它这两件事是分开来完成的，但是在语言层面上，我们还是逻辑上任务new可以同时完成空间的开辟以及对于空间内容的初始化

2.自动完成指针的类型

那么我们调用malloc函数，那么malloc函数是不知道我们要在堆上开辟的空间是给什么样的数据类型来存储的，所以到时候需要我们强制类型转换，而对于new来说，那么编译器识别到我们开辟的对象的数据类型，那么会自动的调用operator new来完成类型转换，所以调用new运算符能够精确的得到返回的指针类型

3.对于自定义类型会调用其构造函数

那么这个区别在上文就已经详细的讲到过了，那么底层是因为调用了placement new来做到的

delete

1.认识delete运算符

那么我们知道malloc会配套有free函数来释放空间，那么new肯定也有对应运算符来释放器开辟的空间，那么这个工作就是delete来完成，那么这里free和delete的作用都是释放在堆上申请的空间，但是它们之间肯定有区别，不然又何必又创建一个delete呢，那么这里的区别其实就体现在释放自定义类型上面，那么delete运算符会先调用其析构函数，然后在完成空间的释放，这就是delete运算符

2.delete运算符如何使用

那么delete运算符的使用就很简答，那么它的语法就是在delete后面跟上你之前保存new开辟的对象的指针

person* a = new person;
delete a;

而对于数组来说，那么delete语法上的使用就要不同一点的就是它后面要添加一个[],代表释放的是一个数组

int* ptr = new int[10] {1,2,3,4};
delete[] ptr;

那么对于delete[]来说，如果你释放的是一个自定义类型的数组，那么它会依次调用这个数组的每一个对象的析构函数，而如果你是用的delete而不是delete[],那么意味着它只会调用一次析构函数，那么就会造成内存泄漏的问题出现

那么我们可以用一段简单的代码来验证，其中我在类中自定义了析构函数，并且在析构函数内部添加了一个打印语句，那么意味着调用一次析构函数，就要打印一次语句：

#include<iostream>
using namespace std;
class person
{
public:int _age;int _height;const char* _name;person(int age=20,int height=180, const char* name="WangZhe"):_age(age), _height(height), _name(name){}~person(){cout << "~person()" << endl;}
};
int main()
{person* ptr = new person[4];delete[] ptr;return 0;
}

#include<iostream>
using namespace std;
class person
{........
}
int main()
{person* ptr=new person[4];delete ptr;return 0;
}

那么这里直接运行崩溃了

delete运算符补充

1.delete运算符的本质

那么对于delete运算符的具体过程，那么根据上文的new，我们也可以大致猜测，这里delete运算符并不是同时调用析构以及释放空间的

对于delete运算符来说，当我们调用delete运算符，那么编译器首先会将其转换为两个步骤，那么第一个步骤就是调用创建出来的对象的析构函数，清理对象的资源，而对于析构函数来说，那么它不像构造函数，那么析构函数可以通过指针或者对象来二次调用，但是注意平常我们自己写代码的时候，我们不要自己去手动通过指针或者对象来调用析构函数，因为对于栈对象来说，那么程序执行了你手动调用的析构函数之后，当函数调用结束之后，那么编译器又会调用一次该对象的析构函数，那么这就会导致析构函数被调用了两次，那么如果类中含有动态的资源比如有一个指针成员变量指向了堆上开辟的空间，那么此时执行了两次析构函数，那么意味着会连续释放两次空间，这是一个未定义行为，而手动二次调用析构函数的场景一般是上文所说的后面要进行placement new的时候，那么可以手动调用析构函数

而这里编译器会先调用析构函数来清理资源，然后下一步便是调用operator delete函数，那么operator delete函数内部封装了free函数，所以operator delete函数底层是调用free函数，那么意味着operator new函数会接收一个指针，将指针指向的空间给释放，那么这就是delete运算符涉及到的底层的过程

//你的视角
person* ptr=new person;
//编译器的视角
ptr->~person();
operator delete(ptr);

2.不要new和free以及malloc和delete混用

那么有的小伙伴喜欢new一个对象，然后调用free函数来释放new出来的对象，或者调用malloc开辟出一个对象，然后调用delete来释放对象，那么这样混用，有些时候不会报错，但是你不可能每次都这么幸运，那么这里我们就来认识一下为什么new和free不能混用

那么这里就要涉及到一点底层了，那么你malloc以及new申请连续的内存空间，那么这些内存空间不是全部都是来存储有效内容的，也就是它会有一部分空间来存储这个内存空间的属性，那么这部分就是申请的内存空间的元数据，那么这个元数据一般是位于malloc以及new的内存空间的头部，而new以及malloc返回的地址其实不是真正意义上的所谓的申请的连续的空间的首元素地址，而是有效内容的首元素的地址，那么这个元素局存储的就是这个内存区域的信息，而对于new以及malloc来说，那么该元数据的内容是不同的

对于new来说，那么它开头的元数据记录的就是你申请的元素的个数，而对于malloc来说，那么它的元数据记录的属性则较多，分别是该申请的内存的总大小包括了元数据以及有效数据，以及一个内存的状态以及空闲列表等等，所以当你new一个对象，然后调用free函数的时候，那么free函数默认这个空间是调用malloc开辟的，那么它会首先解析该空间的元数据，那么它由于接收的是有效数据的首元素的地址，那么它首先就得向前移动一个偏移量到元数据所在位置，然后获取该malloc开辟的空间的总大小，但是由于此时是用new运算符开辟出来的对象，那么它的元数据中只有元素的个数，那么这样就会导致free错误的计算出空间的大小，那么会导致非法访问内存，从而引发段错误，同理delete和malloc混用的话，对于delete它只需知道元素个数即可，因为每一个元素的大小，则是由编译器根据指针指向的对象的类型可以计算得到，那么由于malloc的元数据的构造和new的元数据的构造不同，那么此时delete会错误解析得到释放的元数个数

malloc的元数据内存布局：
±---------------±---------------±---------------+
| 块大小 | 分配状态 | 用户可用内存空间
±---------------±---------------±---------------+

new的元数据内存布局：
±---------------±---------------±----±-----------
| 元素个数 (size_t) |
±---------------±---------------±----±-----------

结语

那么这就是本篇博客关于new和delete介绍的所有内容了，那么下一期博客，我会介绍模版，那么学会了模版之后，我们便可以进入c++的STL的学习了，那么我会持续更新，希望你多多关注与支持，那么如果本文有帮组到你的话，还请三连加关注哦，你的支持，就是我创作的最大的动力！