C++内存管理

前言

本篇博客讲解一下c++的类和对象，看这个之前请先看：C++入门基础-CSDN博客

💓 个人主页：普通young man-CSDN博客

⏩ 文章专栏：C++_普通young man的博客-CSDN博客

⏩ 本人giee:普通小青年 (pu-tong-young-man) - Gitee.com

若有问题评论区见📝

🎉欢迎大家点赞👍收藏⭐文章

c++的内存分布

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

c++的内存管理方式

operator new与operator delete函数

定位new表达式(placement-new）

使用格式

使用场景

示例

malloc/free和new/delete的区别

共同点

不同点

c++的内存分布

在学习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);
}
1. 选择题：
   选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
   globalVar在哪里？____   
   staticGlobalVar在哪里？____
   staticVar在哪里？____   
   localVar在哪里？____
   num1 在哪里？____
   
   char2在哪里？____   
   *char2在哪里？___
   pChar3在哪里？____      
   *pChar3在哪里？____
   ptr1在哪里？____        
   *ptr1在哪里？____

【说明】

栈（Stack）:

栈是一种用于管理局部变量、函数参数以及函数调用返回地址的数据结构。

它遵循“后进先出”（LIFO）原则，这意味着最后压入栈的数据将最先被弹出。

栈是向下增长的，即当内存被分配或释放时，栈指针会向低地址移动或回退。

内存映射段（Memory Mapping Segment）:

这是一种高效的I/O操作方法，通过将文件或其他对象直接映射到进程的地址空间，允许进程像访问内存一样读写这些对象。

内存映射可以用于创建共享内存区域，从而实现进程间的通信。

堆（Heap）:

堆用于程序运行时的动态内存分配，比如通过malloc()、new等函数申请的内存。

堆的大小可以动态调整，通常是从低地址向高地址增长。

数据段（Data Segment）:

数据段用于存储全局变量和静态变量。

在程序启动时，这部分内存就已经初始化，并且在程序运行期间保持不变。

代码段（Code Segment）:

又称为文本段（Text Segment），用于存放编译后的机器码指令和只读常量。

这部分内存通常是只读的，以防止程序意外修改自身的指令集。

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

void Test ()
{
 // 1.malloc/calloc/realloc的区别是什么？
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 // 这里需要free(p2)吗？
 free(p3 );
}

c++的内存管理方式

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

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

	//释放
	delete(p1);
	delete(p2);
	delete[](p3);
}

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

我们来看几段代码，探讨一个问题

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0);
	~A();

private:
	int _a;
};

A::A(int a) :_a(a)
{
	cout << "构造" << endl;
}

A::~A()
{
	cout << "析构" << endl;
}

int main() {
	A* p = new A;
	cout << "$$$$$$$$$$$$$$" << endl;
	delete(p);
}

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0);
	~A();

private:
	int _a;
};

A::A(int a) :_a(a)
{
	cout << "构造" << endl;
}

A::~A()
{
	cout << "析构" << endl;
}

int main() {
	A* p = new A[10];
	cout << "$$$$$$$$$$$$$$" << endl;
	delete[](p);
}

发现了什么？

是不是发现当我们用new这个关键字来开辟空间的时候会自动调用构造函数，反之delete关键字会调用析构，我们来看你一下汇编代码：

为什么会这样？那我们就来探讨new delete的底层

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

这边我简单的给大家展示一下抛异常：

可以看一下申请了多少后抛的异常：

我这边是3个1024相乘 == 1G，这里申请了27个G，这个不是真的申请了这么多，这个是虚拟内存，需要映射在物理内存，而计算机比较聪明是不会映射27个G，其实你是不可能用到这么多的。

我们看一下小一点的

结果一样，还是说一下这个虚拟内存，不是物理内存，我的内存条才16g。只是说让你知道这个知识


#include<iostream>
using namespace std;
void func() {
	int a = 0;
	while (1)
	{
		void* p = new char[1024 ];
		a++;
		cout << a << endl;
	}
}
int main() {
	try
	{
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	

}

new和delete的实现原理

5.1 内置类型

对于内置类型如 int, char, double 等，new 和 malloc 都可以用来分配内存，但是：

new 在分配失败时会抛出异常，而 malloc 则返回 NULL。

new 和 delete 通常用于单个元素，而 new[] 和 delete[] 用于分配和释放连续的数组空间。

5.2 自定义类型

new 和 delete 的原理

new 操作符的工作流程如下：

调用 operator new 函数来分配内存。

在分配的内存上构造对象，调用相应的构造函数。

delete 操作符的工作流程如下：

调用对象的析构函数，进行必要的资源清理。

调用 operator delete 函数释放内存。

new[] 和 delete[] 的原理

new[] 操作符用于分配连续的数组空间：

调用 operator new[] 函数，内部可能多次调用 operator new 来分配足够大的内存块。

对每个元素调用构造函数。

delete[] 操作符用于释放数组空间：

对数组中的每个元素调用析构函数。

调用 operator delete[] 函数，它可能内部调用 operator delete 来释放内存。

实现细节

operator new 和 operator delete 是用户可以重载的运算符，用于自定义内存分配和释放的行为。

_free_dbg 和 _malloc_dbg 等函数提供了调试版本的内存管理，它们包含了额外的检查和跟踪信息，例如验证块类型和线程锁等，以帮助开发者检测潜在的内存问题。

总之，new 和 delete 不仅分配和释放内存，还负责构造和析构对象，这使得它们成为管理自定义类型时更强大的工具，而 malloc 和 free 主要用于简单的内存管理，不涉及构造和析构过程。

定位new表达式(placement-new）

这个简单理解就是脱了裤子放屁

定位 new 表达式（placement new）是一种特殊的 new 操作，它不是为了分配内存，而是为了在已经预分配好的内存位置上调用构造函数，从而初始化一个对象。这种技术在内存池、缓存管理和某些高级数据结构中非常有用，因为它允许你更精细地控制内存的分配和使用。

使用格式

定位 new 的语法如下：
new (place_address) type;
new (place_address) type(initializer_list);
place_address 必须是一个指向足够大内存的指针，该内存之前已经被分配。

type 是你想在指定内存位置上创建的对象类型。

initializer_list 是用于初始化对象的构造函数参数列表。

使用场景

定位 new 表达式主要在以下情况下使用：

内存池管理：在预先分配的大块内存中创建对象，避免频繁的小块内存分配和释放带来的开销。

缓存系统：在缓存中创建和销毁对象，缓存提供预分配的内存。

复用对象：在对象被销毁后，同一块内存可以用来创建新的对象，避免了重新分配内存的成本。

复杂数据结构：在固定大小的内存中创建对象，例如在环形缓冲区中。

示例

简单说定位new就是跳过了malloc这这一段，直接在指定的内存里面构造

这是对比，你会觉得感觉多此一举，脱了裤子放屁，我给你看一种场景

你会发现p的地址和arr的地址是一样的，这就是指定内存中构造，我用指定一个类也是一样的

这边打印了A就说明调用了构造函数
#include<iostream>
using namespace std;
class A
{
public:
	A(int n = 10);
	~A();

private:
	int _a;
};

A::A(int n) :_a(n)
{
	cout << "A" << endl;
}

A::~A()
{
	cout << "~A" << endl;
}


int main(){
	//int arr[512];//内存池
	A *p = (A*)malloc(sizeof(A));

	//使用定位new在对应的内存上进行构造
	A * p1 = new(p)A;
	cout << p1 << endl;
	cout << p << endl;
	cout << sizeof(p) << endl;
	cout << sizeof(A) << endl;//这是类的大小
	cout << sizeof(p1) << endl;


	/*cout << p << endl;
	cout << p + 0xf << endl;*/
	//cout << arr << endl;
	
	//直接使用new构造
	//int* p2 = new int;
	//cout << p2 << endl;

}
//
//int main() {
//
//
//	//对比
//
//	A* p1 = new A(1);
//	delete p1;
//
//	A* p2 = (A*)operator new(sizeof(A));
//	new(p2)A(1);
//
//	p2->~A();
//	operator delete(p2);
//}

malloc/free和new/delete的区别

malloc 和 free 与 new 和 delete 在C++中用于动态内存管理，但它们之间存在关键的区别。下面总结了两者的主要共同点和不同之处：

共同点

堆内存分配：malloc 和 free 以及 new 和 delete 都用于从堆内存中分配和释放空间。

手动管理：无论是使用 malloc/free 还是 new/delete，程序员都必须显式地管理内存，包括分配和释放。

不同点

性质不同：

malloc 和 free 是标准C库中的函数，用于原始内存分配和释放。

new 和 delete 是C++的操作符，提供了更高级的内存管理功能，特别是在处理类和对象时。

初始化：

malloc 分配的内存不会被初始化，意味着它可能包含任意的垃圾值。

new 不仅分配内存，还可以初始化对象，尤其是当使用自定义类型的对象时，它会调用构造函数。

类型安全和大小计算：

使用 malloc 时，你需要手动计算所需的空间大小并将其作为参数传递。

new 更加类型安全，你只需指定对象类型或数组类型，编译器会自动计算所需的内存大小。

返回值和类型转换：

malloc 返回 void* 类型的指针，使用时通常需要显式类型转换。

new 返回与所创建对象类型匹配的指针，无需显式类型转换。

错误处理：

当 malloc 无法分配足够的内存时，它返回 NULL，使用时需要检查是否为 NULL。

new 在无法分配内存时抛出 std::bad_alloc 异常，需要通过异常处理机制来捕获和处理。

自定义类型对象的构造和析构：

malloc 和 free 不会调用构造函数或析构函数，因此对于自定义类型，仅分配和释放内存而不进行对象的初始化或清理。

new 在分配内存后会调用构造函数来初始化对象，而 delete 在释放内存前会调用析构函数来清理对象中的资源。

了解这些差异有助于在编写C++程序时做出更合适的内存管理选择。对于自定义类型的对象，使用 new 和 delete 是更安全和更方便的选择，因为它自动处理了构造和析构过程。而对于简单的数据类型或不需要构造和析构的情况，malloc 和 free 可能更加直接和高效。