C++内存管理初步

2021-04-22

cpp提供了不同层次的内存管理工具，如malloc、new和allocator，所有的管理工具最终都是调用malloc，同时malloc最底层是调用系统的内存管理工具API。

关键点：cpp中提供给程序员的内存管理工具有malloc、new和allocator。

allocator是给容器使用，只定义了实现接口的标准，具体实现方式没有要求，现在很多编译器allocator的实现仅仅是对new和delete做了一层简单的封装，效率低，之前版本的gnuc中使用了内存池+malloc的方式实现了高效的内存管理。

new实现内存管理调用了operator new进行内存分配+placement new实现对象构造。operator new可以由用户进行重载，由此实现内存管理的接管，cpp中全局的operator new底层是malloc实现。

内存管理的两个关键点：1.了解内存管理是如何调用到底层的malloc的；2.实现operator new的重载和allocator的自定义来实现内存管理接管。

概念了解

cpp内存管理malloc、new、operator new、allocator。

malloc不可被重载，new是cpp的关键字，由cpp标准确定下来了也不能重载，operator new可以被重载，也是接管内存管理的方式，allocator可以自定义然后将自定义版本传递给容器，也能实现内存管理的接管。

一般不直接使用allocator来进行内存分配，因为使用起来比较麻烦，并且需要程序员自己记住分配的内存大小。

malloc、new、allocator分配内存实例

void* p1 =malloc(512);
free(p1);

complex<int>* p2= new complex<int>;
delete p2;

void* p3 = ::operator new(512);
::operator delete(p3);

// 使用cpp提供的标准库中的allocator进行内存管理
// 标准库定义了接口，但是不同的厂商并未完全遵守。
#ifdef _MSC_VER
  int* p4 = allocator<int>().allocate(3, (int*)0);
  allocator<int>().deallocate(p4, 3);
#endif
#ifdef _BORLANDC_
  int* p4 = allocator<int>().allocate(5);
  allocator<int>().deallocate(p4, 5);
#endif
#ifdef _GNUC_
  // 这两个函数都是static，可通过全名调用之
  void* p4 = alloc::allocate(512);
  alloc::deallocate(p4, 512);

  // 以下两函数都是non-static，需要通过object调用
  void* p4 = allocator<int>().allocate(7);
  allocator<int>.deallocate((int*)p4, 7);

  // 采用内存池实现
  void* p5 = __gnu_cxx::__pool_alloc<int>().allocate(9);
  __gnu_cxx::__pool_alloc<int>().deallocate((int*)p5, 9);
#endif

new expression的底层实现

1 2	Complex* pc = new Complex(1, 2); // 底层实现如下方代码

void* mem = operator new(sizeof(Complex)); // 调用operator new分配内存，operator new的底层是的调用malloc
//如果重载了operator new便自己接管了内存管理任务
Complex* pc = static_cast<Complex*>(mem); // 进行类型转换
new(pc)Complex(1,2); // 使用placement new执行构造函数，不能使用指针直接调用构造函数（个人理解如果直接能够用的话，与构造函数的语义相违背）

operator new可以被重载，便能实现内存管理的接管，至于operator new的底层如何实现，标准库没有要求，但是目前普遍使用malloc来实现内存管理。同时operator new考虑分配失败时调用用户定义的handler函数，确保malloc能分配到内存或者实现分配不到内存返回0让malloc退出。仅仅只是对malloc做了一点简单的封装。

对于上述的placement new实现，底层实现如下

new(pc)Complex(1, 2);
//内部实现如下，以下忽略了异常捕获

// 第一行
void* mem = operator new(sizeof(Complex), buf); // operator new的一种重载形式
// 第二行
pc = static_cast<Complex*>(mem);
// 第三行
pc->Complex::Complex(1, 2);

// 第一行是operator new的重载版本，内部实现如下：
void* operator new(size_t, void* loc){
    return loc;
}

接下来是对配套使用的delete pc进行解析

1 2	delete pc; // 底层实现如下代码

1 2	pc->~Complex(); // 可以直接调用构造函数，因为pc现在指向了Complex对象 operator delete pc; // 底层实现是直接free(pc);

tips: 析构函数的意义主要是对程序员分配的堆空间（调用new或者malloc）进行回收，以及调用成员的析构函数来实现成员变量的堆空间的释放。换言之，如果对象自身没有分配堆空间，成员变量也没有分配堆空间，那么析构函数是没有用的。当然除了物理资源的管理，析构函数也常常用来实现其它资源管理，如互斥锁的释放，以及计数器的减小（如智能指针的实现）。

vector分配器底层还是调用malloc，其数据保存还是放在堆区，同手动malloc分配方式。

allocator的底层实现

T* p = allocate();
construct();
...
destroy();
deallocate p;

// 上述是一般的接口形式，不同厂商的实现方式略有不同
// G4.9 new_allocator 或者现在的std::allocator
allocate();
deallocate();

// 或者使用目前最新版里面的的内存池的allocator __pool_alloc
allocate();
deallocate();

// 上述代码底层调用
::operator new(size_t);
::operator delete(void*);

// 而上述代码最终调用malloc和free
malloc(size_t);
free(void*);

总结

可以发现，无论是new expression还是allocator.allocate()，底层都是调用::operator new，底层再去调用malloc，同理相反的delete和deallocate()底层都是调用::operator delete，底层再去调用free。因此如果实现了对operator new的重载，便接管了内存管理！而对于内存释放operator delete一般不去重载。