前言：
本文知识点：
1. C/C++内存分布2. C语言中动态内存管理方式3. C++中动态内存管理4. operator new与operator delete函数 5. new和delete的实现原理 （干货在此）
6. 定位new表达式(placement-new)7. 常见面试题
目录
C/C++内存分布
1.内存划分题
2.sizeof 和 strlen 区别？
3.计算sizeof和strlen题
C语言中动态内存管理方式：malloc/calloc/realloc/free
malloc/calloc/realloc和free
C++内存管理方式
new/delete操作内置类型
new和delete操作自定义类型
对于单链表的改进
new和delete的应用
operator new与operator delete函数（重要点进行讲解）
operator new与operator delete函数（重点）
new和delete的实现原理
干货在这（了解即可）：
定位new表达式(placement-new)
常见面试题
malloc/free和new/delete的区别
内存泄漏
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.内存划分题
题解:
内存区域划分：
【说明】
1.栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2.内存映射段是高效的 I/O 映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。(未学到linux仅作了解即可)
3.堆用于程序运行时动态内存分配，堆是可以上增长的。
4.数据段--存储全局数据和静态数据。
5.代码段--可执行的代码/只读常量。
2.sizeof 和 strlen 区别？
这篇文章有详细的总结 --> 指针进阶(3) -- 关于sizeof和strlen的详细总结
在C/C++中：
sizeof：这是一个运算符，编译时确定，用于计算变量或类型的大小（以字节为单位），包括数组、指针、结构体等。对于字符数组或字符串，它返回整个数组（包括结束符 \0）的总字节数。
strlen：这是一个库函数，运行时确定，用于计算以 \0 结尾的字符串的实际字符数，不包括结束符 \0。因此，对于包含字符串的字符数组，strlen 返回的是字符串的有效字符数量。
简单地说：
sizeof 计算内存容量；strlen 计算字符串长度。
3.计算sizeof和strlen题
C语言中动态内存管理方式：malloc/calloc/realloc/free
malloc/calloc/realloc和free
#include<stdio.h>#include<malloc.h>int main(){int* p1 = (int*)malloc(sizeof(int));free(p1);int* p2 = (int*)calloc(4, sizeof(int));// 这里需要free(p2)吗？//free(p2);int* p3 = (int*)realloc(p2, sizeof(int) * 10);free(p3);}为什么不需要free(p2)?
因为p2申请了四个字节的空间，此基础上，如果free掉p2,那么p3申请空间的时候，p2指向那块空间已经属于操作系统了，这时候再操作就引发野指针异常
malloc:
void* malloc(size_t size);示例：int *p = (int*)malloc(sizeof(int)*n); 分配n个整数大小的连续内存空间。 calloc:
void* calloc(size_t num, size_t size);示例：int *p = (int*)calloc(n, sizeof(int)); 分配并初始化n个整数大小的连续内存空间为0。 realloc:
void* realloc(void* ptr, size_t new_size);示例：int *new_p = (int*)realloc(p, sizeof(int)*m); 尝试更改指针p指向的内存区域大小为m个整数所需空间，返回新的内存地址，有可能与原地址相同也可能不同。 总的来说：
malloc 用于单纯分配未初始化的内存。calloc 用于分配并初始化为零的内存。realloc 用于调整已分配内存区域的大小，提供了一种灵活的内存管理手段。 更多详细内容请移步到 --> 【C进阶】-- 动态内存管理
C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因 此C++又提出了自己的内存管理方式：通过 new和delete 操作符进行动态内存管理。new/delete操作内置类型
内置类型是几乎是一样的: malloc和new对于内置类型都 只会申请空间但不会初始化 ,因为 new没有调构造函数 同样对于delete和free来说，都只会释放对象的空间， delete不会调用析构函数int main(){ int* p3 = (int*)malloc(sizeof(int)); // C int* p4 = new int;//这个地方还是随机值(内置类型不会调构造) free(p3); delete p4;}
对于内置类型的详细例子
include<stdio.h>#include<malloc.h>#include<iostream>using namespace std;int main(){//不会初始化的例子 int* p2 = (int*)malloc(sizeof(int));//自动计算大小,不需要强转，动态申请一个int类型的空间 int* p3 = new int;//动态分配一块足够存储 10 个整数的连续内存空间 int* p4 = (int*)malloc(sizeof(int) * 10);// 动态申请10个int类型的空间 int* p5 = new int[10];//malloc的释放方式 //free(p2); //free(p4);//new的释放方式 //delete p3; //delete[] p5;//会初始化的例子//额外支持空间 + 初始化//动态申请一个int类型的空间 int* p6 = new int(10);// 动态申请10个int类型的空间,并初始化前三个 int* p7 = new int[10]{ 1,2,3 };// 动态申请10个int类型的空间 int* p8 = new int[10]{};return 0;}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用 new[]和delete[],注意：匹配起来使用！！！
还需注意的是：
new和delete操作自定义类型
new/delete 和 malloc/free 最大区别是： new/delete 对于【自定义类型】除了 开空间 /释放空间 ，还会调用 构造函数和析构函数 示例：int main(){A* p1 = (A*)malloc(sizeof(A));A* p2 = new A(1);free(p1);delete p2;}
自定义类型A,代码示例:
class A{public:A(int a=0):_a(a){cout << "A()" << endl;}~A(){cout << "~A()" << endl;}private:int _a;};int main(){//malloc没有办法很好地支持动态申请的对象初始化A* p1 = (A*)malloc(sizeof(A));}
int main(){ A* p2 = new A; //0也是初始化，如果没有初始化就是随机值了 A* p3 = new A(3);}执行：
delete的使用:自定义类型，调用析构函数+释放空间
int main(){//开空间，加构造函数初始化 A* p2 = new A;A* p3 = new A(3);//调用析构函数+释放空间delete p2;delete p3;}
调用默认构造初始化
int main(){ A* p4 = new A[10];delete[] p4;}
调用显示构造初始化
int main(){ A aa1(2);A aa2(3);A* p5 = new A[10]{ aa1,aa2 };//使用有名对象进行数组初始化delete[] p5;}
使用了匿名对象进行数组初始化
int main(){ A* p6 = new A[10]{ A(1),A(2)};//使用了匿名对象进行数组初始化delete[] p6;}
使用int型数据进行数组初始化
总结：
在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，
而malloc与 free不会
对于单链表的改进
原单链表：【数据结构】C--单链表
改进后：
#include <iostream>using namespace std;struct ListNode{int _val;ListNode* next;ListNode(int _val = 0):_val(_val), next(nullptr) {}};// 打印链表函数void PrintList(ListNode* head) {while (head != nullptr) {cout<<head->_val;if (head->next != nullptr) {cout << "->";}head = head->next;}cout << endl;}int main() {ListNode* n1 = new ListNode(1);ListNode* n2 = new ListNode(2);ListNode* n3 = new ListNode(3);ListNode* n4 = new ListNode(4);ListNode* n5 = new ListNode(5);n1->next = n2;n2->next = n3;n3->next = n4;n4->next = n5;n5->next = nullptr;PrintList(n1); // 调用函数打印链表// 记得在最后释放内存...delete[] n1;return 0;}
new和delete的应用
尝试：返回一个指向栈对象的指针 以下的写法均不可取：
改正： 
代码： #include<iostream>using namespace std;typedef char DataType;class Stack{public:Stack(size_t capacity = 4){cout << "Stack()" << endl;_array = new DataType[capacity];_capacity = 0;_size = 0;}void Push(DataType data){_array[_size] = data;_size++;}~Stack(){cout << "~Stack()" << endl;delete[] _array;_array = nullptr;_size = _capacity = 0;}private:DataType* _array;int _capacity;int _size;};Stack* func(){int n;cin >> n;Stack* pst = new Stack(n);return pst;}int main(){Stack* ptr = func();ptr->Push(1);ptr->Push(2);delete ptr;return 0;}执行：
operator new与operator delete函数（重要点进行讲解）
operator new与operator delete函数（重点）
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是 系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过 operator delete全局函数来释放空间。 对于内置类型，在内存分配的基本功能上， operator new和malloc，以及operator delete 和 free 的 用法几乎是一样的，即都可用于在堆上分配和释放内存
#include<iostream>using namespace std;int main(){//以下三种方式开辟空间和释放空间的效果是一样的int* p1 = (int*)malloc(sizeof(int)); //mallocfree(p1);//freeint* p2 = new int; //newdelete p2;//deleteint* p3 = (int*)operator new(sizeof(int));//operator newoperator delete (p3);//operator deletereturn 0;}
为什么要封装operator new: C++中当开辟空间失败会抛异常，可以通过代码实现捕获异常， 这是C++的一个编程规范， 如果直接用malloc，申请失败会返回NULL。但是如果没有对这个进行处理的话，会将 这个NULL当作返回成功，正常使用了，原本应该是要抛异常的. C++遇到一个 new 和 delete 做了什么事情: 
底层汇编代码： 
operator new与operator delete底层源码 void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc){// try to allocate size bytesvoid *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来释放空间的。
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来释放空间 这里会不会内存泄露? 不会(内置类型)
#include<iostream>using namespace std;int main(){int* p1 = new int[10];//free(p1);delete p1;//delete[]p1;}
对于自定义类型: 
而写没写析构也会出现报错， 原因是指针释放的位置不对 永远记住一个点： 匹配使用！匹配使用！匹配使用！ ( 没有写析构函数是不会报错的，但用free的话可能会导致内存泄露，因为没调析构) 干货在这（了解即可）：
由于编译器的原因,以下的两张图，左边写了析构的，会在申请的空间前面多申请4byte ，然后这4个字节用来存 10(因为new的时候是10个int数据）,注意：这里的存的 10是个数，不是字节 如果用delete[ ]，它就会自动偏移到新开的4byte的空间和后面原本的空间是合并在一起的，所以释放的时候一把释放是没问题，并且是释放了10次(释放不能分期，不能分段) 但是如果你用delete 和free 的话，那编译器就不会偏移了，因为new 或者 malloc 的时候就是那么多，所以你释放的时候就那么多。因此，如果写了析构,这个时候用 delete 或者 free 只会把4byte后面的空间给释放掉，编译器会报错 所以 右边的那副图，没写析构，但没报错的原因是因为 指针的位置没有指向错误。
指针 - 1位置正确，但是析构函数没调够 
定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式： new (place_address) type 或者 new (place_address) type(initializer-list) place_address 必须是一个指针， initializer-list 是类型的初始化列表 使用场景： 定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。 内存池的浅显理解：
在C++中， 构造函数 是不能通过指针或者对象实例名直接调用的，只能在创建对象时自动调用。如果这些内存不是从堆里面获取的， 是从内存池里面获取的，那就需要显示调用构造和析构， include<iostream>using namespace std;内存池int main(){// p1现在指向的只不过是与Stack对象相同大小的一段空间，//还不能算是一个对象，因为构造函数没有执行Stack* pst1 = (Stack*)operator new(sizeof(Stack));//pst1->Stack(4);//不支持new(pst1)Stack(4);//显示调用构造函数 //注意：如果A类的构造函数有参数时，此处需要传参pst1->~Stack();//可以显示调用析构operator delete(pst1);//显示调用析构函数return 0;}
常见面试题
malloc/free和new/delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。 ? 不同的地方是 ： malloc和free是函数，new和delete是操作符 malloc申请的空间不会初始化，new可以初始化 malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，[ ]中指定对象个数即可。malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型。malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需 要捕获异常。申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new 在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成 空间中资源的清理。
内存泄漏
内存泄漏概念与危害 什么是内存泄漏 内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。 内存泄漏并不是指内存在物理上的消失， 而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄露的危害
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现勺存泄漏会导致响应越来越慢，最终卡死。
代码如下：
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;}总结一下:
内存泄漏非常常见，解决方案分为两种：1 、事前预防型。如智能指针等。 2 、事后查错型。如泄漏检测工具。
?本文修改次数：0
?更新时间：2024年3月10日