C++（三）----内存管理

news2024/9/25 11:19:33

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";
 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在哪里？____
2. 填空题：
 sizeof(num1) = ____;
 sizeof(char2) = ____; strlen(char2) = ____;
 sizeof(pChar3) = ____; strlen(pChar3) = ____;
 sizeof(ptr1) = ____;

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

2.C++内存管理方式

让我们先回想一下，C语言是如何进行内存管理的？
四个函数：malloc、realloc、calloc、free。
但是它们的使用非常不方便：int* p=(int*)malloc(sizeof(int)*n);
不仅代码量大，而且当变量是自定义类型的时候,C语言的内存管理函数无法自动调用变量的构造/析构函数。所以C++有一套自己的内存管理方式：通过new和delete操作符进行动态内存管理

new

1.开辟多个空间int* p = new int[100];

2.开辟一个空间并初始化

class A
{
public:
 A(int a = 0)
 : _a(a)
 {}
private:
 int _a;
};

A* p = new A(10);

使用小括号() 这段代码初始化了一个对象成10，并且将地址赋值给指针变量p
3.开辟多个空间并初始化

A* p = new A[5]{1,2,3};

和malloc相比，new的特点分为以下几点：
1.对于内置类型来说,new和malloc
并没有太大的区别

2.对于自定义类型来说,new会调用
自定义类型的构造函数,而malloc不会

3.new可以初始化变量的内容

delete

delete的使用方法：
1.直接使用：

int* p = new int(10);
//使用指针p
delete p;

当new堆区空间时只开辟了一份空间，释放空间时直接使用delete即可
2. 使用delete []

int* p = new int[10]{1,2,3,4};
//使用指针p
delete[] p;//这里必须使用delete [],因为是多个空间

和free相比，delete在内置类型上没什么区别，对于自定义类型则会调用其析构函数，但是有些情况需要加 [] ,而free不需要考虑这个。

3.实现原理

全局函数operator new

new 和 delete 作为两个操作符，与malloc、free函数不一样，那new是怎样开辟空间的呢？

答：new在底层调用了operator new

这个operator new是一个函数而不是运算符重载，尽管它名字中间有一个空格

库里的函数原型：

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
void *p;
while ((p = malloc(size)) == 0)
	if (_callnewh(size) == 0)
	{
	    // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
	    static const std::bad_alloc nomem;
	    _RAISE(nomem);
	}
return (p);
}

通过这个原型，我们发现new在底层其实还是使用了malloc来进行开辟空间。开辟空间成功,会返回指向此空间的指针；开辟空间失败,会抛异常（后面会学）

全局函数operator delete

和new类似，delete也是调用了一个函数：operator delete:

#define free(p) _free_dbg(p, _NORMAL_BLOCK)
void operator delete(void *pUserData)
{
     _CrtMemBlockHeader * pHead;
     RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
     if (pUserData == NULL)
         return;
     _mlock(_HEAP_LOCK);
     __TRY
         pHead = pHdr(pUserData);
         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg( pUserData, pHead->nBlockUse );//这个是free函数的宏替换
     __FINALLY
         _munlock(_HEAP_LOCK);
     __END_TRY_FINALLY
     return;
}

说明delete也是用free来进行空间的释放的

总结

对于内置类型来说,new和malloc的实现是一样的，free和delete也差不多

对于自定义类型来说:
如果是new T，调用operator new函数申请空间，在申请的空间上执行构造函数，完成对象的构造。如果是new T[n],则调用operator new[]函数，完成N个对象空间的申请，在申请的空间上执行N次构造函数；
如果是delete T，在空间上执行析构函数，完成对象中资源的清理工作，调用operator delete函数释放对象的空间
如果是delete[] T,在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理,调用operator delete[]释放空间.

new是先申请再构造，delete是先析构再释放

下面是对于一些常考点的总结：

1.malloc和free是函数，new和delete是操作符
2.malloc申请的空间不会初始化，new可以初始化
3.malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
4.malloc的返回值为void, 在使用时必须强转，new不需要，因为new后跟的是空间的类型*
5.malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
6.申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

拓展：内存泄露
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不
是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

内存泄露有两种：
1.堆内存泄露——动态分配后未进行释放
2.系统资源泄漏：指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

如何防止内存泄露？
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

ps：如何一次在堆上申请4个G的内存？

// 将程序编译成x64的进程，运行下面的程序试试？
#include <iostream>
using namespace std;
int main()
{
 void* p = new char[0xfffffffful];//十六进制数字
 cout << "new:" << p << endl;
 return 0;
}