本文主要是介绍【C++初阶】第五站:C/C++内存管理 (匹配使用,干货到位),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
前言:
本文知识点:
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
:
- 功能:动态分配指定数量、特定类型的内存空间,并初始化为0。
- 特点:不仅分配内存,还会清零初始化。
- 语法:
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++内存管理方式
new/delete操作内置类型
malloc和new对于内置类型都 只会申请空间但不会初始化 ,因为 new没有调构造函数同样对于delete和free来说,都只会释放对象的空间, delete不会调用析构函数
int main()
{int* p3 = (int*)malloc(sizeof(int)); // Cint* 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 对于【自定义类型】除了 开空间 /释放空间 ,还会调用 构造函数和析构函数
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));
}
- malloc没有办法很好地支持动态申请的对象初始化
- new的使用:开空间,加构造函数初始化
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函数(重点)
对于内置类型,在内存分配的基本功能上, 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; }
C++中当开辟空间失败会抛异常,可以通过代码实现捕获异常, 这是C++的一个编程规范, 如果直接用malloc,申请失败会返回NULL。但是如果没有对这个进行处理的话,会将 这个NULL当作返回成功,正常使用了,原本应该是要抛异常的.
底层汇编代码:
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_FINALLYreturn;
}
/*
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后面的空间给释放掉,编译器会报错所以 右边的那副图,没写析构,但没报错的原因是因为 指针的位置没有指向错误。
定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
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申请的空间不会初始化,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;
}
- 在linux下内存泄漏检测:linux下几款内存泄漏检测工具
- 在windows下使用第三方工具:VLD工具说明
- 其他工具:内存泄露检测工具比较
- 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAI思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps:不过很多工具都不够靠谱,或者收费昂贵。
总结一下:
内存泄漏非常常见,解决方案分为两种:1 、事前预防型。如智能指针等。 2 、事后查错型。如泄漏检测工具。
🔧本文修改次数:0
🧭更新时间:2024年3月10日
这篇关于【C++初阶】第五站:C/C++内存管理 (匹配使用,干货到位)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!