Re：从零开始的C++世界——动态内存管理

  • 开发
  • 22

文章目录

前言

我们知道在 C 语言中，可以使用 malloc、realloc、calloc 来开辟空间，使用 free 来销毁空间。
那么在 C++ 中，我们该如何向内存申请空间呢?

1. 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";
	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、选择题

在这里插入图片描述

答案：

在这里插入图片描述
2、填空题

在这里插入图片描述

答案：

在这里插入图片描述

我们再来看一张 C/C++中程序内存区域划分 的图:

在这里插入图片描述

【说明】

  1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
  2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
    创建共享共享内存，做进程间通信。
  3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
  4. 数据段–存储全局数据和静态数据。
  5. 代码段–可执行的代码/只读常量。

注意:为什么说栈是向下增长的，而堆是向上增长的?

在这里插入图片描述

因为，一般情况下，在栈区开辟空间，先开辟的空间地址较高，而在堆区开辟空间，先开辟的空间地址较低。

例如，下面代码中，变量a和变量b存储在栈区，指针c和指针 d指向堆区的内存空间:

#include <iostream>
using namespace std;

int main()
{
	//栈区开辟空间，先开辟的空间地址高
	int a = 10;
	int b = 20;
	cout << &a << endl;
	cout << &b << endl;

	//堆区开辟空间，先开辟的空间地址低
	int* c = (int*)malloc(sizeof(int) * 10);
	int* d = (int*)malloc(sizeof(int) * 10);
	cout << c << endl;
	cout << d << endl;
	return 0;
}

我们可以运行上面的代码，可以看出，a和b的地址是大于c和 a的地址

在这里插入图片描述

因为在栈区开辟空间，先开辟的空间地址较高，所以打印出来a的地址大于b的地址;

在堆区开辟空间，先开辟的空间地址较低，所以c指向的空间地址小于d指向的空间地址。

注意：

在堆区开辟空间，后开辟的空间地址不一定比先开辟的空间地址高。
因为在堆区，后开辟的空间也有可能位于前面某一被释放的空间位置。

2.C语言内存管理方式

(1)malloc

malloc 函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个 NULL(空指针)。

它使用的时候，传参只需传入需要开辟的字节个数。
在这里插入图片描述

(2)calloc

calloca 函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个 NULL(空指针)。

calloc 函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。

calloc 函数开辟好内存后会将空间内容中的每一个字节都初始化为 0。

在这里插入图片描述

3)realloc

realloca 函数可以调整已经开辟好的动态内存的大小，第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。

realoc 函数与上面两个函数一样，如果开辟成功便返回开辟好的内存的首地址，开辟失败则返回 NULL(空指针)

在这里插入图片描述

注意:realloc 函数调整动态内存大小的时候会有三种情况:

· 原地扩。需扩展的空间后方有足够的空间可供扩展，此时，realloc函数直接在原空间后方进行扩展，并返回该内存空间首地址(即原来的首地址)。

· 异地扩。需扩展的空间后方没有足够的空间可供扩展，此时，realloc 函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放(即还给操作系统)，返回新内存空间的首地址。

· 扩容失败。需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个 NULL(空指针)。

(4)free
free 函数的作用就是将 malloc、calloc 以及 realloc 函数申请的动态内存空间释放，其释放空间的大小取决于之前申请的内存空间的大小。

在这里插入图片描述

3. C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

🍎new/delete操作内置类型

(1)new 一个int 类型的对象

int main()
{
	// 动态申请一个int类型的空间
	int* p1 = new int;

	// 销毁p1
	delete p1;

	return 0;
}

等价于用 malloc 来定义:

int main()
{
	// 用malloc动态申请一个int类型的空间
	int* p1 = (int*)malloc(sizeof(int));

	// 销毁p1
	free(p1);

	return 0;
}

(2)new 10 个int 类型的对象

int main()
{
	// 动态申请10个int类型的空间
	int* p2 = new int[10];

	// 销毁p1
	delete[] p2;

	return 0;
}

等价于用 malloc 来定义:

int main()
{
	// 动态申请10个int类型的空间
	int* p2 = (int*)malloc(sizeof(int) * 10);

	// 销毁p2
	free(p2);

	return 0;
}

(3)new 一个 int 类型对象，然后初始化为 10

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

	// 销毁p3
	delete p3;

	return 0;
}

等价于用 malloc 来定义:

int main()
{
	int* p3 = (int*)malloc(sizeof(int));
	*p3 = 10; //赋值

	//销毁p3
	free(p3);

	return 0;
}

(4)new 10 个int 类型对象，并进行初始化

int main()
{
	//动态申请10个int类型的空间并初始化为1到10
	int* p4 = new int[10]{ 1,2,3,4,5,6,7,8,9,10 };

	//销毁p4
	delete[] p4;
	
	return 0;
}

如果我们只初始化第一个对象的话，后面9个对象默认为初始化为 0
在这里插入图片描述
等价于用 malloc 来定义:

int main()
{
	//动态申请10个int类型的空间并初始化为1到10
	int* p8 = (int*)malloc(sizeof(int) * 10); //申请

	for (int i = 0; i < 10; i++) //赋值
	{
		p8[i] = i;
	}

	free(p8); //销毁

	return 0;
}

我们再来看一张详细图:
在这里插入图片描述
注意:

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

申请和释放 连续 的空间，使用 new[ ] 和 delete[ ]

🍎new和delete操作自定义类型

对于内置类型而言，用 malloc 和 new 除了用法不同，其他没什么区别，但是，它们的区别在于 自定义类型!

对于下面这段代码相信大家很熟悉吧，是我们前面学过的链表定义节点的方法:

//链表
struct ListNode
{
    ListNode* next;
    int val;
};

//申请节点
struct ListNode* BuyListNode(int x) 
{
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(node);

    node->next = NULL;
    node->val = x;
    return node;
}

int main()
{
    // 定义n1节点
    struct ListNode* n1 = BuyListNode(1);

    return 0;
}

有没有发现，如果用 C 语言的这套方式来定义的话，是不是很繁琐?

那么我们可以用 new 来改进一下：

//链表
struct ListNode
{
    ListNode* _next;
    int _val;

    //构造函数
    ListNode(int val = 0)
        :_next(nullptr) // 初始化列表
        , _val(val)
    {}
};

int main()
{
    // 定义n1节点
    ListNode* n2 = new ListNode(2); // new会去调用ListNode的构造函数

    return 0;
}

这样是不是很方便?

所以 C++ 的 new，相当于我们之前写的 BuyListNode 函数，也就是说，针对自定义类型，malloc 只能开空间，但是 new 是 开空间+调用构造函数进行初始化

🍎总结

(1)C++ 中如果是申请内置类型的对象或是数组，用 new/delete 和 malloc/free 没有什么区别。

(2)如果是自定义类型的话，new 和 delete 分别是 开空间+构造函数、析构函数+释放空间，而 malloc 和free 仅仅是 开空间和释放空间，可以看到区别还是很大的。

(3)建议在 C++ 中无论是内置类型还是自定义类型的申请和释放，尽量都使用 new 和 delete.

4. operator new与operator delete函数

new 和 delete 是用户进行动态内存申请和释放的操作符。

operator new 和 operator delete 是系统提供的全局函数，new 在底层调用 operator new 全局函数来申请空间，delete 在底层通过operator delete 全局函数来释放空间。

operator new 和 operator delete 的用法与 malloc 和 fee 的用法完全一样，其功能都是在堆上申请和释放空间。

下面是 operator new 和 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;
}

new 先去调用 operator new，然后，operator new 的底层是通过调用 malloc 函数来申请空间的，当 malloc 中请空间成功时直接返回;若申请空间失败，则尝试执行空间不足的应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。

而 operator delete 的底层是通过调用 free 函数来释放空间的。

在这里插入图片描述

🍎类专属重载

那么 operator new 和 operator delete 什么时候用呢?

假设有下面这样一个链表，我们现在对链表进行插入数据

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;

	// 构造函数
	ListNode(int data = 0)
		:_next(nullptr)
		,_prev(nullptr)
		,_data(data)
	{
		cout << "ListNode()" << endl;
	}
};

class List
{
public:
	List()
	{
		_head = new ListNode; // 调用 operator new + 构造函数
		_head->_next = _head;
		_head->_prev = _head;
	}

	//尾插
	void PushBack(int val) 
	{
		ListNode* newnode = new ListNode;
		ListNode* tail = _head->_prev;

		// _head(头)     _tail(尾)       newnode(新节点)
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;
 	}

	//析构函数
	~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;
	int n;
	cin >> n;
	for (int i = 0; i < n; ++i) { // 向链表里面插入n个数据
		l.PushBack(i);
	}
	return 0;
}

如果我们输入 1000，那么就会向堆申请 1000 次空间。

也就是说会去:调用 new，然后又调用operator new，最后再调用 malloc。

在这里插入图片描述
也就是说，现在这 1000 个数据是存在链表里面的，那么我把这堆数据用完，就会去把它清理掉，但是过了一会儿，我又要开辟空间去存放另外一对数据…

可以发现，在这个过程中，堆 会反复的给我们 申请空间，然后又 释放空间。

(其实有点像购物车的机制，把某个商品添加到购物车，然后又把某个商品从购物车删除)

在这里插入图片描述
这时，C++ 提出了一种机制:类专属重载，不破坏原有方式，我还是会去调用 new，但是我们可以把operator new 进行修改，因为 operator new 在没有动它的情况下，它默认是调用全局的 operator new，也就是说，它会去找 堆，然后进行申请和释放空间。

针对上面的代码，我们可以在 ListNode 里面去写一个operator new和 operator delete 函数，这里面就可
以走一个 内存池 的机制。

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;

	// 构造函数
	ListNode(int data = 0)
		:_next(nullptr)
		,_prev(nullptr)
		,_data(data)
	{
		cout << "ListNode()" << endl;
	}
	
	//专属operator new
	void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);
		cout << "memory pool allocate" << endl;
		return p;
	}
	
	//专属operator delete
	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}
};

这个时候申请空间就不会向系统申请了，而是走我们自己写的专属的 operator new。

我们再输入 100，那么就会向 内存池 申请 100 次内存。
在这里插入图片描述

5. new和delete的实现原理

🍎内置类型

如果申请的是内置类型的空间，new和 malloc，delete 和 free 基本类似。

不同的地方是，new/delete 申请和释放的是单个元素的空间，new[ ]和 delete[ ]申请的是连续空间，而且new 在申请空间失败时会抛异常，malloc 会返回 NULL(空指针)。

🍎自定义类型

(1)new 的原理

·调用 operator new 函数申请空间。

·在申请的空间上执行构造函数，完成对象的构造。

(2)delete 的原理

·在空间上执行析构函数，完成对象中资源的清理工作。

·调用 operator delete 函数释放对象的空间。

(3)new T[N]的原理

·调用 operator new[]函数，在 operator new[]中实际调用 operator new 函数完成 N 个对象空间的申请。

·在申请的空间上执行 N 次构造函数。

在这里插入图片描述
(4)delete[]的原理

在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源的清理。

调用 operator delete[]释放空间，实际在 operator delete[]中调用 operator delete 来释放空间。

6.定位 new 表达式

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

使用格式:new(place_address)type或者new(place_address)type(initializer-list)。

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

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

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

private:
	int _data;
};

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

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

注意: 在未使用定位 new 表达式进行显示调用构造函数进行初始化之前，malloc 申请的空间还不能算是一个对象，它只不过是与 Test 对象大小相同的一块空间，因为构造函数还没有执行。

7. 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在释放空间前会调用析构函数完成
    空间中资源的清理释放。
阅读全部

相关推荐

  6. 【零基础C语言】动态内存管理

    2024-07-20 12:42:04       40 阅读

  8. C++动态内存管理

    2024-07-20 12:42:04       42 阅读

  10. 动态内存管理（C）

    2024-07-20 12:42:04       28 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-07-20 12:42:04       103 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-07-20 12:42:04       114 阅读

  9. 在Django里面运行非项目文件

    2024-07-20 12:42:04       93 阅读

  19. Python语言-面向对象

    2024-07-20 12:42:04       99 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-07-20 12:42:04       99 阅读

热门阅读

  1. 京准：GPS北斗卫星授时信号安全隔离防护装置

    2024-07-20 12:42:04       26 阅读

  3. SpringCloudAlibaba Seata AT模式实现分布式事务原理概述

    2024-07-20 12:42:04       27 阅读

  8. vue2关于Object.defineProperty实现响应式

    2024-07-20 12:42:04       28 阅读

  10. 离散化

    2024-07-20 12:42:04       28 阅读

  12. RedisTemplate 查看key的过期时间

    2024-07-20 12:42:04       28 阅读

  16. Spark Streaming

    2024-07-20 12:42:04       24 阅读

  18. Redis 跳跃列表与紧凑列表

    2024-07-20 12:42:04       30 阅读

  21. 极狐GitLab 如何管理 PostgreSQL 扩展？

    2024-07-20 12:42:04       35 阅读

  22. 学懂C语言系列（一）：认识C语言

    2024-07-20 12:42:04       28 阅读

  24. Wpf和Winform使用devpress控件库导出Excel并调整报表样式

    2024-07-20 12:42:04       22 阅读

  25. Go的入门

    2024-07-20 12:42:04       31 阅读

  26. SOME/IP配置文件SD中ttl单位是秒

    2024-07-20 12:42:04       23 阅读

  27. 写好的程序还没看到结果就退出了，别担心，四个办法教你解决

    2024-07-20 12:42:04       28 阅读

  28. Android 14 适配之 - 隐式/显示 Intent 和 广播适配

    2024-07-20 12:42:04       21 阅读

  29. IT服务规划设计之PDCA

    2024-07-20 12:42:04       27 阅读