C/C++动态内存管理

小小酥诶

已于 2022-03-28 10:32:35 修改

阅读量1.2k

点赞数

分类专栏：笔记文章标签： c++ 开发语言

于 2022-03-28 10:31:09 首次发布

本文链接：https://blog.csdn.net/qq_56870066/article/details/123762062

版权

笔记专栏收录该内容

72 篇文章 1 订阅

订阅专栏

读书笔记及扩展

文章目录

C/C++内存分配方式
C++内存管理方式

C/C++内存分配方式

在学习C语言阶段的时候，创建一个变量，编译器会为它分配一块内存。而创建一个C++对象的时候，编译器会为这个对象分配内存，并且调用合适的构造函数进行初始化。
那么编译器的内存分配方式是怎样的呢？
内存分配可以有以下的几种方式

从静态存储区分配。这样的分配方式在程序开始前就可以为对象/变量分配，这块空间在整个程序运行期间都存在。
从栈区分配。调用函数时，函数的参数，局部变量，返回地址等存储在堆栈上，函数执行结束时将会自动释放这些内存空间，栈区的内存空间远远小于堆区。
从堆区分配。这种内存分配方式被称为动态内存分配，堆区又被称为“自由存储单元”，运行时通过调用相应的函数来申请和释放内存。

有时候我们并不知道程序中的对象确切地需要多少内存空间，动态内存分配则很好地处理了这种需求。

C++内存管理方式

C库中提供了函数malloc，以及它的变种函数realloc、calloc来动态地申请内存空间。使用函数free来释放动态申请出的内存空间。

	int* ptr1 = (int*)malloc(sizeof(int));

使用malloc需要指定空间大小，并且要强制类型转化，因为它只是简单地分配了一块空间，返回的是void*,而C++中不允许将空类型的指针赋予给其他类型的指针。另外，如果你申请一块内存之后，没有对这个指针进行正确的初始化，有可能会导致程序运行失败，并且如果忘记释放动态申请的内存空间，则会造成内存泄露等危害……

在创建一个C++对象时，编译器会做这两件事：

1.为对象分配内存。
2.编译器自动调用构造函数初始化该内存。

构造函数不支持显式地调用，意味着如果使用malloc函数创建一个对象，那么这个对象将不能够调用构造函数，仅仅只是开辟了一块空间。但是我们必须要确保对象被初始化，因为未初始化对象是大部分程序出错的主要原因。总而言之，C中的动态内存管理无法满足C++中动态对象的需求。
所以提出了new和delete.关键字

new和delete的使用

int main(void)
{
	//基本内置类型
	//开辟一个int类型的空间
	int* ptr2 = new int;

	//开辟多个int类型空间
	int* ptr3 = new int[5];

	//开辟一个int类型并初始化为1
	int* ptr4 = new int(1);

	delete ptr2;
	delete[] ptr3;
	delete ptr4;
	return 0;
}

new和delete的使用方式：

1.开辟一个空间: new 类型;       对应释放： delete 对象；
2.开辟多个空间：new 类型[个数]   对应释放：delete[] 对象；
3.开辟并初始化： new 类型(初始化数据) 对应释放：delete 对象

new和delete的骚操作

【内置类型】

对于内置类型，new和delete与C的内存管理函数做了差不多的事情，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

【自定义类型】

new表达式：
1.调用opreator new函数分配内存
2.调用构造函数初始化该内存

delete表达式:
1.调用析构函数清理对象中的资源
2.调用operator delete释放空间。

operator new( ) 和operator delete( )这两个内存分配函数是系统提供的全局函数,实际上是对malloc和free的各种行为进行了封装。

new和delete的区别

new、delete 和 malloc、free的区别有哪些呢？

1.new和delete是关键字，malloc和free是函数
2.malloc申请的空间不会初始化，new会初始化。
3.malloc需要手动计算空间大小并传递，new不需要
4.malloc的返回值是void*，使用时必须强制类型转换；new不需要，后面跟的是空间的类型。
5.malloc申请失败，返回NULL，所以调用后要判断是否开辟成功；new需要捕获异常
6.malloc只是开辟空间，不会调用构造函数，free释放空间不会调用析构函数；new在申请空间后会调用构造函数初始化对允许象，delete会调用析构函数清理对象中的资源，然后再释放空间。

重载new和delete

C++允许重载new和delete，以实现我们自己的存储分配方案。但是注意重载operator new和operator delete时，仅仅只能改变原本的内存分配方式。同重载其他的运算符一样，可以分为重载成全局和针对特定类的内存分配函数。
【重载全局】
重载一个全局的new和delete会导致默认版本完全不能被访问。

重载operator new的要求：

必须有一个size_t参数，该参数将接收要开辟空间的长度。
返回一个指向对象的指针，该对象的长度等于或者大于所申请的长度。
如果分配失败，不仅仅要返回一个0，还需产生一个异常信息之类的现象，明确分配内存时出了问题。
返回值是一个void*

重载operator delete的要求

参数是一个指向由operator new()分配的void*类型的内存的指针
返回值是void

为什么重载operator delete的时候，参数是一个void*?
这是因为它是在调用析构函数后得到的指针。

	//重载operator new
	//1.必须有一个size_t的参数，该参数将接收要申请开辟空间的大小
	//2.返回值是一个void*
	//3.返回一个指向对象的指针，该对象的长度等于或大于所申请的长度
	//4.如果分配失败。不仅仅要返回一个0，还需产生一个异常信息
	void* operator new(size_t sz)
	{
		cout << "new %d Bytes" << sz << endl;
		void* p = nullptr;
		//不需要强制类型转换，因为malloc返回的就是void*
		p = malloc(sz);
		if (nullptr == p)
		{
			cout << "new fail\n" << endl;
		}
		return p;
	}
	//重载operator delete
	//1.返回值为void
	//2.参数是一个指向由operator new()返回的void*的指针
	void operator delete(void* rp)
	{
		cout << "operator delete" << endl;
		free(rp);
	}

【重载类专属】

//重载ListNode专属的operator new
struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;
	void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);
		cout << "memory pool allocate" << endl;
		return p;
	}
	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1); //内存池--空间适配器
		cout << "memory pool deallocate" << endl;
	}
};
class List
{
public:
	List()
	{
		_head = new ListNode;
		_head->_next = _head;
		_head->_prev = _head;
	}
	~List()
	{
		ListNode* cur = _head->_next;
		while (cur != _head)
		{
			ListNode* next = cur->_next;
			delete cur;
			cur = next;
		}
		delete _head;
		_head = nullptr;
	}
private:
	ListNode* _head;
};
int main()
{
	List l;
	return 0;
}

定位new表达式

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

使用的格式：
new (place_address) type 或者 new (place_address) type (initializer-lost) place_address必须是一个指针，initializer-list是初始化列表。

//例如
class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}

private:
	int _data;
};

int main(void)
{
	// pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	Test* pt = (Test*)malloc(sizeof(Test));

	//定位new
	new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
	return 0;
}