C++内存管理
前言
本篇博客讲解一下c++的类和对象，看这个之前请先看：C++入门基础-CSDN博客
💓 个人主页：普通young man-CSDN博客
⏩ 文章专栏：C++_普通young man的博客-CSDN博客
⏩ 本人giee:普通小青年 (pu-tong-young-man) - Gitee.com
若有问题 评论区见📝
🎉欢迎大家点赞👍收藏⭐文章
目录
C语言中动态内存管理方式：malloc/calloc/realloc/free
operator new与operator 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表达式（placementnew）是一种特殊的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可能更加直接和高效。
原文地址：https://blog.csdn.net/2302_78381559/article/details/140553453
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！