C/C++动态内存管理

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内
存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。栈是向下增长的。

2. 堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。堆是可以上增长的。

3. 数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。

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

一、C语言中的malloc/calloc/realloc和柔性数组

1、malloc和free

C语言提供了⼀个动态内存开辟的函数：

void* malloc (size_t size);

这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。

 (1)如果开辟成功，则返回⼀个指向开辟好空间的指针。

 (2)如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。

 (3)返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使用者  自己来决定。

 (4)如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

C语言提供了另外⼀个函数free，专⻔是⽤来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

free函数⽤来释放动态开辟的内存。

(1) 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

(2 )如果参数 ptr 是NULL指针，则函数什么事都不做。

2、 calloc和realloc

C语言还提供了⼀个函数叫 calloc ， calloc 函数也⽤来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全为0。对申请的内存空间的内容要求初始化，那么可以很放便的使用calloc函数来完成任务。示例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *p = (int*)calloc(10, sizeof(int));
    if(NULL != p)
    {
        int i = 0;
        for(i=0; i<10; i++)
        {
          printf("%d ", *(p+i));
        }
    }
    free(p);
    p = NULL;
    return 0;
}

realloc 函数可以做到对动态开辟内存大小的调整，函数原型如下：

void* realloc (void* ptr, size_t size);

(1)ptr 是要调整的内存地址。

(2)size 调整之后新大小。

(3)返回值为调整之后的内存起始位置。

 (4)这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

这里要注意realloc的两种情况：

(1)原有空间之后有足够大的空间，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

(2)原有空间之后没有足够大的空间，在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是⼀个新的内存地址。

3、柔性数组

C99 中，结构体中的最后⼀个元素允许是未知大小的数组，这就叫做柔性数组成员。

struct st_type
{
int i;
int a[];//柔性数组成员
};

特点：

结构中的柔性数组成员前面必须至少⼀个其他成员。

sizeof 返回的这种结构大小不包括柔性数组的内存。

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该⼤于结构的大小，以适应柔性数组的预期大小

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
int main()
{
    printf("%d\n", sizeof(type_a));//输出的是4
    return 0;
}

柔性数组优点：

（1）放便内存释放

如果我们的代码是在一个给别⼈用的函数中，你在里面做了⼆次内存分配，并把整个结构体返回给
用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给用户⼀个结构体指针，用户做⼀次free就可以把所有的内存也给释放掉。

（2）有利于访问速度

连续的内存有益于提⾼访问速度，也有益于减少内存碎片。

小试牛刀：

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);
}

globalVar在哪里？____静态区（全局变量，静态变量放在静态区）

staticGlobalVar在哪里？____静态区

staticVar在哪里？____静态区

localVar在哪里？____栈

num1 在哪里？____栈

char2在哪里？____栈

*char2在哪里？___栈（char2由常量字符串进行初始化，即将常量字符串的内容复制到char2的空间（在栈上开辟），*char2获取的是char2数组的第一个字符，所以*char2是在栈上）

pChar3在哪里？____栈(const修饰的是pChar3所指向的内容不可修改，而pChar3是可以修改它的指向的。所以pChar3的类型就是指针变量，在栈开辟)

*pChar3在哪里？____常量区（pChar3是一个指针变量，存的常量区的地址，*pChar3就是访问的常量区）

ptr1在哪里？____栈

*ptr1在哪里？____堆区

二、C++中的new和delete

C++仍然可以用C语言的那一套东西，但是C++也有自己的一套东西，且有些情况下用C语言的开辟方式是行不通的。

1、new/delete操作内置类型

void Test()
{
    
    int* ptr1 = new int;// 动态申请一个int类型的空间
    
    int* ptr2 = new int(10);// 动态申请一个int类型的空间并初始化为10
    
    int* ptr3 = new int[3];// 动态申请3个int类型的空间
  
    int* ptr4 = new int[3]{1,2,3};  //动态申请3个int类型的空间,并初始化
    //注意这里ptr4和ptr3所指向的空间为sizeof(int)*4个字节（也就是16个字节）
    //多开一个字节的位置，是用于存储空间中元素个数的大小，
    //因为delete[]底层是要获取这个数的，从而达到释放空间的作用。
    //所以new和delete最好要配套使用
    delete ptr1;
    delete ptr2;
    delete[] ptr3;
    delete[] ptr4;
}

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和
delete[]。

对于内置类型而言，new/delete和malloc/free,没有什么区别

2、 new和delete操作自定义类型

class Test
{
public:
    Test()
    : _data(0)
    {
    cout<<"Test():"<<this<<endl;
    }
    ~Test()
    {
    cout<<"~Test():"<<this<<endl;
    }
private:
    int _data;
};
void Test1()//c
{
    // 申请单个Test类型的空间
    Test* p1 = (Test*)malloc(sizeof(Test));
    free(p1);
    // 申请10个Test类型的空间
    Test* p2 = (Test*)malloc(sizoef(Test) * 10);
    free(p2);
}
void Test2()//c++
{
    // 申请单个Test类型的对象
    Test* p1 = new Test;
    delete p1;
    // 申请10个Test类型的对象
    Test* p2 = new Test[10];
    delete[] p2;
}

对于自定义类型，如果用malloc则不会对对象初始化，而类的有些成员为私有不可访问，所以开了空间后再初始化是行不通的。

但是new开了空间后会调用类的默认构造，从而完成了初始化。

在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

3、operator new与operator delete函数

(1)new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过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 );
    __FINALLY
    _munlock(_HEAP_LOCK); /* release other threads */
    __END_TRY_FINALLY
    return;
}

//free的实现
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

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

下面代码演示了，针对链表的节点ListNode通过重载类专属 operator new/ operator delete，实现链表节点使用内存池申请和释放内存，提高效率。

struct ListNode
{
    ListNode* _next;
    ListNode* _prev;
    int _data;
    void* operator new(size_t n)
    {
        void* p = nullptr;
        p = allocator<ListNode>().allocate(1);
        cout << "memory pool allocate" << endl;
        return p;
    }
    void operator delete(void* p)
    {
        allocator<ListNode>().deallocate((ListNode*)p, 1);
        cout << "memory pool deallocate" << endl;
    }
};
class List
{
public:
    List()
    {
        _head = new ListNode;
        _head->_next = _head;
        _head->_prev = _head;
    }
    ~List()
    {
        ListNode* cur = _head->_next;
        while (cur != _head)
        {
            ListNode* next = cur->_next;
            delete cur;
            cur = next;
        }
        delete _head;
        _head = nullptr;
    }
private:
    ListNode* _head;
};
int main()
{
    List l;
    return 0;
}

(2)new和delete的实现原理

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

自定义类型：

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来释放空间

4、定位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类的构造函数有参数时，此处需要传参
}

代码：

class A {
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A " << _a << endl;
	}
	~A()
	{
		cout << "~A " << _a << endl;
	}
private:
	int _a;
};
int main()
{

	//A* p1 = new A;//调用operate new（malloc+抛异常） 和 默认构造
	//A* p2 = new A(1);//调用operate new（malloc+抛异常） 和 带参构造
	//delete p2;
		//A* p1 = (A*)operator new(sizeof(A));
		//new(p1)A;//定位new调用默认构造函数
		//new(p1)A(1);//定位new调用代参构造函数
	//delete p1;//调用operator delete（free+其他） 和 析构
		//p1->~A();//调用析构
		//free(p1);
	
	//int* p3 = new int[10] {0};//调用operator new[T]（底层调用多次operator new + 构造）  	
	//delete[] p3;
	
	//A* p2 = new A[10]{ 1,2,3,4 };
		A* p2 = (A*)operator new(sizeof(A) * 10);
		new(p2)A[10]{ 1,2,3,4,5 };
		
		for (int i = 0;i < 10;i++)
		{
			new(p2 + i)A(i);
		}
	//delete[] p2;
		for (int i = 0;i < 10;i++)
		{
			(p2 + i)->~A();//调用多次析构
		}
		free(p2);
	return 0;
}

三、总结

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