【C++】 C & C++ 内存管理

C、C++ 内存分布

C 和 C++ 的内存分布没什么区别，C++ 是基于 C 语言的，如下：

1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段–存储全局数据和静态数据。
5. 代码段–可执行的代码/只读常量

C++ 内存管理方式

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

1. 操作内置类型

如下，以 int 类型为例。进行了申请一个空间、申请一个空间并初始化、申请3个空间、申请三个空间并初始化，释放空间的例子。
与 malloc 不同的是，用 new 动态申请空间，可以直接初始化。而不是像 C 语言的malloc（不可以初始化）、calloc（全初始化为0），new可以初始化为任意的值。

值得注意的是，如果只申请了一个空间，初始化是用圆括号，如果申请多个空间，初始化是用花括号。
同时，释放空间的时候，如果释放的是超过一个空间，delete后面要紧跟着方括号。

void Test()
{
    // 动态申请一个int类型的空间
	int* ptr1 = new int;
    // 动态申请一个int类型的空间并初始化为10
	int* ptr2 = new int(10);
    // 动态申请3个int类型的空间
	int* ptr3 = new int[3];
    // 动态申请4个int类型的空间并初始化
	int* ptr4 = new int[4] {2，8，9，1};
	delete ptr1;
	delete ptr2;
	delete[] ptr3;
	delete[] ptr4;
}

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。

2. 操作自定义类型

如下代码，对于自定义类型，可以用 malloc 和 new 做对比，delete 和 free 做对比，单步调试查看控制台输出结果，发现：new 会调用构造函数，delete 会调用析构函数。malloc并不会，只是单纯地开辟空间，free也只是单纯释放空间。

这样的话，对于内置类型，其没有构造函数和析构函数，所以是用混着用不会产生什么太大的bug。（并不推荐混着用）
当然，对于像 A 类这样的自定义类型，其不涉及资源的管理，new/malloc、delete/free 用起来其实没有什么区别，但是，对于涉及资源管理的类，就有很大的区别，如Stack类。

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


int main()
{
    // new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;

	A* p5 = (A*)malloc(sizeof(A)*10);
	A* p6 = new A[10]; //  调用十次构造函数
	free(p5);
	delete[] p6;   // 调用十次析构函数
	return 0;
}

对于自定义类型，如果内置成员有指针，指向堆区开辟的一块空间。如果用 free 释放，指针本身固然会被释放，但是其指向的空间，并不会被释放掉，就会造成内存泄漏。

可以用图片来理解上面的内容。Stack类中是有指针成员的，用其来当例子比较合适。下图中，pst 指向的空间是 new 出来的，new 会调用构造函数，所以也会为 _a 指针开辟一块空间。
如果直接 free(pst) ，那么，pst 指针直接指向的那一块空间，固然会被释放。但是由于没有调用析构函数，所以 _a 指向的空间（红色箭头指向的那块）就不会被释放。造成内存泄漏。
同时，观察下图，注意定义对象 和 new出一个对象的区别。 st 是一个对象；pst 是一个指针，指向一个对象。

所以，还是尽量配套使用 new/delete ，不要和 malloc/free 交叉使用。

---

此时就可以对一些混用的错误进行区分：
对于 p1、p2 ，由于都是内置类型，没有构造函数和析构函数，所以混用无所谓。

对于 p3，自定义类型的数组：

• 如果直接 free ，报错。但是去掉A类中的析构函数，就可以。
• 如果 delete 没加 [ ] ，也会产生错误。但是去掉析构函数，就不报错。
• delete[ ] p3; 标准用法。

但是对于 p4 ，其没有涉及资源释放，所以直接 free 可以。

为什么在 p3 中，去掉析构函数，就可以让原本报错的程序，正常运行呢？
因为开辟连续的自定义类型的空间的时候，在开辟空间的前方，额外开辟了一个 int 类型的空间（四个字节），存放着开辟对象的数量，在delete的时候，访问这个空间，就知道要调用几次析构函数。如下图。

编译器在识别的时候，发现 A 类中并没有自定义的析构函数，要让编译器自己生成，但是这里编译器就比较聪明，它评估了一下，觉得不调用析构函数也可以。既然不调用析构函数也无所谓，那么为了析构函数而生的那四个字节的空间也就不用被开辟出来，所以直接 free 掉也没什么错误。

class A {
public:
	A(int a = 10)
	{
		cout << "A()" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	int* p1 = new int;
	free(p1);

	int* p2 = new int[10];
	free(p2);

	A* p3 = new A[10];
	//free(p3);    // 报错。
	delete p3;     // 报错。 把A类中的析构函数去掉，就不报错。
	//delete[] p3; // 标准用法

    A* p4 = new A;
    delete p4;
    
	return 0;
}

我们可以小小地总结一下，对于 malloc 和 free ，无法满足 C++ 自定义类型的动态开辟内存（涉及资源管理），所以，C++ 自己定义了一套 new 和 delete 。虽然有时候，混用不会造成什么错误，但是最好还是匹配着用，不要混用。

operator new 与 operator delete

那么 new 和 delete 的底层原理是什么呢？

operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
operator new 和 operator 并不是 new 和 delete 的重载，前者是全局函数，后者是操作符。（只是取名字取得比较像重载…）

如下，是 operator new 和 operator delete 的底层原理。虽然不能全部看懂，但是大致可以知道，他们分别是用 malloc 和 free 来实现相应的功能的。
其实，operator new 是对 malloc 的封装，operator delete 是对 free 的封装。

//operator new：该函数实际通过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;
}

但是这就让人一脸懵了，operator new 是对 malloc 的封装，那为什么要多此一举呢？两者区别在哪里？看到下面的代码，实际上，operator new 如果开辟空间失败，会抛出异常，而不是返回空指针，这是两者的区别。（看上面的源代码，operator new 返回值是 void* ，所以要强制类型转换）

    int* p = (int*)operator new(sizeof(int));
	int* p1 = (int*)malloc(sizeof(int));
	if (p1 == nullptr) {
		perror("malloc fail");
	}

---

可是 operator new 这样存在的意义又是什么呢？

其实，它是为了 new 服务的。
在我们 new 一个对象的时候，首先要开辟空间（使用operator new），其次要调用它的构造函数。那么开辟空间的话，按照以往的思想是用 malloc 、calloc 的，遇到错误返回空指针。
但是，对于面向对象的语言来说，它如果遇到错误，是要抛出异常。而C语言并没有这样的机制，所以C++中，对malloc进一步封装，有了面向对象特性的 operator new ，遇到错误抛异常。

如下图，从下面代码的汇编代码中，可以看出，先 call operator new，再 call 构造函数。

    // 调用 operator new 开辟空间   operator new -> malloc
	// 调用构造函数
	A* p = new A;

那么 delete 的机制又是什么呢？
类比于new，他就是先调用析构函数，再用 operator delete 释放空间。

	// 先调用析构函数
	// 再 operator delete p5指向的空间  operator deldte -> free
	delete p;

那为什么不是先释放空间，再调用析构函数呢？还是下面这张图，如果直接释放 pst 指向的空间，就会造成这个对象直接被释放了，但是 _a 指向的空间（红色箭头所指处）没有释放。

---

对于一次new出多个对象，其实也是用的上面的机制。

如下代码和汇编，实际上会去调用 operator new[] ，但是 operator new[] 本质上也是去一次次调用 operator new。

	// 先调用 operator new[] 。实际上 operator new[] 也是去调用 operator new
	// 调用十次构造函数
	A* p6 = new A[10];
	
	// 一样，先调用十次析构函数
	// 再调用 operator delete[]
	delete[] p6;

定位 new

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

使用格式：

new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化

如下代码，但是平时使用的时候，先 malloc 再 定位new 很麻烦，直接 new 就可以了。
只不过是有时候为了提升性能，申请内存要向内存池申请，这样子快一些，但是没有初始化；new 是直接向操作系统申请的，相对较慢。

内存池就可以理解为蓄水池。如果住在山里，将溪水挑到蓄水池，这样子用水就很方便，不需要跑到远处溪水去挑。

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

int main()
{
    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

关于 C++ 的内存管理就介绍到这里啦！有错误的地方欢迎指正~