C++内存管理

C++内存管理

(一)C/C++的内存分布

在c++中内存分为5个区，分别是堆、栈、自由存储区、全局、静态存储区和常量存储区。

• 堆：用于程序的内存动态分配。c语言使用malloc从堆上分配内存，使用free释放已分配的对应内存
• 栈：函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。
• 自由存储区：是c++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。
• 全局/静态存储区:这块内存在编译的时候就已经分配好的，在程序整个运行期间都存在。
• 常量存储区：里面存放的是常量，不允许修改。

1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段–存储全局数据和静态数据，内存空间是在编译时确定，全局静态数据是在main函数之前初始化，局部静态数据是运行到的时候初始化
5. 代码段–可执行的代码/只读常量

操作系统内存管理：

• 分段，不同用途的数据放到不同的区域，就像对西安划分区域
• 分页

---

1. 常见题：

int globalVar = 1;                      

static int staticGlobalVar = 1; //main函数之前就初始化,在哪都能用,作用域是全局的
 						//globalVar与staticGlobalVar的区别是链接属性不同


void Test()

{

 static int staticVar = 1;   //运行到这里的时候才初始化，作用域在Test函数中，
    							//只能在Test函数中使用

 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在哪里？C staticGlobalVar在哪里？C

staticVar在哪里？C localVar在哪里？A

num1 在哪里？A

char2在哪里？A *char2在哪里？A

pChar3在哪里？A *pChar3在哪里？D

ptr1在哪里？A *ptr1在哪里？B

2. 填空题：

sizeof(num1) = 40;

sizeof(char2) = 5; strlen(char2) = 4;

sizeof(pChar3) = 4/8; strlen(pChar3) = 4;

sizeof(ptr1) = 4/8;

---

早年的时候，物理内存比较小，一般都是不到1G左右，32位的进程完全能够满足

内存技术不断发展，内存越来越便宜，现在的内存都比较大，8G，如果一个进程是32位的，那么这个进程的虚拟内存是2^32个字节大小内存即4G，用4字节编号即可

64位的进程虚拟内存是2^64 个字节大小内存即2^32*4G，虚拟内存是特别大的，所以对内存的编号要是8字节为单位才行

---

一个程序在LINUX是如何编译然 后运行起来的？

• 编写的代码是存在文件系统即磁盘上的
• 编译的时候，编译器去读这个程序，通过编译链接生成二进制可执行程序
• ./a就是在一个终端下去运行一个a.out程序，相当于终端创建了一个子进程，然后exec去执行a.out程序，然后把a.out中的代码段和指令段加载到内存中，然后在运行过程中加载栈和堆内存

(二)C语言中的动态内存管理方式

int main()
{
	 int* p1 = (int*) malloc(sizeof(int));
	 free(p1);
 
	 int* p2 = (int*)calloc(4, sizeof (int));
	 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
	 // 这里需要free(p2)吗？
	 free(p3 );
}

问题：malloc/calloc/realloc的区别？

• malloc是开辟一块空间
• calloc是开辟一块空间并初始化为0
• realloc是对原有的空间进行扩容

(三)C++中的动态内存管理

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

1. new/delete操作内置类型

int main()
{
	///C语言
	int *p1 = (int*)malloc(sizeof(int));
	int *p2 = (int*)malloc(sizeof(int)*10);
    free(p1);
    free(p2);
    
	///C++
	int *p3 = new int;
	int *p4 = new int[10];
    int *p5 = new int(10); //开辟一个int类型的空间，初始化为10
	delete p3;
    delete []p4;
    delete p5;
    
    return 0;
}

已经有了malloc和free那么new和delete的意义何在？

• 对于上面的内置类型，效果是一样的
• 对于自定义类型，效果不一样，malloc和free不会调用构造函数和析构函数，new和delete会调用构造函数初始化成员变量和析构函数释放成员变量的额外空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-60wll82l-1603867654750)(C:\Users\SS\Desktop\QQ图片20201028134831.png)]

2. new/delete操作自定义类型

class Test
{
public:
    Test(): _data(0)
     {
         cout<<"Test():"<<this<<endl;
     }
     ~Test()
     {
         cout<<"~Test():"<<this<<endl;
     }
private:
     int _data;
};
void Test2()
{
 // 申请单个Test类型的空间
     Test* p1 = (Test*)malloc(sizeof(Test));
     free(p1);

     // 申请10个Test类型的空间
     Test* p2 = (Test*)malloc(sizoef(Test) * 10);
     free(p2);
}

void Test2()
{
 	// 申请单个Test类型的对象
     Test* p1 = new Test;
     delete p1;

     // 申请10个Test类型的对象
     Test* p2 = new Test[10];
     delete[] p2; 
 }

(四)operator new与operator delete函数

new和delete用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。我们可以通过在类里面重载一个operator new()函数，来定制其类专属的operator new。

/*

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; 

}

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常operator delete 最终是通过free来释放空间的p。

(五)new和delete的实现原理

1. 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和

释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，

malloc会返回NULL。

2. 自定义类型

• new的原理

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

• delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

• new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

2. 在申请的空间上执行N次构造函数

• delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

(六)定位new表达式

• 概念：

  定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

• 使用格式：

  new (place_address) type或者new (place_address) type(initializer-list)

  place_address必须是一个指针，initializer-list是类型的初始化列表

• 使用场景：

  定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义

  类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

  class Test
  {
  public:
      Test(): _data(0)
      {
          cout<<"Test():"<<this<<endl;
      }
      ~Test()
      {
          cout<<"~Test():"<<this<<endl;
      }
  private:
      int _data;
  };
  void Test()
  {
   // pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
      Test* pt = (Test*)malloc(sizeof(Test));
      new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
  }
  

(七)常见面试题

1. malloc/free和new/delete的区别

malloc/free和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在释放空间前会调用析构函数完成空间中资源的清理

7. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free

8. delete与free失败的结果都一样，都是直接终止进程

9. 多次delete和多次free会导致错误，因为free 释放这个指针占用的空间，释放后别的指针变量也可以得到这片空间，该空间的值并不一定是NULL。所以free后不能用是否为NULL来判断。
   delete：当一个指针被delete后，该指针就成了野指针（不指向任何内存空间的指针我们称之为野指针，野指针所指向的地方是随机的）。当再次delete该指针时，编译器就会提示你操作非法。

2. 设计特殊的类

• 设计一个只能在堆上开辟的类

• 设计一个只能在栈上开辟的类

• 设计一个单例模式

设计特殊类在之前的博客中有说到哦，戳他👇

3. 内存泄漏

3.1 什么是内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

3.2 内存泄漏的分类

• 堆内存泄漏

  堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生堆内存泄漏

• 系统资源泄漏

  指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

普通的进程内存泄漏是没有危害的，因为进程结束资源就会被收回，长期运行的程序危害很大比如服务器

如何检测内存泄漏

• LINUX下的内存泄漏检测工具：valgrind
• windows下的内存泄漏检测工具：CRT内存泄漏检测

内存泄漏及检测方法

如何避免内存泄漏

1. 良好的代码设计和逻辑处理：包括代码检查还有使用合理的异常处理机制、智能指针等等
2. 静态分析检测工具：包括手动检测和静态工具分析等
3. 动态运行检测：常用的valgrind工具，在linux中用top命令查看进程内存使用情况
4. 使用智能指针：智能指针在析构函数里面就会把管理的堆内存释放掉
5. 尽量避免在堆上分配内存，因为内存泄露发生的时机一般就是在堆上，因此就尽可能的使用栈上的内存，让编译器来进行分配和回收

如何一次在堆上申请4G的内存

因为32位进程的虚拟地址空间大小为4G，所以不能申请成功，所以在申请前先改为64位进程

#include <iostream>
using namespace std;
int main()
{
    void* p = new char[0xfffffffful];
    cout << "new:" << p << endl;
    return 0; 
}