自学内容网 自学内容网

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和delete的实现原理

5.1 内置类型

5.2 自定义类型

new 和 delete 的原理

new[] 和 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在哪里?____

【说明】

  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

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 内置类型

  • 对于内置类型如 intchardouble 等,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 等函数提供了调试版本的内存管理,它们包含了额外的检查和跟踪信息,例如验证块类型和线程锁等,以帮助开发者检测潜在的内存问题。

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

定位new表达式(placement-new)

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

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

使用格式

定位 new 的语法如下:
 

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

使用场景

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

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

示例

简单说定位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的区别

mallocfreenewdelete 在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++程序时做出更合适的内存管理选择。对于自定义类型的对象,使用 newdelete 是更安全和更方便的选择,因为它自动处理了构造和析构过程。而对于简单的数据类型或不需要构造和析构的情况,mallocfree 可能更加直接和高效。


原文地址:https://blog.csdn.net/2302_78381559/article/details/140553453

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!