C/C++内存管理

最新推荐文章于 2024-03-30 11:25:14 发布

无罢哥

最新推荐文章于 2024-03-30 11:25:14 发布

阅读量428

点赞数 12

分类专栏： C++学习文章标签： c++

本文链接：https://blog.csdn.net/Allelujah123/article/details/123747672

版权

C++学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

2.4 malloc/calloc/realloc区别

3.C++是如何进行内存管理的

4.operator new与operator delete函数

5.operator new与operator delete的重载

5.1replacement -now

6.malloc/free和new/delete的区别

1.C/C++中的内存分布

在C/C++程序运行起来之后，内存分布情况如图

栈又叫堆栈，非静态局部变量/函数相关的一些数据：形参，局部变量表达式中间结果，寄存器信息/返回值等等，栈是向下增长的，从高地址向低地址依次存放。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
堆用于程序运行时动态内存分配（malloc，calloc，realloc等），堆是可以上增长的，从低地址向高地址次存放。
数据段--存储全局数据和静态数据。
代码段--可执行的代码/只读常量。

为什么操作系统在设计的时候，需要将完整的内存划分成不同的区域呢？

其实是为了更方便对内存空间进行管理

2.C语言中动态内存管理方式

2.1malloc

C语言提供了一个动态内存开辟的函数：

void* malloc (size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器

2.2 free

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下

void free (void* ptr);

free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
malloc和free都声明在 stdlib.h 头文件中。

2.3 calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

2.3 realloc

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间

情况2：原有空间之后没有足够大的空间

情况 1

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况 2

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小

的连续空间来使用。这样函数返回的是一个新的内存地址。

由于上述的两种情况，realloc函数的使用就要注意一些

2.4 malloc/calloc/realloc区别

相同点：

都是从堆上申请空间
都需要对返回值判空
都需要用户free释放
返回值类型相同（void*）
都需要类型转化
底层实现上是一样的，都需要开辟多余的空间，用来维护申请的空间

不同点：

函数名字不同和参数类型不同。
calloc会对申请空间初始化，并且初始化为0，而其他两个不会。
malloc申请的空间必须使用memset初始化
realloc是对已经存在的空间进行调整，当第一个参数传入NULL的时候和malloc一样
调整分为两种情况。

3.C++是如何进行内存管理的

在C++中仍可以使用malloc/realloc/calloc等来从堆上动态申请空间，然后用free释放，因为C++是兼容C语言的，但是在C++中一般不会使用C语言中的动态内存管理方式，C++为我们提供了new 和delete操作符来进行动态内存管理，更加便捷。

void Test()
{
 // 动态申请一个int类型的空间
 int* ptr4 = new int;
 
 // 动态申请一个int类型的空间并初始化为10
 int* ptr5 = new int(10);

 // 动态申请3个int类型的空间
 int* ptr6 = new int[3];

// 动态申请3个int类型的空间且赋值
 int* ptr6 = new int[3]{1，2，3};
 delete ptr4;
 delete ptr5;
 delete[] ptr6;
 }

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，并且要一一对应，是良好的代码习惯。

在C++中，动态内存空间申请和释放时，一定要匹配：
malloc/calloc/realloc---->free
new ---> delete
new[] ---> delete[]
否则：可能会存在内存泄漏或者存在程序崩溃

本文测试环境均为VS2019

对于下面的程序并非是按照标准来写的

int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	delete p1;

	int* p2 = (int*)malloc(sizeof(int) * 10);
	delete[] p2;

	int* p3 = new int;
	free(p3);

	int* p4 = new int;
	delete[] p4;

	int* p5 = new int[10];
	free(p5);

	int* p6 = new int[10];
	delete p6;

	// _CrtDumpMemoryLeaks：是windows操作系统提供一个api函数
	// 用来简单进行内存泄漏检测
	_CrtDumpMemoryLeaks();
	return 0;
}

经过测试发现程序并没有崩溃

结论：对于内置类型，是否完全匹配，并不会造成内存泄漏或者程序崩溃的后果。建议在使用时还是匹配起来，是一个良好的代码习惯。

那么对于自定义类型呢？

经过测试，会造成程序崩溃和内存泄露，那么这些是为什么呢，这我们就需要了解一下底层中malloc/free，new/delete是什么样的了。

class Test
{
public:
	Test(int t = 0)
		: _t(t)
	{
		cout << "Test(int):" << this << endl;
	}

	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _t;
};
int main() {

	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);

	Test* p2 = new Test(100);
	delete p2;

	Test* p3 = new Test[10];
	delete[] p3;

	return 0;
}

那么，问题来了，为什么C++设计的时候不让malloc申请空间之后调用构造函数，不让free之后调用析构函数呢？

答案很简单：因为malloc和free都是C标准库中定义的函数

4.operator new与operator delete函数

new和delete 是用户进行 动态内存申请和释放的操作符 ， operator new 和operator delete 是系统提供的 全局函数，new在底层调用operator new 全局函数来申请空间， delete在底层通过operator delete 全局函数来释放空间。

对以下的代码

class Test
{
public:
	Test(int t = 0)
		: _t(t)
	{
		p = new int[10];
		cout << "Test(int):" << this << endl;
	}
	~Test()
	{
		delete[] p;
		cout << "~Test():" << this << endl;
	}
private:
	int _t;
	int* p;
};
int main()
{
	Test* pt = new Test(10);
	delete pt;
	_CrtDumpMemoryLeaks();
	return 0;
}

在底层反汇编时我们可以看到

在用new初始化对象时调用了一个 operator new(size_t size==sizeof(Test))函数

还调用了Test中的构造函数将对象初始化完整

关于 operator new

它是一个已经被编译器定义好的函数

我们可以看到new底层还是用malloc实现的。

关于delete也是类似的

调用析构函数将对象中的资源清理完成后会调用 operator delete(void* pt) 来释放空间

通过上述两个全局函数的实现知道， operator new 实际也是通过malloc来申请空间 ， 如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。 operator delete 最终是通过free来释放空间的

new多个自定义类型或者delete多个也是类似的

class Test{
private：int _t;
}
Test* t1=new Test[10];
delete[] t1;

它们会循环调用 operator new/delete函数，直到完成。

5.operator new与operator delete的重载

一般情况下时不需要重载的，直接使用库提供的就行，但在有某些特殊需求时比如：申请空间时顺便打印日志信息，防止内存泄露，可以进行重载

5.1replacement -now

定位new表达式是在 已分配的原始内存空间中调用构造函数初始化一个对象 。

使用格式：

new (place_address) type 或者 new (place_address) type(initializer-list)

place_address必须是一个指针，initializer-list是类型的初始化列表

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化

void* operator new(size_t size, char* fileName, char* funcName, size_t lineNo)
{
	cout << fileName << "-" << funcName << "-" << lineNo << ":" << size << endl;
	return operator new(size);
}

void operator delete(void* p, char* fileName, char* funcName, size_t lineNo)
{
	cout << fileName << "-" << funcName << "-" << lineNo << endl;
	return operator delete(p);
}

#ifdef _DEBUG
#define new new(__FILE__, __FUNCDNAME__, __LINE__)
#define delete(p) operator delete(p, __FILE__, __FUNCTION__, __LINE__)
#endif
int main()
{
	int* pt1 = new int;
	delete(pt1);

	Test* pt2 = new Test;
	delete pt2;
	return 0;
}

我们通过重载可以打印出文件信息，并且在利用宏可以在debug模式下才会打印，release则不会打印

6.malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

malloc和free是函数，new和delete是操作符
malloc申请的空间不会初始化，new可以初始化
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

7.内存泄漏

7.2什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

7.2.1内存泄漏分类

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

7.2.2如何避免内存泄漏

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
采用RAII思想或者智能指针来管理资源。
有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

end

无罢哥

关注

12
点赞
踩
4

收藏

觉得还不错? 一键收藏
10
评论
C/C++内存管理

1.C/C++中的内存分布在C/C++程序运行起来之后，内存分布情况如图栈又叫堆栈，非静态局部变量/函数相关的一些数据：形参，局部变量表达式中间结果，寄存器信息/返回值等等，栈是向下增长的，从高地址向低地址依次存放。内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）堆用于程序运行时动态内存分配（malloc，calloc，realloc等），堆是可以上增长的，从.
复制链接

扫一扫