C++内存管理

丢掉幻想准备斗争

已于 2024-09-20 14:44:54 修改

阅读量1k

点赞数 28

文章标签： c++

于 2024-09-20 12:11:45 首次发布

本文链接：https://blog.csdn.net/2301_80475151/article/details/142319544

版权

1.C/C++内存分布

栈又叫堆栈-存放费静态成员变量\函数参数\返回值等，而且栈是向下增长的；
堆-用于存放程序运行时动态分配的内存，堆是向上增长的；
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（这是Linux处的知识，这只需要了解一下）；
数据段-存储全局数据和静态数据；
代码段-存储可执行的代码\只读常量；如下图：

2. C语言中内存管理方式:malloc/realloc/calloc/free

#include<stdio.h>
#include <stdlib.h>


int main()
{
	//malloc申请5个int类型大小的空间
	int* arr1 = (int*)malloc(sizeof(int)*5);

	//calloc申请5个int类型大小的空间并且初始化为0；
	int* arr2 = (int*)calloc(5, sizeof(int));

	//realloc增容，在原有的空间后面增加空间
	int* arr3 = (int*)realloc(arr1, sizeof(int) * 5);

	//free完arr1就不用free arr3了，因为是同一块空间只不过是两个不同指针指向同一块空间而已；
	free(arr1);
	free(arr2);
	return 0;

}

3.C++内存管理方式

3.1 new/delete操作内置类型

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
new的语法：首先是申请一块整型空间：int* prt1 = new int；然后是申请一块整型空间初始化为10：int* ptr2 = new int(10)；最后是申请10块整型空间：int* ptr3 = new int[10]；

delete的语法：首先是释放一块空间：delete(ptr1)，delete(ptr2)；然后是释放10快整型空间delete[] ptr3；如下代码所示：

#include<iostream>
using namespace std;

void test01()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

int main()
{
	test01();
	return 0;

}

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用

new[] 和 delete[] ，注意：匹配起来使用。

3.2 new/delete操作自定义类型

new/delete和malloc/free的最大区别就是对于自定义类型除了开空间之外还会调用自定义类型中的构造函数\析构函数，而对于内置类型来说new/delete和malloc/free是一样的；如果用new/delete创建10个自定义类型就会调用10次；如下代码所示：

#include<iostream>
#include<stdlib.h>
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(1);
	delete p1;

	cout << "malloc/free的使用" << endl;
	int* ptr1 = (int*)malloc(sizeof(int));
	free(ptr1);

	cout << endl;
	cout << "new/delete创建10个自定义类型" << endl;

	A* p2 = new A[10];
	delete[] p2;
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

4. 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 来释放空间的；new其实就是operator new + 构造函数，delete就是operator delete + 析构函数；

5. new和delete的实现原理

5.1 内置类型

如果申请的是内置类型的空间， new 和 malloc ， delete 和 free 基本类似，不同的地方new/delete申请和释放的是单个元素的空间， new[] 和 delete[] 申请的是连续空间，而且 new 申请空间失败时会抛异常，malloc 会返回 NULL 。

5.2 自定义类型

new的原理：首先调用operator new函数申请空间，然后在申请的空间上执行构造函数，完成对象的构造；
delete的原理：首先执行在申请的空间调用析构函数完成对象中资源的清理工作，然后再调用operator delete函数释放对象空间；
new T[N]的原理：首先调用operator new[]函数（在operator new[]中实际调用operator new 函数完成N个对象空间的申请），然后再调用N次构造函数；

6. 定位new表达式（placement—new）

定位new是在我们想直接调用new的内部实现的函数operator new函数来申请自定义类型空间的时候需要需要用到的，其实也就是调用自定义类型中的构造函数初始化一个对象，但那就有疑问了，为什么不直接调用构造函数呢？原因是C++不支持直接调用构造函数，所以需要通过定位new来对构造函数的调用；

定位new使用语法：new(place-address) type或者new(place-address) type(initializer-list)；place-address必须是一个指针，initialize-list是类型的初始化列表;如下图和代码所示：下面这个就是直接调用构造函数发现直接报错但是析构函数可以调用：

下面这个是通过定位new表达式来调用构造函数：

#include<iostream>
using namespace std;
class Person
{
public:
	Person(int a = 0)
		: _a(a)
	{
		cout << "Person():" << this << endl;
	}
	~Person()
	{
		cout << "~Person():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	//这里的p1不能算做一个对象，这里只是p1指向了一块Person对象
	//相同大小的一段空间，因为构造函数还没有执行
	Person* p1 = (Person*)malloc(sizeof(Person));
	new(p1)Person;
	p1->~Person();
	free(p1);

	cout << endl;
	cout << "下面是operator new 的调用" << endl;

	Person* p2 = (Person*)operator new(sizeof(Person));
	new(p2)Person;
	p2->~Person();
	free(p2);

	cout << endl;
	cout << "下面是operator new 的调用加初始化" << endl;

	Person* p3 = (Person*)operator new(sizeof(Person));
	new(p3)Person(10);
	p3->~Person();
	operator delete(p3);
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：

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

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

以下是不同点

malloc和free是函数，而new和delete是操作符；
malloc申请空间不会初始化，new可以初始化.
malloc申请空间的时候要手动计算大小并传递，new只需要在后面加上类型就可以，如果是多个对象。[]指定个数就可以；
malloc的返回值是*void,在使用时必须强转，new不需要，因为new后跟着空间的类型
malloc申请失败时返回NULL，需要判空操作；new不需要，但new内部的operator new函数会捕获异常操作；
申请自定义类型的时候malloc和free只会进行单一的申请空间和释放空间的操作，但new和delete不一样的是，new申请空间的时候会调用构造函数进行初始化，delete在释放空间前会调用析构函数完成空间中资源的释放；

最后再补充一个点就是new和free不要随便搭着用，可能会造成内存泄漏；例如我们new了一个对象，对象里面又调用new的话，那么operator new 完就会调用构造函数进行初始化，就会给指针动态分配空间，如果说用free来释放的话就不调用析构函数进行内存的释放而导致内存泄漏；如下代码所示

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
		delete arr;
	}
private:
	int _a;
	int* arr = new int;
};
int main()
{
	A* p1 = new A;
	free(p1);
	return 0;
}

👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇 👇

运行结果为：这里并没有调用析构函数那一块，那么就没有对arr进行释放而导致内存的泄漏，但这里没有报错，因为内存泄漏不一定会崩溃；