C++内存管理

c/c++内存分布

说到内存管理，我们先来看一到题目

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);
}
1. 选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____
staticGlobalVar在哪里？____
staticVar在哪里？____
localVar在哪里？____
num1 在哪里？____
char2在哪里？____
*char2在哪里？___
pChar3在哪里？____
*pChar3在哪里？____
ptr1在哪里？____
*ptr1在哪里？___

现在我们来详细说一下
第一题globalVars是在静态区，因为是全局变量；
第二题staticGlobalVar是在静态区，因为是static修饰，在程序结束的时候才会释放
第三题staticVar和上面一样也是在静态区，这个也和上面一样程序结束才会销毁，不受函数作用域的限制
第四题localVar在栈上面，他是在函数内部定义的（函数的建立会创建栈帧空间）
第五题num1也是在栈上面，他也一样在栈上创建的数组，所以在栈上面
第六题char2也是在栈上面，同上
第七题*char2也是在栈上面，他是一个在函数栈上面创建的一个指针变量
第八题pchar3是在常量区上面，他是指向了一个常量字符串
第九题ptr1是在栈上面的，他只是一个指针
第十题 *ptr1是在堆上面的他动态声请了一个数组，动态申请的是在堆上面的
通过上面的题目的讲解，我们就来说说C/C++的内存管理方式
首先我们来看一张图

通过这张图片我们与上面的题目的代码一一对应看一下

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

C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因
此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。就像我们定义的那些自定义类上面C语言的就无能为力了
下面来说说new/delete操作内置类型
来看一个样例

void Test()
{
// 动态申请一个int类型的空间
int* ptr1 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr2 = new int(10);
// 动态申请5个int类型的空间，就像数组一样
int* ptr3 = new int[5];
在del的时候一定要注意匹配操作符，怎么声请的就怎么释放申请和释放，单个元素的空间，
使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。
delete ptr4;
delete ptr5;
delete[] ptr6;
}

new和delete操作自定义类型
我们现在拿个日期类来举个例子

#include<iostream>
# include<stdlib.h>
using namespace std;

class Date
{
public:

	 Date(int year=2000 , int month = 1, int day = 1)
	 {
		 this->_year = year;
		 this->_month = month;
		 this->_day = day;
	 }
	 Date(const Date& d)//拷贝构造函数
	 {
		 this->_day = d._day;
		 this->_month = d._month;
		 this->_year = d._year;
	 }
	 void Print()
	 {
		 cout << _year << "/" << _month << "/" << _day << endl;
	 }
	~Date()
	{
		this->_year = 0;
		this->_month =0;
		this->_day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
	int* _arr;
};
int main()
{
 new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
还会调用构造函数和析构函数
	Date* p1 = (Date*)malloc(sizeof(Date));用C语言的方式来创建
	Date* p2 = new Date(1999, 1, 1);传参数构造
	free(p1);
	delete p2;
	下面是对应内置类型
int* p3 = (int*)malloc(sizeof(int));
int* p4 = new int;

Date* p4 = (Date*)malloc(sizeof(Date)*10);创建10个对象
Date* p5 = new Date[10];
free(p4);
delete[] p5;
	return 0;
}

operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是
系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过
operator delete全局函数来释放空间。

下面是定义opoperator new与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来释放空间的。我们可以通过汇编来看看

同样delete也是通过这样的方式调用到free的，delete是要先调用析构函数，把对象析构完了之后才去调用free,这里要说一个问题，假如一次创建了多个对象，new[]，delete后面一定要加[]，这样才能匹配这里的[]代表要析构多少次，相当于一个标头告诉delete我们new了多少个对象，就要调用多少次析构，如果操作符不匹配，就很容易出错


完