文章目录
目录
二、C语言中动态内存管理方式：malloc/calloc/realloc/free
四、operator new与operator delete函数
4.1 operator new与operator delete函数
4.2 为什么要用operator new和operator delete？
前言
C++兼容C语言，C++的内存管理也是和C语言类似的。C语言使用malloc、realloc、calloc、free来进行动态内存管理，C++使用new、delete来进行。C++相比C语言在内存管理上更加方便和安全，但也需要注意内存泄漏和内存溢出等问题。在实际开发中，建议尽量使用C++的内存管理方式，以提高代码的可靠性和可维护性。
一、C/C++内存分布
我们先来看下面的一段代码和相关问题:
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}
1. 选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____
2. 填空题：
sizeof(num1) = ____;
sizeof(char2) = ____; strlen(char2) = ____;
sizeof(pChar3) = ____; strlen(pChar3) = ____;
sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别？
1选择
globalVar在哪里？_C___ staticGlobalVar在哪里？__C__
staticVar在哪里？__C__ localVar在哪里？__A__
num1 在哪里？__A__
char2在哪里？__A__ *char2在哪里？__A_
pChar3在哪里？__A__ *pChar3在哪里？__D__
ptr1在哪里？__A__ *ptr1在哪里？__B__
#include <iostream>
using namespace std;
int main()
{
//这俩个变量都在栈
const int a = 0;
int b = 0;
cout << &a << endl;
cout << &b << endl;
//这个指针指向的地址在常量区
const char* p = "abcd";
cout << (void*)p <<endl;
return 0;
}堆区域的地址和栈区域的地址相差很远可以通过上面的代码进行验证：
2填空
sizeof(num1) = __40__;
sizeof(char2) = __5__; strlen(char2) = __4__;
sizeof(pChar3) = __4/8__; strlen(pChar3) = __4__;
sizeof(ptr1) = __4/8__;
3sizeof和strlen的区别：
sizeof是一个运算符，strlen是一个函数。
sizeof用于计算数据类型或变量在内存中所占空间的字节数。
strlen用于计算字符串的长度，即不包括字符串结束符'\0'的字符数。
sizeof返回的是数据类型或变量在内存中所占空间的大小，而strlen返回的是字符串的实际长度。sizeof是在编译时计算的，而strlen是在运行时计算的。
【说明】
1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux的内容现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。
5. 代码段--可执行的代码/只读常量。
实际上电脑上的文件都是可执行程序，可执行程序执行起来就是进程。
这些内存区域的划分是因为要更好的管理。
二、C语言中动态内存管理方式：malloc/calloc/realloc/free
C++兼容C语言所以C语言的内存管理方式可以使用。
void Test()
{
int* p1 = (int*)malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 这里需要free(p2)吗？
free(p3);
}
malloc：malloc是最基本的动态内存分配函数，用于分配指定大小的内存空间。它只分配内存，并不对其进行初始化，所以分配的内存中可能包含任意值。
calloc：calloc也用于分配内存空间，但它会在分配内存后将其初始化为零。calloc需要两个参数，第一个参数是要分配的元素个数，第二个参数是每个元素的大小。
realloc：realloc用于重新分配之前分配的内存空间的大小。它接受两个参数，第一个参数是之前分配的内存地址，第二个参数是新的内存大小。如果新的内存大小比之前的大，realloc会扩展内存空间并保留原有数据；如果新的内存大小比之前的小，realloc会缩小内存空间并保留原有数据。
realloc在扩张新的空间时，如果后面有其他数据则会将原有的数据进行拷贝然后扩容再转移到新的地方，并且释放掉原来的空间。
三、 C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
3.1new/delete操作内置类型
对于内置类型我们使用malloc和new是没什么很大区别的。
void Test1()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[10];
// 动态申请10个int类型的空间,并初始化
// 未初始化的部分默认是0
int* ptr7 = new int[10] {1,2,3,4,5};
delete ptr4;
delete ptr5;
delete[] ptr6;
delete[] ptr7;
}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。
3.2 new和delete操作自定义类型
注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
A(const A& a)
{
cout << " A(const A& a):" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
//new/delete和malloc/free最大区别是
//new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);//调用默认构造
free(p1);
delete p2;//调用析构
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];//十个A对象调用默认构造
free(p5);
delete[] p6;//调用十次析构
return 0;
}对于自定义类型使用malloc初始化不了：
int main()
{
A a1(1);
A a2(2);
A a3(3);
cout << endl;
//有名对象初始化
A* p1 = new A[5]{ a1,a2,a3 };
cout << endl;
delete[] p1;
return 0;
}
使用有名对象初始化：
匿名对象初始化：
int main()
{
//匿名对象初始化
A* p1 = new A[5]{A(1),A(2),A(3)};
cout << endl;
delete[] p1;
return 0;
}
隐式类型转换进行初始化：
int main()
{
//隐式类型转换进行对象初始化
A* p1 = new A[5]{1,2,3};
cout << endl;
delete[] p1;
return 0;
}
也可以进行多参数的构造：
class A
{
public:
A(int a = 0)
: _a(a)
{cout << "A():" << this << endl;}
A(const A& a)
{cout << "A(const A& a):" << this << endl;}
A(int a, int b)
: _a(a)
{
cout << "A(int a, int b):" << this << endl;
}
~A()
{cout << "~A():" << this << endl;}
private:
int _a;
};
int main()
{
//隐式类型转换进行对象初始化
A* p1 = new A[5]{ 1,2,3,{4,5}};
cout << endl;
delete[] p1;
return 0;
}
四、operator new与operator delete函数
4.1 operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete局函数来释放空间。
/*operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，
尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void* p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
/*operator delete: 该函数最终是通过free来释放空间的*/
void operator delete(void* pUserData)
{
_CrtMemBlockHeader* pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg(pUserData, pHead->nBlockUse);
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
/*free的实现*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
简单来说就是如下代码：
//operator new->(malloc) + 构造函数
A* p2 = new A;
//析构 + operator delete
delete p2;析构和operator delete释放的不是一个东西，俩个东西不是同一个。operator new和operator delete管理的是对象的成员的空间，而构造和析构管理的是，成员变量指向的空间。
观察汇编代码：
A* p2 = new A;先调用operator new函数，再调用构造函数。
delete p2; 先调用析构函数，再调用operator delete。
4.2 为什么要用operator new和operator delete？
由于malloc失败的结果是返回空，在C语言中我们常常要检查malloc开辟的空间是否为空。而C++中引出了异常的概念。如果operator new开辟空间失败会抛异常。异常是可以捕获的，通过try{}catch(){}语块，try中捕获异常，如果抛异常就会执行catch中的语句。
使用operator new来分配内存可以确保在内存不足时抛出std::bad_alloc异常，以避免程序崩溃。同时，通过重载operator new可以实现自定义的内存分配策略，例如实现内存池来提高内存分配的效率。
使用operator delete来释放内存可以确保在释放内存之前调用对象的析构函数，从而避免内存泄漏。
使用operator new和operator delete可以更好地控制内存的分配和释放，提高程序的灵活性和性能。
五、new和delete的实现原理
5.1 内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是:new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
5.2 自定义类型
new的原理
1. 调用operator new函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造
delete的原理
1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用operator delete函数释放对象的空间
new T[N]的原理
1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数
delete[]的原理
1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
5.2.1 delete的匹配
operator new[T]本质上就是调用了n次的operator new函数，他会提前计算好要开辟的空间大小：
#include <iostream>
using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
A* p1 = new A;
A* p2 = new A[10]; //44
delete[] p2;
return 0;
}观察反汇编：
提前计算好size，但是大小为什么是44？
实际上malloc可以和new交错着使用，但是前提是内置类型。如果是自定义类型就有可能出问题了。
#include <iostream>
using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{cout << "A():" << this << endl;}
~A()
{cout << "~A():" << this << endl;}
private:
int _a;
};
int main()
{
A* p2 = new A[10]; //44
delete[] p2;
int * p3 = new int[10]; //40
free(p3);
return 0;
}
//如果p2是下面这样释放呢？
A* p2 = new A[10]; //44
free(p2);这样会不会发生内存泄露呢？运行代码发现崩溃了。
注释掉~A析构函数后：
代码运行正常。代码结果很怪异。
实际上就是因为p2多开的4个字节的原因。多开的4个字节用于存什么呢？通过内存调试窗口进行查看operator delete[]干了什么事情：
就如下图：
存储了size，operator delete[]就可以将这个值取出来进行调用多少次析构函数。
operator delete[]调用n次operator delete，operator delete调用free。最终free的位置是10开始的位置。这是operator delete[]的作用。
使用free进行释放则不会将10位置给释放掉。(即不会往前偏移)
使用delete p2同样也不会进行偏移，因为不匹配new []也不会发生偏移。
只有delete[] p2才可以将10释放掉。
所以在使用delete时要匹配new的方式。
多开辟的位置用于存储个数的，所以一般就是4个字节。
而在使用delete[]时如果将析构函数进行注释，编译器又会又奇怪的行为：
size大小变成了40.
所以也不一定是44.这取决于是否要调用析构函数。如果要调用析构函数则需要加上析构的次数。所以将析构函数去掉时，free也没问题，因为不需要偏移到前面。
总结：释放时匹配使用。
六、定位new表达式 (placement-new)
析构是可以显示调用的。C++规定不能能显示调用析构函数。
class A
{
public:
A(int a = 0)
: _a(a)
{cout << "A():" << this << endl;}
~A()
{cout << "~A():" << this << endl;}
private:
int _a;
};
int main()
{
A* p1 = new A;
//显示效用析构
p1->~A();
operator delete(p1);
return 0;
}结果：
那不用new行不行，那如何显示调用构造函数？
int main()
{
//A* p1 = new A;
A* p1 = (A*)operator new(sizeof(A));
//delete p1;
//显示效用析构
p1->~A();
operator delete(p1);
return 0;
}
所以有了replacement-new表达式：
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
int main()
{
//A* p1 = new A;
A* p1 = (A*)operator new(sizeof(A));
//显示调用构造
new(p1)A;
//delete p1;
//显示效用析构
p1->~A();
operator delete(p1);
return 0;
}
可以进行初始化：
//显示调用构造
//new(p1)A;
new(p1)A(10);//调用构造并进行初始化//new(p1)A{10};{}可用于多个参数，或者多个对象。
隐式类型转化。
但是不推荐这样，最好使用循环，这样灵活控制。
在析构A[10]时注意要使用循环进行析构。
int main()
{
//A* p1 = new A;
A* p1 = (A*)operator new(sizeof(A));
//p1->A(); // 不支持这样显示调用构造
//new(p1)A; // 对已有空间，显示调用构造
new(p1)A(10); // 对已有空间，显示调用构造
//A* p1 = pool.alloc(sizeof(A));
//new(p1)A(10); // 对已有空间，显示调用构造
// delete p1
p1->~A();
operator delete(p1);
// new []
A* p2 = (A*)operator new[](sizeof(A)*10);
//new(p2)A[10]{1,2,3,4}; // 对已有空间，显示调用构造
for (int i = 0; i < 10; ++i)
new(p2 + i)A(i);
// delete[]
for (int i = 0; i < 10; i++)
{
(p2 + i)->~A();
}
operator delete[](p2);
return 0;
}像我们这样写是不会多开4个字节的，因为我们调用的是operator new和operator delete。明确知道个数。
这些东西在后面的内存池中可以运用。什么是内存池？
实际上我们使用malloc和new开辟空间的时候都要去找堆的空间。这些都是编译器自己在操作。效率较低。所以为了提高效率，出现了池化技术(内存池，线程池···)。
内存池是我们自己通过空间配置器来进行空间的管理，加大效率，这是我们就需要定位new来进行自定义类型的显示调用构造和析构函数。
七、常见面试题
7.1 malloc/free和new/delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：
1. malloc和free是函数，new和delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，[]中指定对象个数即可
4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
7.2 内存泄漏
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
1.如何避免内存泄漏
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。
具体内存泄漏的问题往后智能指针详细讲解。
如果你有所收获可以留下你的点赞和关注，谢谢你的观看！
扫一扫
3259
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
