C++内存管理

在很早之前的文章里，那时候我们认为内存大致是这样的：(如果对栈帧结构不太明白的同学可以看一看)

入口地址：https://blog.csdn.net/LSFAN0213/article/details/80280494

到如今，我们眼里的内存应该是如下这个样子：

其中，栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。

内存映射段是高效的 I/O 映射方式，用于装载一个共享的动态内存库。用户可以使用系统接口创建共享内存，做进程间通信。

堆用于程序运行时的动态内存分配，堆是向上增长的。

数据段使存储全局数据和静态数据的。

代码段是可执行的代码/只读常量。

大概回顾了内存那些事之后，我们再来回想几个C语言中动态管理内存的函数。malloc / realloc / calloc / free

这几个函数在C语言中都是做动态管理内存的函数接口，它们都是从堆上申请内存空间，用完都要主动释放，那它们的区别是什么呢？我们在这也稍微复习一下：

void* malloc(size_t size);   不做初始化

void* calloc(size_t num,size_t size);  做初始化

void* realloc(void* ptr,size_t size);  可以扩容，如果原有空间足够，就不会开辟新的内存空间，若不够，就会去开辟新的空间。

说到动态内存管理，就不得不提内存泄露这件事，我们在申请空间，用完的时候，一定要记住用 free 函数去释放空间，不然就会引发内存泄露。

什么是内存泄露，内存泄露是指，在堆上申请的空间由种种原因没有释放或者无法释放，而导致的系统内存的浪费，最后导致程序运行速度减慢或者崩溃的严重后果。

简单来说，我们知道，每台计算机都有操作系统，操作系统是来管理计算机所有的硬件和软件的，我们在使用malloc / realloc / calloc 等函数接口在堆上申请空间，我们可以理解为，我们在向操作系统借内存空间，在我们使用完毕后，一定要还给操作系统，不然就会导致操作系统的内存越来越少，我们的计算机就会变得越来越卡，越来越慢，最后崩溃，所以，内存泄露是一件很可怕的事情。

上面说了那么多，都是C语言中的内存管理方式，那么在C++中，内存该如何管理

首先，C语言的内存管理方式在C++中可以继续使用，毕竟C++是要兼容C语言的，在此同时，C++又提出了一套自己的内存管理方式，其中，C++通过 new 和 delete 来进行动态内存管理的。

void Test()
{
    //动态分配4个字节(1个 int) 的空间单个数据
    int* p1 = new int;

    //动态分配4个字节(1个 int) 的空间并初始化为3
    int* p2 = new int(3);

    //动态分配12个字节(3个 int) 的空间
    int* p3 = new int[3];

    //释放空间
    delete p1;
    delete p2;
    delete[] p3;
}

切记，new 和 delete、new[] 和 delete[] 一定要匹配使用，用new开辟的空间就用delete释放，用new[] 开辟的空间，就有delete[] 释放。

new 也是在堵上开辟空间，delete也是释放空间，那么new 和 malloc、delete 和 free 有什么区别

在C++中，如果不存在自定义类型，都是内置类型，我们用new 申请空间，用free释放空间，这种代码在编译时候，没有什么问题。

如果代码中存在有自定义类型并且析构函数显式给出，不匹配使用的话，会有内存泄露，严重点，程序立马崩溃。所以，再强调一遍：

new 和 delete、new[] 和 delete[] 一定要匹配使用啊！！！！！！！！！！！！！！！！！！！！！！

我们前面讲过实例化对象的时候，一定会用到构造函数。从这里我们可以大致猜到，new 要调用构造函数。

是的，C++对象的new/delete需要分别调用构造函数和析构函数。

new操作符/操作符new

在C++中，new只是一个操作符，new/delete 操作符是C++用来动态管理内存的关键字。

而操作符new/delete是一个函数：

void* operator new(size_t,size);

void* operator delete(size_t size);

void* operator new[](size_t size);

void* operator delete[](size_t size);

简单总结下也就是说：

operator new/operator delete、operator new[]/operator delete[] 和 malloc/free 用法一样，它们只负责分配空间/释放空间，不会调用对象的构造函数 和 析构函数。实际上 operator new 和 operator delete 在底层就是用malloc 和 free 来做的。

但是 new 就做了两件事：

1.调用operator new分配空间

2.调用构造函数初始化对象。

delete也做了两件事：

1.调用析构函数清理对象

2.调用operator delete 释放空间

new[N]

1.调用operator new 分配空间

2.调用N次构造函数初始化每个对象

delete[N]

1.调用N次析构函数清理对象，这里有个小秘密，编译器在new出的数组对象头指针位置前4个字节中记录了对象的个数(4个字节对应一个int) 结合。我们在用new[] 申请空间的时候，实际上的大小要比我们想要的大小多出4个字节，这4个字节就是来记录创建了多少个对象，在后面调用delete[]的时候，就会调用析构函数多少次。

2.调用operator delete 释放空间

定位new 表达式

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

new(place_address)type (不带参)

new (place_address)type(initializer-list) （带参）

其中，place_address必须是一个指针，initializer-list是类型的初始化列表，定位new表达式的实际调用：

T* ptr1 = allocator<T>.allocate(1); //从池对象中申请对象对应的空间， T为对象类型
new(ptr)T; //显式调用T类型的构造函数进行初始化

定位new表达式多用于对象池化处理，最常见的就是内存池技术。

对象池化就是将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来使用，从而在一定的技术上减少频繁创建对象所造成的开销，用于充当保存对象的“容器”的对象，被称为“对象池”.

总结一下前面的 malloc / free / new / delete 的区别与联系

它们都输动态管理内存的入口

malloc / free 是C/C++ 标准库的函数，new/delete 是C++ 操作符

malloc / free 只是动态分配内存空间/释放空间。而new / delete 除了分配空间还会调用构造函数和析构函数进行初始化和清理

malloc / free 需要手动计算类型的大小且返回值是 void* ，而new/delete 可自己计算类型的大小，返回值是对应类型的指针。

特殊要求的类的设计：

设计一个类，该类只能在堆上创建对象。

我们可以将构造函数声明为private，但是为了创建该类的对象，我们必须提供创建对象和释放对象的接口，用static函数成员实现。

#include<iostream>
using namespace std;

class HeapOnly{
public:
    static HeapOnly *CreateInstance()
    {
        HeapOnly* obj = new HeapOnly();
        obk->m = 2;
        return obj;
    }
    
    static void DeleteInstance(HeapOnly* obj)
    {
        if(obj != NULL)
            delete obj;
    }
private:
    HeapOnly(){};
    ~HeapOnly(){};
public:
    int m;
};

int main()
{
    HeapOnly *obj = HeapOnly::CreateInstance();
    cout<<obj->m<<endl;
    HeapOnly::DeleteInstance(obj);
    return 0;
}

设计一个类，该类只能在栈上创建对象

思路：在堆上创建要用到new，为了在类外不能使用new、delete，把new、delete重载为私有

#include <iostream>
using namespace std;

calss StackOnly
{
public:
    StackOnly()
    {
        cout<<"constructor."<<endl;
    }

    ~StackOnly()
    {
        cout<<"destructor"<<endl;
    }
private:
    void* operator new(size_t size);
    void* operator delete(void* ptr);
};

int main()
{
    StackOnly s;
    return 0;
}

设计一个类，该类只能创建一个对象

思路：类实例化对象的时候，需要检查自己是否已经存在同类对象，所以需要静态成员变量，另外还需要提供对外的全局访问方式，所以，需要静态方法来创建于销毁该实例对象

#include <iostream>
using namespace std;

class singleton
{
public:
    static singleton* getpsin()
    {
        if(psin == NULL){
            psin = new singleton();
        }
        return psin;
    }

    static void relice()
    {
        if(psin != NULL){
            delete psin;
        }
        psin = NULL;
    }
private:
    singleton()
    {
        cout<<"++++++"<<endl;
    }
    static singleton* psin;
};

singleton* singleton::psin = NULL;

int main()
{
    singleton* p = singleton::getpsin();
    return 0;
}