c_c++内存管理

• c/c++内存布局
• c++中new和delete
• malloc/free和new/delete的区别
• new和delete的实现原理
• 定位new表达式（placement-new）

一.c/c++内存布局

1. 栈(堆栈)：存放非静态局部变量/函数参数/返回值的地方。栈区是向下增长的
2. 内存映射段：高效的I/O映射方式，用于装载一个共享的动态内存库。用户可以使用系统接口来创建共享内存
3. 堆：在程序运行时，动态内存分配，向上增长
4. 数据段（静态区）：存储全局数据/静态数据
5. 代码段（常量区）：存储可执行代码/只读常量

二.c++中new和delete

c++中使用new/delete操作符来进行动态内存管理。

2.1内置类型的内存管理

c++中，new默认不会初始化空间，但可以初始化。

1. 对于单个元素的空间，初始化：new 类型(初始化值)，释放：delete 空间地址
2. 对于数组，初始化：new 类型[size]{初始化列表}，释放：delete[] 地址空间

int main()
{
    //开辟空间，不初始化
    int *p1 = new int;
    delete p1;
    //开辟空间，初始化为1
    int *p2 = new int(1);
    delete p2;
	//开辟10个元素的数组，不初始化
    int *p3 = new int[10];
    delete[] p3;
    //开辟10个元素的数组，不完全初始化，其他元素默认为0
    int *p4 = new int[10]{1, 2, 3};
    delete[] p4;
    return 0;
}

2.2自定义类型的内存管理

new和delete对于自定义类型的操作和对内置类型的操作是一样的，但new会调用自定义类型的构造函数，delete会调用自定义类型的析构函数。

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

     //调用10次构造函数
     A* p6 = new A[10];
     //调用10次析构函数
     delete[] p6;
    
     return 0;
}

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

1. malloc/free是函数，new/delete是操作符
2. malloc不可以初始化空间，new可以初始化
3. malloc传参需要手动计算空间的大小，new只需要知道个数即可
4. malloc申请空间必须强制类型转换，new不需要
5. malloc申请失败后会返回NULL，所以必须判空，new失败后会抛出异常
6. malloc/free对于自定义类型，不会调用构造函数/析构函数，new/delete会调用构造函数/析构函数

四.new和delete的实现原理

4.1operator new和operator delete函数

new和delete是内存管理的操作符，operator new和operator delete是内存管理的全局函数，new/delete在底层调用了operator new/operator delete，实际上operator new/operator delete底层封装了malloc/free，将malloc分配内存空间失败后返回NULL，改为了抛出异常。

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

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;
}
int main()
{
    //需要强制类型转换，不需要判空
    int *p1 = (int*)operator new(sizeof(int));
    operator delete(p1);

    int *p2 = (int*)malloc(sizeof(int));
    if (p2 == nullptr)
    {
        cout << "Error" << endl;
    }
    free(p2);
    
}

4.2自定义类型

• **new：**new先会调用operator new函数申请空间，然后调用构造函数初始化对象，完成对象的构造。
• **delete：**delete会先调用析构函数，完成对象中资源的清理，然后调用operator delete函数释放对象空间
• **new T[N]：**先会调用operator new[]函数，然后调用operator new函数完成N个对象的空间申请，然后调用N次构造函数初始化
• **delete[] ：**先调用N次析构函数，然后调用operator delete[]释放空间，实际在operator delete[]中会调用operator delete函数

五.定位new表达式(placement-new)

定位new表达式是在已分配的原始空间中调用构造函数初始化对象。
格式：new (空间地址)类型(初始化列表)
使用场景：定位new一般配合内存池使用。因为内存池分配的内存没有初始化所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 1, int b = 2)
		:_a(a)
		,_b(b)
	{}
	~A()
	{
		cout << "~A" << endl;
	}
private:
	int _a;
	int _b;
};
int main()
{

	//自定义类型定位new表达式
	A* p2 = (A*)malloc(sizeof(A));
	if (p2 == nullptr)
	{}
	new(p2)A;
	free(p2);

	return 0;
}