---

一、new、delete、malloc和free

最简单的分配内存

	int* p_m = (int*)malloc(sizeof(int));int* p_n = new int;

自定义对象分配和释放内存

让我们定义如下的对象

class TestClass
{
public:TestClass(){cout << "构造函数调用" << endl;}~TestClass(){cout << "析构函数调用" << endl;}int a = 0;int b = 0;
};

然后使用new和malloc分配内存，使用delete和free分别释放

	TestClass* p_m1 = (TestClass*)malloc(sizeof(TestClass));TestClass* p_n1 = new TestClass();delete p_n1;free(p_m1);

我们会发现最终只有new 和 delete 配对的方式走了生命周期

那我们把他们换过来配对会怎么样呢

	TestClass* p_n1 = new TestClass();free(p_n1);

	TestClass* p_m1 = (TestClass*)malloc(sizeof(TestClass));delete p_m1;

可以看到：
delete 释放都会调用析构函数，而free都不会调用。
new 可以调用构造函数，而malloc不会调用构造
如果要使用生命周期的话使用new是较好的选择

二、new、delete与虚析构的问题

我们定义一个有着继承关系的结构

class BaseClass
{
public:BaseClass(){cout << "Base构造函数调用" << endl;}~BaseClass(){cout << "Base~析构函数调用" << endl;}int a = 0;int b = 0;
};class ChildClass : public BaseClass
{
public:ChildClass(){cout << "Child构造函数调用" << endl;}~ChildClass(){cout << "Child~析构函数调用" << endl;}
};

然后我们分配内存和释放内存，看看构造与析构是怎么样的

	ChildClass* Child = new ChildClass();delete Child;

现在我们使用多态去定义

	BaseClass* Child1 = new ChildClass();delete Child1;

我们发现这时候并没有调用子类的析构了，我们需要给父类析构变成虚析构
最终代码

class BaseClass
{
public:BaseClass(){cout << "Base构造函数调用" << endl;}virtual ~BaseClass(){cout << "Base~析构函数调用" << endl;}int a = 0;int b = 0;
};class ChildClass : public BaseClass
{
public:ChildClass(){cout << "Child构造函数调用" << endl;}~ChildClass(){cout << "Child~析构函数调用" << endl;}
};int main()
{ChildClass* Child = new ChildClass();delete Child;cout << "=========================" << endl;BaseClass* Child1 = new ChildClass();delete Child1;system("pause");return 0;
}

三、一维、二维、多维数值创建和释放

一维

	TestClass* Arr = new TestClass[10];delete[] Arr;

二维

	// 创建TestClass** Arr = new TestClass*[3];for (size_t i = 0; i < 3; i++){Arr[i] = new TestClass[3];}// 释放for (size_t i = 0; i < 3; i++){delete[] Arr[i];}delete[] Arr;

多维

	// 创建TestClass*** Arr = new TestClass**[2];for (size_t i = 0; i < 2; i++){Arr[i] = new TestClass*[2];for (size_t j = 0; j < 2; j++){Arr[i][j] = new TestClass[2];}}// 释放for (size_t i = 0; i < 2; i++){for (size_t j = 0; j < 2; j++){delete[] Arr[i][j];}delete[] Arr[i];}delete[] Arr;

四、new的缺点以及连续内存的优点

内存碎片产生原因：

1、小块内存分配​​：
频繁分配不同大小的对象
内存分配器需要不断寻找合适大小的内存块

for (int i = 0; i < 10000; i++) {// 频繁分配不同大小的对象auto* obj1 = new SmallObject();   // 例如 16 字节auto* obj2 = new MediumObject();  // 例如 64 字节auto* obj3 = new LargeObject();   // 例如 256 字节// 释放部分对象delete obj2; // 在内存中留下中等大小的空隙
}

2、非连续释放​​：
对象以随机顺序创建和销毁
在已分配内存中留下大小不一的"空洞"

3、内存分配器限制​​：
无法合并相邻的小空闲块
新分配的对象无法放入这些"空洞"

频繁的new对象会有大量的内存碎片产生，可以预先分配一块内存进行取用

template<typename T>
class FPreCacheData
{
public:FPreCacheData(int size){Size = size;DataPtr = new T[size];}inline int GetSize() { return size; }T& operator[](int index) {return DataPtr[index];}private:int Size;T* DataPtr;
};

	FPreCacheData<TestClass> PreCacheData = FPreCacheData<TestClass>(100);TestClass& a = PreCacheData[20];