C&C++内存管理

C/C++内存分布

在C语言中我们经常说，局部变量存放在栈区，动态内存开辟的空间是向堆区申请的，只读常量存放在常量区等等。其实这里我们所说的区域都是虚拟进程地址空间的一部分，具体划分如下：

1. 内核空间是存放操作系统内核的，受硬件保护，我们无法访问
2. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
3. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信.（Linux课程如果没学到这块，现在只需要了解一下）
4. 堆用于程序运行时动态内存分配，堆是可以上增长的。
5. 数据段–存储全局数据和静态数据。
6. 代码段–可执行的代码/只读常量 (从操作系统层面更喜欢叫代码段，从语言角度叫常量区)

ps：进程地址空间以及多线程的问题会在Linux中详细学习，在这里只需要简单了解一下就可以。

有了上述知识的铺垫，我们大概清楚了内存的区域划分，接下来做几道题目：

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

解答：

//选择题：
//选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
//globalVar在哪里？____ 
// globalVar作为一个全局变量是存放在数据段的，数据段主要存放全局变量和静态变量
// 
// staticGlobalVar在哪里？____
// 静态变量存放在数据段
// 
//staticVar在哪里？____ 
// 静态变量存放在数据段
// 
// localVar在哪里？____
// 局部变量存放在栈区
// 
//num1 在哪里？____
//局部变量存放在栈区
//char2在哪里？____  
// char2是一个局部数组存放在栈区
// 
// * char2在哪里？___
// *char2是首元素a的地址，这个局部数组都存在于栈区，这个数组的首元素肯定也是存在于栈区啊
// 
//pChar3在哪里？____
// pChar3作为一个局部指针变量存放于栈区
// 
// * pChar3在哪里？____
// *pChar3是一个常量字符串存在于代码段
// 
//ptr1在哪里？____
// ptr1是局部变量存在于栈区
// 
//* ptr1在哪里？____
//*ptr1是堆区上开辟的空间，存在于堆区
//2、填空题：40 5 4 4/8 4 4/8
//3、sizeof是操作符/关键字，后面可以不加括号，而直接跟类型，另外，sizeof计算的是变量所占空间的字节数；而strlen是函数，调用必须加括号，且strlen计算的是字符串中字符的个数(不包括'\0')

那么这里有个地方我想特别讲解一下，就是为什么* char2存在于栈区。或许你们会认为数组char2中存放的是一串字符是只读常量，应该存在于代码段中。但其实char2作为一个数组里面的只读常量是从代码段中拷贝而来的，所以并不存在于代码段而是存在于栈区。

此外为什么ptr1在栈区，而 *ptr1却在堆区，这个其实在数据结构部分应该是反复讲过的， *ptr1作为栈区的一个指针指向了堆区所开辟的那一块空间，用于标识

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

在C语言中我们通常是使用malloc/calloc/realloc配合free来进项动态内存管理，下面我们来看两个问题：

void Test()
{
  int* p1 = (int*)malloc(sizeof(int));
  free(p1);
  // 1.malloc/calloc/realloc的区别是什么？
  int* p2 = (int*)calloc(4, sizeof(int));
  int* p3 = (int*)realloc(p2, sizeof(int) * 10);
  // 这里需要free(p2)吗？
  free(p3);
}

1.malloc/calloc/realloc的区别

malloc用于开辟一块内存空间，大小需要我们指定，开辟以后不会初始化，如果开辟成功就返回空间的起始地址，开辟失败就会返回一个空指针。

calloc用法于malloc相似，它有两个参数，一个是元素个数，一个是每个元素的大小，不过它与malloc最大的不同在于它会将该空间中的元素初始化为0.

realloc用于空间的改变（扩容/缩容），有两个参数，第一个参数为需要调整的空间的地址，第二个是调整后空间的总大小，如果第一个参数为NULL就相当于malloc，如果是扩容那么编译器会检查当前空间后是否有足够的空间，如果有就是原地扩，否则就会另寻一块空间并将当前空间的数据拷贝到新空间中，最后释放原空间，这就是异地扩，异地扩的代价相对较大。如果是缩容，编译器就会找一块新空间，将数据拷贝过去，最大后再释放原空间

2.在上述代码中需要释放p2吗?

有了第一个问题的知识，我们就知道不需要释放p2，因为如果是原地扩，那么p3和p2是同一块空间，如果是异地扩那么p2就已经被realloc释放掉了，后续只要释放p3就行。

拓展

如果你好奇，malloc的实现原理可以参考一下这个视频：glibc中malloc实现原理 – bilibili

C++内存管理

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

new/delete操作内置类型

对于内置类型来说，C和C++的内存管理方式并没有什么区别，只是用new取代了malloc/calloc，用delete来代替free。

new和delete是C++中的操作符不是函数，所以不需要传参，只需要标明类型即可，此外new可以自主选择是否对空间初始化

void Test()
{
  // 动态申请一个int类型的空间
  int* ptr4 = new int;
  // 动态申请一个int类型的空间并初始化为10
  int* ptr5 = new int(10);
  // 动态申请10个int类型的空间
  int* ptr6 = new int[10];
  delete ptr4;
  delete ptr5;
  delete[] ptr6;
}

申请和释放单个元素空间就用new和delete，申请和释放多个元素空间要用new[]和delete[]，二者一定要配合使用，也就是说不能用delete删除new[]. 否则就会有会问题产生。（有些编译器会报错，有些不会但是这样的程序一定是存在问题的）

要注意的一点是C++没有提供修改空间的方式，如果该空间大小不适合就只能销毁该控件再重新开辟一个大小合适的空间。

new/delete操作自定义类型

既然前面说了C语言对内存管理的方式在C++中的某些地方无能为力，但是它们在处理内置类型时有没什么区别，那么也就是说主要区别在于对自定义类型的操作咯。C语言中的malloc/calloc只负责开辟空间，free只负责释放空间，而C++中的new在开辟空间的同时会调用构造函数，delete在释放空间时会自动调用析构函数

class A
{
public:
  A(int a=0)
    :_a(10)
  {
    cout << "调用构造函数" << endl;
  }
  ~A()
  {
    cout << "调用析构函数" << endl;
  }
private:
  int _a;
};
int main()
{
  A* p1 = new A(10);
  delete p1;
    cout<<endl;
    A*p2=new A[10];
    delete[] p2;
  return 0;
}

拓展学习

不知道各位有没有想过在我们开辟了空间以后，释放的时候编译器怎么知道需要释放的这个空间有多大呢？如果是你的话，你会怎么设计让编译器能够智能的识别呢？这里以vs2013作为编程环境来讲解

int* p3 = new int[10];这是开辟十个整形的空间并且不初始化，但是其实编译器并不是只开辟四十个字节，而是开辟了四十四个字节，前四个字节用于存储开辟出来的空间中存放的元素个数。

当我们需要释放空间时，也就是执行delete[]操作时，编译器会自动向前减四个字节拿到该空间中的元素个数，并将整个空间四十四个字节一块释放。

而如果你用new[]开辟出来的空间不用delete[]来释放的话，编译器就无法自动向前减四个字节，而是直接从后面开始释放，这样是不对的，产生的结果是无法预料的，这就是为什么说一定要配套使用

operator new和operator delete

new和delete通过在底层调用operator new和operator delete来达到开辟和释放空间的目的。在学过类和对象以后看到operator就想到运算符重载是吧，但是这里其实并不是运算符重载；这点从它们的参数没有自定义类型就可以看出来，初学者很容易被这个名字搞混。要注意operator new和operator delete是系统提供的一个全局函数 ，只是名字没取好带了operator而已

C++底层的operator new和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);  //此处调用free函数
  __FINALLY
    _munlock(_HEAP_LOCK);  // release other threads
  __END_TRY_FINALLY
    return;
}
// free的实现
#define  free(p)        _free_dbg(p, _NORMAL_BLOCK)

通过上面的代码可以看出，new和malloc的另一个不同，malloc在开辟空间失败的时候会返回一个空指针，而new在失败的时候则会抛异常（抛异常是面向对象处理错误的方式）。

前面说了new和delete底层是在调用operator new和operator delete，下面就通过汇编来看一下底层是不是这样：

同样的道理，对于new[]和delete[]来说底层也有一个operator new[]和operatordelete[]与之配套：

但其实operator new[]和operator delete[]不过是迭代调用operator new和operator delete的结果：

如果再往下看，就会发现其实operator new不过也是调用malloc而已如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。而operator delete 最终是通过free来释放空间的。

new和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL 。

自定义类型

new 的原理

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

2.在申请的空间上调用构造函数，完成对象的初始化；

delete 的原理

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

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

new T[N] 的原理

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

在申请的空间上调用N次构造函数；

delete[] 的原理

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

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

从底层也可以看到，new除了能开辟空间以外还会自动调用构造函数，而delete除了释放空间外还会调用析构函数对资源进行清理。这就是为什么C++在C语言本身有动态内存管理办法的基础上还有新增new和delete。

定位new表达式

定位new也叫repalcement new，**定位new表达式是已分配的原始内存空间中调用构造函数初始化一个对象 **，使用格式如下：

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

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

class A
{
public:
  A(int a=1)
    :_a(a)
  {}
  ~A()
  {
    cout << "调用析构函数" << endl;
  }
  void Print()
  {
    cout << _a << endl;
  }
private:
  int _a;
};
int main()
{
    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
  A* p1 = (A*)malloc(sizeof(A) * 4);
  new(p1)A;//如果这个对象的构造函数有参数就需要传参
  p1->Print();
  p1->~A();//这是定向new调用析构函数的形式
  delete p1;
  cout << endl;
  A* p2 = (A*)malloc(sizeof(A) * 4);
  new(p2)A(10);
  p2->Print();
  p2->~A();
  delete p2;
  return 0;
}

使用场景

定位new一般是配合内存池所使用，什么是内存池呢？

假设山上有一个村庄，村里都用一口井打水，那么在早上或者用水频繁的时候，打水的人会比较多就需要排队，这样效率太低。所以你就找关系在你家搞了一个水窖，你将水提前搞到水窖里，想用的时候就从水窖里面取，这种即用即取的水窖就相当于内存池。

公用的水井就相当于堆，如果很多变量同时向堆申请空间可能就需要排队，而池化就可以提高空间申请的效率。这个后面会说，这里简单了解一下就行。

常见面试题

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申请空间失败时返回的是空指针，因此使用的时候需要判空；new不需要，new开辟失败是抛异常需要我们捕获异常

6.对自定义类型开辟空间时，malloc/free只会开辟/释放空间不会调用构造/析构函数，而new/delete则会在开辟/释放空间的同时调用构造/析构函数

2.内存泄漏

1.什么是内存泄漏

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

注意内存泄漏并不是内存丢了，只是指向内存的指针丢了，无法再找到这块空间了而已。所谓的内存泄漏其实和占着茅坑不拉屎一个道理，茅坑在那里没有丢，但是那个茅坑没有人能使用。

2.内存泄漏的危害

对短期运行的程序而言内存泄漏的问题其实并不是很严重，因为在程序结束时操作系统会自动回收内存空间。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

3.内存泄漏的分类

在C/C++中内存泄漏一般分为两种：

1.堆内存泄漏(Heap leak)

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

2.系统资源泄漏

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

4.如何检测内存泄漏

在 vs 下，可以使用 windows 操作系统提供的 _CrtDumpMemoryLeaks() 函数进行简单检测，但是该函数只会报出大概泄漏了多少个字节，没有其他更准确的位置信息：

因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放；但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下，如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的：

在linux下内存泄漏检测：Linux下几款C++程序中的内存泄露检查工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄露检测工具比较

如何避免内存泄漏

5.如何避免内存泄漏

1.工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放；(注：这个是理想状态，但是如果碰上异常时，就算注意释放了，也还是可能会出问题，需要下一条智能指针来管理才有保证)

2.采用RAII思想或者智能指针来管理资源；

3.有些公司内部规范使用内部实现的私有内存管理库；这套库自带内存泄漏检测的功能选项；

4.出问题了使用内存泄漏工具检测。(注：很多工具都不够靠谱，或者收费昂贵)

总结：

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

那么本篇文章的内容就到这里啦，感谢观看