C/C++内存分布
- 一、C/C++内存分布
- 总结
- 二、C++内存管理方式
- 前言:C语言中动态内存管理方式:malloc/calloc/realloc/free
- 一、C++内存管理方式
- (一)new/delete操作内置类型
- (1)new : `new + 类型( 开辟的类型 )+ `[]` ( `[]` 代表开辟空间的数量 ) + `{}`( 初始化的的内容 )`
- (2)delete 调用析构函数+释放空间
- (3)new/delete 和 malloc/free最大区别是:是在于对自定义类型的操作
- (二)operator new与operator delete函数(重要点进行讲解)
- (三)new和delete的实现原理 总结
- (四)定位new表达式(placement-new) (了解)
- (五)常见面试题
- 二、内存泄漏
一、C/C++内存分布
(1)对比全局变量
// 对比全局变量
//**链接属性**的区别:
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);
}
链接属性的区别:
int globalVar; // 所有文件都能用
static int staticGlobalVar; // 只能在当前文件里用
static int staticVar; // 只能在作用域里能用
在整个生命周期都能用
总结
【说明】
-
栈:又叫堆栈 – 非静态 局部变量/函数参数/返回值等等临时变量,栈是向下增长的。
函数建立栈帧,存储临时变量
-
内存映射段“:是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存,做进程间通信。(Linux课程如果没学到这块,现在只需要了解一下)
-
堆:用于程序运行时动态内存分配,堆是可以上增长的。
-
数据段 【静态区】:存储全局数据和静态数据。
-
代码段 【常量区】:可执行的代码 、只读数据(包含 常量)
常量区,修改会报错
常量区存放 二进制的代码( 指令 cpu才能看的懂 )
-
我们敲写的代码(就是一个文件) 都存在 磁盘 里
*char2
char2 数组名 => 首元素的地址,*char2 ( *地址=> )在栈中
const char* pChar3 【 这里的const 修饰的是指针指向的内容*p ,而不是p本身 】
char2数组内容在常量区,把内容拷贝过去栈中数组开辟的空间里
[]方括号 的定义本质是将常量区的字符串内容拷贝过来
pChar3 是指针变量(临时变量存在栈中),实际中应该存的是地址
常变量:常属性的变量
字面量:常量的值,默认会给字面量进行类型识别,好传
二、C++内存管理方式
前言:C语言中动态内存管理方式:malloc/calloc/realloc/free
void Test ()
{
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 );
}
【面试题】
-
malloc/calloc/realloc的区别?
-
malloc的实现原理 ? glibc中malloc实现原理
C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力。好比 :
-
malloc后 不好初始化 无法对私有成员变量进行初始化。
而且使用起来比较麻烦。 -
构造函数是在实例化对象时自动调用,无法显式调用,malloc 不方便解决 动态申请的自定义类型对象的初始化问题
因此C++又提出了自己的内存管理方式:通过new和delete 操作符 进行 动态内存管理。
一、C++内存管理方式
(一)new/delete操作内置类型
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[10];
delete ptr4;
delete ptr5;
delete[] ptr6; //开了多个内存的 new[],也要对应的delete也要加上[]
}
malloc:单纯开空间
(1)new : new + 类型( 开辟的类型 )+
[] (
[]代表开辟空间的数量 ) +
{}( 初始化的的内容 )
语法:new + 类型( 开辟的类型 )+ []
( 对象个数 ) + {}
( 初始化的的内容 )
- 类型 输入要开辟的数据类型即可,不需要强转
[ ]
自动识别前面输入的类型,自动算sizeof大小
初始化
- 单个数据进行初始化
new + 类型 +
()
- 多个数据进行初始化
new + 类型 +
[]
+ {} ({}
中放要用于初始化的多个值 )
后面的值就默认初始化为0
(2)delete 调用析构函数+释放空间
要与 new 对应匹配
new/delete 与 malloc/free 对于内置类型,于底层而言没有什么区别,除了用法上,和检查方式不一样
(3)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;
}
-
对于内置类型 的对象 申请和释放
new和malloc (malloc失败会返回nullptr,要检查一下是否为nullptr)(new失败:抛异常)
抛出 bad_alloc 类型异常。
内存开辟失败 。
cout是自动类型的识别 地址 会被识别成 字符串,要遇到 \0 才能停下来。
try catch 出错会直接跳到出错的地方
除了用法上,没有区别
-
对于自定义类型
new/delete对于 【自定义类型】
除了开空间 ,还会 调用构造函数和析构函数而 malloc/free 不会。
new的本质:开空间+调用构造函数初始化
- 开空间= malloc
- 调用构造函数,初始化
显式调用构造函数 A* p7=new A(1);
delete:调用析构函数+释放空间
C语言库中 没有构造函数的概念 。
(二)operator new与operator delete函数(重要点进行讲解)
(1)operator new与operator delete函数(重点)
-
new/delete 是用户进行 动态内存申请和释放 的 操作符 ; operator new / operator delete 是 系统提供的 全局函数 。
-
new 在 底层调用 “operator new全局函数” 来申请空间,delete 在底层通过 operator delete全局函数 来释放空间 。
-
operator new:该函数 实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间
失败,尝试执行空间不足应对措施,如果改应对措施用户设置了,则继续申请,否则 则会 抛出 bad_alloc 类型异常。
内存开辟失败 -
operator delete: 该函数 最终是通过free来释放空间
/*
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 ); //operator delete: 该函数最终是通过free来释放空间的
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK) //free的实现
(三)new和delete的实现原理 总结
区别一:c 动态内存管理对内置类型很友好,但对自定义类型无法访问类里的私有权限(C++中新加的)=》new:开辟空间 + 自动调用 构造函数
(1)对于内置类型
相同:
如果申请的是内置类型的空间,new和malloc,delete和free基本类似 。
不同的地方是:
- new/delete申请和释放的是单个元素的空间,new[] 和 delete[] 申请的是连续空间。
- 而且 new在申请空间失败时 会抛异常,malloc 会返回NULL。
(2)自定义类型
1. new 的原理
- 调用operator new(全局)函数申请空间【 实际operator new 再调用malloc 】
- 在申请的空间后 执行构造函数,完成对象的构造
2. delete 的原理
- 在空间上执行析构函数,完成对象中资源的清理工作
- 调用operator delete(全局)函数释放对象的空间【 实际operator delete 再调用free 】
3. new T[N] 的原理
- 调用 operator new[] 函数,在operator new[]中 【 实际调用operator new函数完成N个对
象空间的申请 】 - 在申请的空间上执行N次构造函数
4. delete[] 的原理
- 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
- 调用
operator delete[]
释放空间,【 实际在operator delete[]中 调用operator delete来释放空间 】
区别二:不用再根据所存放数据的类型 计算开辟的空间大小了,return的类型不用强转了,用法简便了很多
区别三:new 会抛异常 throw(关键字) =》try catch 出错会直接跳到出错的地方,出现异常就直接跳到catch的地方走
(四)总结
new —> 调用operator new 全局函数 —> malloc
-
new
构造函数开空间 + 初始化 -
new/delete
是 关键字。 -
operate new/operate delete
对应malloc/free
一样,是函数 。malloc在c中要是错了,会返回0/空指针nullptr。new 面向对象失败,不能用返回值处理 => 封装malloc,失败后抛异常 。 -
operate new
不是对new的重载,而是一个 全局的函数,是malloc的封装 】 -
delete 是用来和 new 配对使用的。new 要配对 delete,new[ N ] 要配对 delete [ ]。
第一行是开辟数组的个数,每个自定义类型 多4个字节,留给delete[]
没有要求 [ ] 中给出数组个数,p3减掉4找到前面数组的个数,析构各数组,再free整个对象一开始开辟的空间。
有 [] 才能往前找4个字节 才能完整free掉开辟的数组 。只有delete p4 就只能从p4所指向的地址开始释放,所以不会进行向前开辟4个字节的操作,new[] 才要 。若 new[ N ] 要配对 delete 则会出现:
delete p4 就只能从p4所指向的地址开始释放,所以不会进行向前开辟4个字节的操作,则会泄露前面自定义类型 用于存储数组数量多少 而多开辟的 4个字节 的内存空间 。
所以 new/delete,new[]/delete[] malloc/free,一定要配对使用,否则结果是未定义的 。
(四)定位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)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
// 定位new/replacement new
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
A* p1 = (A*)malloc(sizeof(A));
new(p1)A; // 注意:如果A类的构造函数有参数时,此处需要传参
p1->~A();
free(p1);
A* p2 = (A*)operator new(sizeof(A));
new(p2)A(10);
p2->~A();
operator delete(p2);
return 0;
}
(五)常见面试题
【1】 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在申请空间后 会调用构造函数完成对象的初始化
【c 动态内存管理对内置类型很友好,但对自定义类型无法访问类里的私有权限(C++中新加的)=》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;
}
(三)内存泄漏分类(了解)
C/C++程序中一般我们关心两种方面的内存泄漏:
-
堆内存泄漏 (Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存,用完后必须通过调用相应的 free或者delete 删掉。
假设程序的设计错误导致这部分内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。 -
系统资源泄漏
指 程序使用系统分配的资源,比方 套接字、文件描述符、管道等没有使用对应的函数释放 掉,导致 系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。
(四)如何检测内存泄漏(了解)
在vs下,可以使用windows操作系统提供的**_CrtDumpMemoryLeaks()** 函数进行简单检测,该
函数 只报出了 大概泄漏了多少个字节,没有其他更准确的位置信息。
int main()
{
int* p = new int[10];
// 将该函数放在main函数之后,每次程序退出的时候就会检测是否存在内存泄漏
_CrtDumpMemoryLeaks();
return 0;
}
// 程序退出后,在输出窗口中可以检测到泄漏了多少字节,但是没有具体的位置
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00EC5FB8, 40 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
因此写代码时一定要小心,尤其是动态内存操作时,一定要记着释放。但有些情况下总是防不胜防,简单的可以采用上述方式快速定位下。如果工程比较大,内存泄漏位置比较多,不太好查时,一般都是借助第三方内存泄漏检测工具处理的。
- 在linux下内存泄漏检测:linux下几款内存泄漏检测工具
- 在windows下使用第三方工具:VLD工具说明
- 其他工具:内存泄漏工具比较
(五)如何避免内存泄漏
- 工程前期 良好的设计规范,养成 良好的编码规范,申请的内存空间 记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用 RAII思想 或者 智能指针 来管理资源。
- 有些公司内部 规范使用内部实现的 私有内存管理库。这套库 自带内存泄漏检测的功能选项。
- 出问题了 使用内存泄漏工具检测。ps:不过很多工具都不够靠谱,或者收费昂贵。
总结一下:
内存泄漏非常常见,解决方案分为两种:1、事前预防型。如 智能指针 等。2、事后查错型。如 泄漏检测工具。