C++内存管理

普通young man2024-07-24 0:08

前言

本篇博客讲解一下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函数](#operator new与operator delete函数)

new和delete的实现原理

[5.1 内置类型](#5.1 内置类型)

[5.2 自定义类型](#5.2 自定义类型)

[new 和 delete 的原理](#new 和 delete 的原理)

[new[] 和 delete[] 的原理](#new[] 和 delete[] 的原理)

实现细节

[定位new表达式(placement-new）](#定位new表达式(placement-new）)

使用格式

使用场景

示例

malloc/free和new/delete的区别

共同点

不同点

c++的内存分布

在学习C语言的当中，我们就学过内存管理，但是在c++当中我们优化了这里，首先我们看看一看这些代码(请选出答案放在评论区)：

cpp 复制代码 
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在哪里？____

【说明】

  1. 栈（Stack）:

    • 栈是一种用于管理局部变量、函数参数以及函数调用返回地址的数据结构。
    • 它遵循"后进先出"（LIFO）原则，这意味着最后压入栈的数据将最先被弹出。
    • 栈是向下增长的，即当内存被分配或释放时，栈指针会向低地址移动或回退。

  2. 内存映射段（Memory Mapping Segment）:

    • 这是一种高效的I/O操作方法，通过将文件或其他对象直接映射到进程的地址空间，允许进程像访问内存一样读写这些对象。
    • 内存映射可以用于创建共享内存区域，从而实现进程间的通信。

  3. 堆（Heap）:

    • 堆用于程序运行时的动态内存分配，比如通过malloc()、new等函数申请的内存。
    • 堆的大小可以动态调整，通常是从低地址向高地址增长。

  4. 数据段（Data Segment）:

    • 数据段用于存储全局变量和静态变量。
    • 在程序启动时，这部分内存就已经初始化，并且在程序运行期间保持不变。

  5. 代码段（Code Segment）:

    • 又称为文本段（Text Segment），用于存放编译后的机器码指令和只读常量。
    • 这部分内存通常是只读的，以防止程序意外修改自身的指令集。

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

cpp 复制代码 
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操作符进行动态内存管理。

cpp 复制代码 
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[]，注意：**匹配起来使用。

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

cpp 复制代码 
#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);
}
cpp 复制代码 
#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全局函数来释放空间。

cpp 复制代码 
/*
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。只是说让你知道这个知识

cpp 复制代码 
#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 操作符的工作流程如下：
    1. 调用 operator new 函数来分配内存。
    2. 在分配的内存上构造对象，调用相应的构造函数。
  • delete 操作符的工作流程如下：
    1. 调用对象的析构函数，进行必要的资源清理。
    2. 调用 operator delete 函数释放内存。
new[] 和 delete[] 的原理
  • new[] 操作符用于分配连续的数组空间：
    1. 调用 operator new[] 函数，内部可能多次调用 operator new 来分配足够大的内存块。
    2. 对每个元素调用构造函数。
  • delete[] 操作符用于释放数组空间：
    1. 对数组中的每个元素调用析构函数。
    2. 调用 operator delete[] 函数，它可能内部调用 operator delete 来释放内存。

实现细节

  • operator new 和 operator delete 是用户可以重载的运算符，用于自定义内存分配和释放的行为。
  • _free_dbg 和 _malloc_dbg 等函数提供了调试版本的内存管理，它们包含了额外的检查和跟踪信息，例如验证块类型和线程锁等，以帮助开发者检测潜在的内存问题。

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

定位new表达式(placement-new）

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

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

使用格式

定位 new 的语法如下：

cpp 复制代码 
new (place_address) type;
cpp 复制代码 
new (place_address) type(initializer_list);
  • place_address 必须是一个指向足够大内存的指针，该内存之前已经被分配。
  • type 是你想在指定内存位置上创建的对象类型。
  • initializer_list 是用于初始化对象的构造函数参数列表。

使用场景

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

  1. 内存池管理：在预先分配的大块内存中创建对象，避免频繁的小块内存分配和释放带来的开销。
  2. 缓存系统：在缓存中创建和销毁对象，缓存提供预分配的内存。
  3. 复用对象：在对象被销毁后，同一块内存可以用来创建新的对象，避免了重新分配内存的成本。
  4. 复杂数据结构：在固定大小的内存中创建对象，例如在环形缓冲区中。

示例

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

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

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

这边打印了A就说明调用了构造函数

cpp 复制代码 
#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，程序员都必须显式地管理内存，包括分配和释放。

不同点

  1. 性质不同：

    • malloc 和 free 是标准C库中的函数，用于原始内存分配和释放。
    • new 和 delete 是C++的操作符，提供了更高级的内存管理功能，特别是在处理类和对象时。

  2. 初始化：

    • malloc 分配的内存不会被初始化，意味着它可能包含任意的垃圾值。
    • new 不仅分配内存，还可以初始化对象，尤其是当使用自定义类型的对象时，它会调用构造函数。

  3. 类型安全和大小计算：

    • 使用 malloc 时，你需要手动计算所需的空间大小并将其作为参数传递。
    • new 更加类型安全，你只需指定对象类型或数组类型，编译器会自动计算所需的内存大小。

  4. 返回值和类型转换：

    • malloc 返回 void* 类型的指针，使用时通常需要显式类型转换。
    • new 返回与所创建对象类型匹配的指针，无需显式类型转换。

  5. 错误处理：

    • 当 malloc 无法分配足够的内存时，它返回 NULL，使用时需要检查是否为 NULL。
    • new 在无法分配内存时抛出 std::bad_alloc 异常，需要通过异常处理机制来捕获和处理。

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

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

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

相关推荐
一点媛艺3 小时前
Kotlin函数由易到难
开发语言·python·kotlin
姑苏风3 小时前
《Kotlin实战》-附录
android·开发语言·kotlin
奋斗的小花生4 小时前
c++ 多态性
开发语言·c++
魔道不误砍柴功4 小时前
Java 中如何巧妙应用 Function 让方法复用性更强
java·开发语言·python
闲晨4 小时前
C++ 继承：代码传承的魔法棒，开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
老猿讲编程5 小时前
一个例子来说明Ada语言的实时性支持
开发语言·ada
UestcXiye6 小时前
《TCP/IP网络编程》学习笔记 | Chapter 3：地址族与数据序列
c++·计算机网络·ip·tcp
Chrikk6 小时前
Go-性能调优实战案例
开发语言·后端·golang
幼儿园老大*6 小时前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
canyuemanyue6 小时前
go语言连续监控事件并回调处理
开发语言·后端·golang
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除