一、C/C++内存分布
通过下面的代码来检验你对C/C++的内存分布情况是否熟练掌握：
#include <stdio.h> 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"; 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在哪里？_______
2.填空题
sizeof ( num1 ) = ____ ;
sizeof ( char2 ) = ____ ; strlen ( char2 ) = ____ ;
sizeof ( pChar3 ) = ____ ; strlen ( pChar3 ) = ____ ;
sizeof ( ptr1 ) = ____ ;
解析：
首先，我们要了解一下C/C++中内存的分布情况，掌握每个部分存储的是什么，再对代码进行分析；
二、C/C++中动态内存管理方式
1.C语言中动态内存管理方式
在C语言中我们常常使用这些：malloc / calloc / realloc 和 free 来进行动态申请空间和销毁；
malloc / calloc / realloc这三个动态申请空间有什么区别呢？
1.malloc 和 calloc
malloc 和 calloc成功开辟空间都会返回一个指针(void*)，但是calloc会按字节对每个空间进行初始化0；
2.realloc在开辟空间是，如果是第一次开辟空间，它等同于malloc，当在进行扩容时，会存在两种情况：
①在需要开辟的空间之后，如果空间足够，直接开辟；
②如果不够，会找一块大的空间进行开辟，将原来空间的内容拷贝下来，返回一个指针；
int main() { int* p1 = (int*) malloc(sizeof(int)); free(p1); // 1.malloc/calloc/realloc的区别是什么？ int* p2 = (int*)calloc(4, sizeof (int)); int* p3 = (int*)realloc(p2, sizeof(int)*10); // 这里需要free(p2)吗？ free(p3 ); return 0; }
在上面的代码中，我们每次进行动态开辟空间，都会进行空间释放，这是为了防止 内存泄露；如代码中，p2申请了4个字节的空间，初始化为0；p3在是对p2的一次扩容，最后只是释放了p3，没有释放p2，会存在内存泄露吗？
当然是不会的，给p2扩容，p3是指向这块空间的，释放了p3也就释放了p2，从下面的运行的监视窗口来看，
此图为p2开辟好空间，并进行了扩容，p2和p3所指向的空间地址是一样：
此图为释放p3后的情况：
发现不释放p2也是可以的；
2.C++中动态内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理
void Test() { // 动态申请一个int类型的空间 int* ptr1 = new int; // 动态申请一个int类型的空间并初始化为10 int* ptr2 = new int(10); // 动态申请10个int类型的数组 int* ptr3 = new int[3]; // 动态申请一个int类型的数组并初始化为1,2,3 int* ptr4 = new int[3]{1,2,3}; delete ptr1;//对单个对象的空间进行释放 delete ptr2;//对单个对象的空间进行释放 delete[] ptr3; //对多个对象进行释放 ptr1 = nullptr; ptr2 = nullptr; ptr3 = nullptr; ptr4 = nullptr; }
比较malloc和new，我们知道malloc申请空间，不会进行初始化，new开辟空间，会初始化吗？
从上面的监视窗口可以看出，ptr1和ptr3,都没有初始化，ptr2和ptr4是我们赋值之后进行了初始化；
以上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() { //动态申请单个A对象 和 5个A对象数组 A* p1 = (A*)malloc(sizeof(A)); A* p2 = (A*)malloc(sizeof(A) * 5); //C语言中malloc出来的不会初始化 A* p3 = new A;//C++的new不仅可以把内存开出来，同时会去调用自定义类型的构造函数，进行初始化 A* p4 = new A[5]; //使用new呢，一定要有默认构造 free(p1); free(p2); delete p3;//先调用指针类型的析构函数 + 释放空间给堆上 delete[] p4;//new开辟的空间，不能free/delete混用 return 0; }
通过运行，在监视窗口下，p1和p2是malloc出来的空间，p3和p4是new出来的空间，情况如下：
p1和p2没有对自定义类型进行初始化，只是单独开辟了空间；p3和p4不仅开辟空间，也进行了初始化；
下图为注释掉malloc后，new申请空间的情况：
发现new申请空间时，调用了6次构造函数和6次析构函数，所以new对于自定义类型会进行初始化；
那么new和delete的机制是什么呢？
1.C++的new不仅可以把内存开出来，同时会去调用自定义类型的构造函数，进行初始化；
2.使用new呢，一定要有默认构造；
3.先调用指针类型的析构函数 + 释放空间给堆上；
4.对于new---先申请空间，在调用构造函数；
5.对于delete---先进行析构函数清理资源，在释放空间；
注意：
1.要区分calloc和new的区别：calloc是非常粗暴的，直接将开辟的空间初始化为0，自定义类型的初始化不一定是0；
2.当代码中出现malloc和new一起开辟空间时，在进行释放的时候，一定要注意不能free/delete混用；
3.C/C++处理错误的方式
面向对象的语言，处理错误的方式一般是--->抛异常 ，C++中也要求出错 抛异常 -- try catch
面向过程的语言，处理错误的方式是---> 返回值+错误码解决
int main() { //C语言 char* p1 = (char*)malloc(1024u* 1024u * 1024u *2u); if (p1 == nullptr) { printf("%d\n", errno); perror("malloc fail"); exit(-1); } else { printf("%p\n", p1); } //C++ char* p2 = nullptr; try { //char* p1 = new char[1024u * 1024u * 1024u * 2u - 1]; p2 = new char[1024u * 1024u * 1024u * 2u - 1]; } catch (const std::exception& e) { cout << e.what() << endl;//发生错误后，抛异常，直接跳转到这里 } return 0; }
在上述代码中，对于malloc出来的空间，我们一般都是需要进行检查的，但是在C++中就不需要去检查了，因为在抛异常之后 直接跳转到错误的地方；
C++提出new和delete，主要是解决两个问题：
1.自定义类型对象制动申请的时候，初始化和清理的问题。new/delete会调用构造和析构函数；
2.new失败了以后要求抛异常，这样才符合面向对象语言的处理机制；
注：delete和free一般不会失败，如果失败了，都是是否空间上存在越界或释放指针位置不对；
4.operator new与operator delete函数（重点）
new和delete 是用户进行 动态内存申请和释放的操作符 ， operator new 和operator delete 是系统提供的 全局函数 ， new在底层调用operator new 全局函数来申请空间， delete在底层通过operator delete 全局 函数来释放空间。
class Stack { public: Stack(int capacity = 4) :_top(0) , _capacity(capacity) { _a = new int[capacity]; } private: int* _a; int _top; int _capacity; }; int main() { //和malloc用法是一样的 Stack* pst1 = (Stack*)operator new(sizeof(Stack)); Stack* pst2 = new Stack; operator delete(pst1); delete(pst2); return 0; }
从上图可以看出operator new和malloc是一样的，只是开辟了空间，并没有初始化，这个函数我们也可以用，最关键的还是给new用的；
operator new和operator delete就是对malloc和free的封装；
operator new中调用malloc申请内存，失败后，改为抛异常处理；
本质上new是调用了operator new和构造函数；
operator 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)
5.operator new与operator delete类的专属重载（了解）
在之前学习链表、顺序表等，这些我们都是去动态开辟的空间，只要容量不够，就去开辟，显得很麻烦， 针对链表的节点ListNode通过 重载类专属 operator new/ operator delete ，实现链表节点使用内存池申请和释放内存，提高效率；
//定制专属的operator new struct ListNode { ListNode* _next; ListNode* _prev; int _data; ListNode(int val) :_next(nullptr) ,_prev(nullptr) ,_data(val) {} /**********************************************************************************/ //new会去调用全局的operator new，这里我们自己实现一个operator new，就不会去调用全局的 void* operator new(size_t n) { void* p = nullptr; p = allocator<ListNode>().allocate(1);//STL中的内存池---空间配置器 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(-1); _head->_next = _head; _head->_prev = _head; } void PushBack(int val) { ListNode* newnode = new ListNode(val); ListNode* tail = _head->_prev; tail->_next = newnode; newnode->_prev = tail; newnode->_next = _head; _head->_prev = newnode; } ~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; l.PushBack(1); l.PushBack(2); l.PushBack(3); l.PushBack(4); l.PushBack(5); return 0; }
6.new和delete的实现原理
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常， malloc会返回NULL。
自定义类型：
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来释放空间
7.定位new表达式(placement-new) （了解）
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
class A { public: A(int a = 0) : _data(0) { cout << "A():" << this << endl; } ~A() { cout << "~A():" << this << endl; } private: int _data; }; int main() { // pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行 A* pt = (A*)malloc(sizeof(A)); new(pt) A; new(pt) A(1); }
当malloc出来的空间，是没有进行初始化的，想要去调用它的构造函数，是调用不了的，这时候定位new就起到作用了；
注意：构造函数不支持显示调用，析构函数是可以的；
三、内存泄露重要知识点（重要）
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在释放空间前会调用析构函数完成空间中资源的清理
2.内存泄漏
什么是内存泄漏：
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不
是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会
导致响应越来越慢，最终卡死。
void MemoryLeaks() { // 1.内存申请了忘记释放 int* p1 = (int*)malloc(sizeof(int)); int* p2 = new int; // 2.异常安全问题 int* p3 = new int[10]; Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放. delete[] p3; }
3.内存泄漏分类（了解）
C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)：
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏：
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
4.如何避免内存泄漏
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。注：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。（在后期会进行介绍）
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。
在linux下内存泄漏检测： linux 下几款内存泄漏检测工具
在windows下使用第三方工具： VLD 工具说明
其他工具 ： 内存泄漏工具比较
注：不过很多工具都不够靠谱，或者收费昂贵。
四、总结
作为一名程序员，良好的代码风格，是最基本的素养。内存泄露不是小事，做好每一步的措施，要时时刻刻提醒自己；以上是对C/C++中内存管理的大致概括，若有错误，请联系笔者，加以改正。
