C++内存管理
目录
C/C++内存分布
C语言中的动态内存管理方式
C++内存管理方式
new 和 delete 操作内置类型
new 和 delete 操作自定义类型
初始化方式
operator new与operator delete函数
new和delete的实现原理
内置类型
自定义类型
new的原理
delete的原理
new[N] 的原理
delete[N] 的原理
代码实现+图示
new / delete
new[ ] / delete[ ]
使用时进行匹配原因
1.内置类型
2.自定义类型
malloc/free和new/delete的区别
C/C++内存分布
先来了解下C/C++中的内存区域：栈，堆，静态区，常量区，内存映射区。
有些地方叫法可能不同，比如静态区在操作系统中喜欢叫数据段，了解即可。
既然给内存分了这么多区域，肯定有它的用处，不同区域用来存放不同的数据，区域不同，他们的生命周期也会有所不同。下面是对每个区域的解释：
1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。3. 堆用于程序运行时动态内存分配，堆是可以上增长的。4. 数据段--存储全局数据和静态数据。5. 代码段--可执行的代码/只读常量
栈中存放的是函数栈帧创建时创建的一些变量，堆是用来存放动态开辟的一些数据，如C中的malloc等，C++中new出来的对象，都在堆中存放。
下面是一个练习习题，可以用来帮助理解
图解
答案 C C C A A A A A D A B
*char2 是char2 的地址，char2 在栈上创建，所以*char在栈上；
pchar3是函数栈帧内创建的数组，pchar3在栈上，但是 abcd/0在上面已经创建过了，所以会在字符串常量池中，*pchar3的地址指向常量区；
ptr1在栈中创建，ptr1在栈上，但是他的内容是动态开辟出来的，所以*ptr1在堆上。
C语言中的动态内存管理方式
malloc / calloc /realloc / free
这里不过多讲述C语言中的动态内存管理方式
void Test ()
{
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？
free(p3 );
}malloc：动态开辟空间
calloc：开辟空间时可以初始化，不过只能初始化为零
realloc：扩容；两种方式：原地扩容和异地扩容；
原地扩容：剩余空间够完成扩容，直接在原地址上增加内存空间。
异地扩容：剩余空间不够完成扩容，会新开辟足够的空间，但是指针指向的地
址会变为新的空间地址
所以上述代码中不需要再 free(p2)。
【面试题】1. malloc/calloc/realloc 的区别？2. malloc 的实现原理？ glibc 中 malloc 实现原理
C++内存管理方式
C 语言内存管理方式在 C++ 中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++ 又提出了自己的内存管理方式： 通过 new 和 delete 操作符进行动态内存管理 。
new 和 delete 操作内置类型
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}可以理解为new就是创建，delete就是销毁。
int* a1 = new int[10]{1,2,3};
// 这里前三个会依次匹配 1 2 3 其余会初始化为 0new 和 delete 操作自定义类型
new/delete 和 malloc/free最大区别是 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()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
// 内置类型是几乎是一样的
// 这两句的执行结果是相同的，过程不同。
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
}class A
{
public:
A(int a1 = 0, int a2 = 0)
: _a1(a1)
, _a2(a2)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
// 这两句的结果相同，但过程不同
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1, 1);
// 目的相同，过程不同。
free(p1);
delete p2;
return 0;
}初始化方式
class A
{
public:
A(int a1 = 0, int a2 = 0)
: _a1(a1)
, _a2(a2)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
// 开辟出十个 A 类型的空间
A* p5 = (A*)malloc(sizeof(A) * 10);
// 类类型初始化
A a1(1), a2(2), a3(3);
A* p6 = new A[3]{a1, a2, a3};
A a1 = { 1,1 };
// 使用{} 这里涉及隐私类型转换
A* p6 = new A[10]{ {1,1}, {2,2}, {3,3} };
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
}这里记住new和delete要分别调用构造函数和析构函数即可。
new和delete比malloc和free的优点
1.使用比C简单
2.功能跟健全（比如C语言只能初始化为0）
operator new与operator delete函数
new 和 delete 是用户进行 动态内存申请和释放的操作符 ， operator new 和 operator delete 是系统提供的 全局函数 ， new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
注意：
1. operator new 与 operatro delete 不是对 new 和 delete 的重载。
2. operator new 与 operator delete 是 malloc 和 free 的封装。
3. 可以理解为 new = operator new + 构造 ； delete = 析构 + operator delete
4. 注意 delete 是先析构再 operator delete
new = operator new + 构造 ；delete = 析构 + operator
代码 + 图示
class A
{
public:
A(int a1 = 0, int a2 = 0)
: _a1(a1)
, _a2(a2)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
// 不会调用构造和析构
A* p2 = (A*)operator new(sizeof(A));
operator delete(p2);
// 会调用构造和析构
A* p2 = new A(1, 1);
delete p2;
return 0;
}图示
下述代码不要求能看懂，注意中文注释即可。
/*
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)C++中的抛异常可以理解为C语言中为了避免错误自己写的判断块，例如 0 不能作为被除数用C++抛异常。
new和delete的实现原理
内置类型
如果申请的是内置类型的空间， new 和 malloc ， delete 和 free 基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL 。
内置类型使用一般不会出现问题。主要是自定义类型。
自定义类型
上述我们可知C++内存动态管理操作符有 new / delete / new[] / delete[]
new的原理
1. 调用 operator new 函数申请空间2. 在申请的空间上执行构造函数，完成对象的构造
delete的原理
1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用 operator delete 函数释放对象的空间
new[N] 的原理
1. 调用 operator new[ ] 函数，在 operator new[ ] 中实际调用 operator new 函数完成 N 个对象空间的申请2. 在申请的空间上执行 N次构造函数
delete[N] 的原理
1. 在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源的清理2. 调用 operator delete[ ] 释放空间，实际在 operator delete[ ] 中调用 operator delete 来释放空间
代码实现+图示
class A
{
public:
A(int a1 = 0, int a2 = 0)
: _a1(a1)
, _a2(a2)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
//A* p2 = (A*)operator new(sizeof(A));
//operator delete(p2);
// 核心操作：operator new + 构造函数
A* p2 = new A(1, 1);
A* p3 = new A[10];
// 核心操作：析构函数 + operator delete
delete p2;
delete[] p3;
return 0;
}new / delete
new[ ] / delete[ ]
可以看出此处执行了十次构造和十次析构。
使用时进行匹配原因
这里说的匹配是new 要跟 delete 配合使用，new[ ] 要跟delete[ ]配合使用。
1.内置类型
int main()
{
int* a1 = new int[10];
delete a1;
int* a2 = new int(1);
delete[] a2;
return 0;
}
这里看出编译器会提醒有问题，但程序照常执行，不会报错
2.自定义类型
class A
{
public:
A(int a1 = 0, int a2 = 0)
: _a1(a1)
, _a2(a2)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
A* p7 = new A[10];
delete p7;
return 0;
}
执行断点，出现错误。这里使用 new[ ]创建了 10 个自定义类型，但是使用的是 delete，程序出现错误。 但是如果我们把析构函数注释掉，程序运行就不会报错。这里有兴趣的可以把析构函数注释掉运行查看结果。
为什么自定义类型不匹配时会出现错误？内置类型不匹配时不会报错？
对于自定义类型来说，使用new[10]时，编译器会多开空间来存放这个数字 10 ，可以发现new[N] 时中括号内要填写数字来表明个数，但是delete[]却不需要。这是因为delete[]会向前扫描寻找去找这个存放的数字，来判断需要释放多少空间。
但对于内置类型来说，要开辟10个 int 来说，开辟40个字节的空间。但是对于上述类A，一个类A要8个字节，new[10]出来却需要84个字节，就是多开辟了四个字节空间来存放大小。