【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理-Toy模板网

这篇具有很好参考价值的文章主要介绍了【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

📙 作者简介：RO-BERRY
📗 学习方向：致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识
📒 日后方向 : 偏向于CPP开发以及大数据方向，欢迎各位关注，谢谢各位的支持

【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理,c++入门到精通,c++,java,开发语言

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";
	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);
}

选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____

答案为CCCAA
globalVar为定义为全局变量，所以在静态区
staticGlobalVar定义为static全局变量，在静态区，并且只在本文件可以使用，其他文件查找不到
staticVar定义为函数体内的static变量，在静态区，并且只在本函数内可以使用，其他函数查找不到
localVar定义为函数体内的整形，为栈区，函数结束销毁
num1 定义为函数体内的数组，为栈区，函数结束销毁

char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____

答案为AAAD
char2定义为函数体内的字符数组，为栈区，函数结束销毁
*char2为字符数组里的字符，为栈区，函数结束销毁
pChar3为指针变量，存的是常量区的地址，为栈区，函数结束销毁
*pChar3为常量字符串/字面量，存在常量区
ptr1为指针变量，存的是堆区的地址，但是为栈区，函数结束销毁
*ptr1为堆区
填空题：
sizeof(num1) = ____;
sizeof(char2) = ____; strlen(char2) = ____;
sizeof(pChar3) = ____; strlen(pChar3) = ____;
sizeof(ptr1) = ____;

num1为十个整形的数组，大小为40
char2为字符数组，存储的是“abcd\0”，大小为5
char2的长度为4
pChar3的大小为4或者8，看为32位还是64位
pChar3的长度为4
ptr1的大小为4或者8
sizeof 和 strlen 区别？

sizeof和strlen是C语言中的两个关键字，用于获取变量或字符串的大小。它们的区别如下：
- sizeof：sizeof是一个运算符，用于获取变量或数据类型的大小（以字节为单位）。它可以用于任何数据类型，包括基本数据类型（如int、float）和自定义数据类型（如结构体、数组）。sizeof返回的是一个无符号整数值。
- strlen：strlen是一个函数，用于获取字符串的长度（以字符为单位）。它只能用于字符串类型（即以null字符’\0’结尾的字符数组）。strlen返回的是一个整数值，表示字符串中字符的个数，不包括null字符。
总结一下：

sizeof用于获取变量或数据类型的大小，而strlen用于获取字符串的长度。
sizeof可以用于任何数据类型，而strlen只能用于字符串类型。
sizeof返回的是字节数，strlen返回的是字符个数。

【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理,c++入门到精通,c++,java,开发语言

【说明】

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

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

void Test()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);
	int* p2 = (int*)calloc(4, sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	// 这里需要free(p2)吗？
	free(p3);
}

在这段代码中，需要使用free(p2)来释放内存。虽然在后续使用realloc重新分配内存时，会将原来的内存块复制到新的内存块中，但是在这之前，我们仍然需要使用free来释放原来的内存块。这是因为realloc函数并不会自动释放原来的内存块，而是返回一个新的指针指向重新分配后的内存块。所以，在使用realloc之前，我们需要手动释放原来的内存块。

.【面试题】

malloc/calloc/realloc的区别？

malloc、calloc和realloc都是C语言中用于动态存分配的函数，它们的区别如下：

malloc：malloc函数用于分配指定大小的内存块，并返回一个指向该内存块起始地址的指针。它只负责分配内存，并不对内存进行初始化，所以分配的内存中可能包含旧数据。

calloc：calloc函数也用于分配内存块，但与malloc不同的是，它在分配内存后会将内存块中的每个字节都初始化为0。因此，使用calloc分配的内存是被清零的。

realloc：realloc函数用于重新分配已经分配的内存块的大小。它接受两个参数：一个已经分配的内存块指针和新的大小。realloc会尝试重新分配指定大小的内存，并返回一个指向新分配内存起始地址的指针。如果重新分配成功，原来的内存块会被释放；如果失败，原来的内存块保持不变。需要注意的是，realloc可能会将原来的数据复制到新的内存块中，因此在使用realloc时需要小心处理指针引用问题。

3. C++内存管理方式

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

3.1 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类型的空间，并初始化为1,2,3
	int* ptr7 = new int[3]{1,2,3};
	
	// 动态申请10个int类型的空间，并初始化为1,2,3,0,0,0,0,0,0
	int* ptr8 = new int[10]{1,2,3};     //new会为你没有初始化的空间默认初始化为0
	
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
	delete[] ptr7;
	delete[] ptr7;
}

【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理,c++入门到精通,c++,java,开发语言

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[] --------注意：匹配起来使用。

3.2 new和delete操作自定义类型

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
	cout << "自定义类型" << endl;
	cout << "malloc and free" << endl;
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);
	cout << "new and delete" << endl;
	A* p2 = new A(1);
	delete p2;
	cout << endl;

	// 内置类型是几乎是一样的
	cout << "内置类型" << endl;
	cout << "malloc and free" << endl;
	int* p3 = (int*)malloc(sizeof(int)); // C
	free(p3);
	cout << "new and delete" << endl;
	int* p4 = new int;
	delete p4;
	cout << endl;

	cout << "自定义类型多个空间" << endl;
	cout << "malloc and free" << endl;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	free(p5);
	cout << "new and delete" << endl;
	A* p6 = new A[10];
	delete[] p6;
	cout << endl;

	return 0;
}

【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理,c++入门到精通,c++,java,开发语言

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。 所以对于自定义类型的初始化，new和delete比malloc和free更为方便
内置类型的对象申请释放，new和malloc除了用法上，没有人任何区别

4. operator new与operator delete函数

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

/*
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来释放空间的。

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次构造函数

delete[]的原理

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

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

6. 定位new表达式(placement-new) （了解）

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

new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

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

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "调用构造函数" << endl;
		_a = new int[capacity];
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		cout << "调用析构函数" << endl;
		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};


int main()
{
	//构造函数自动调用
	Stack s1;
	Stack* p1 = (Stack*)operator new(sizeof(Stack));
	
	//不能这么显示调用构造函数
	//p1->Stack(1);
	//定位new可以显示调用构造函数
	new(p1)Stack(1);
	
	//析构函数可以显示调用
	p1->~Stack();
	
	return 0;
}

运用实例：

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

7. 常见面试题

7.1 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.2 内存泄漏

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

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

7.3 operator new和new的区别

operator new和new是C++中用于动态内存分配的两个关键字，它们有以下区别：

operator new是一个全局函数，用于分配指定大小的内存块，但不会调用对象的构造函数。它返回一个指向分配内存的指针。使用operator new时，需要手动调用对象的构造函数来初始化对象。
new是一个运算符，用于在动态存储区中分配内存，并调用对象的构造函数进行初始化。它可以自动计算所需的内存大小，并返回一个指向已初始化对象的指针。

总结来说，operator new只负责内存的分配，而new除了分配内存外还会调用对象的构造函数进行初始化。文章来源地址https://www.toymoban.com/news/detail-837571.html

到了这里，关于【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！