C++ 内存分析（4）

已于 2023-06-06 11:59:59 修改
阅读量69 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2023-04-17 20:15:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DuGuYiZhao/article/details/130208135
版权

菱形虚继承
    菱形虚继承是多继承和虚继承的复合
    验证：顺序
        派生类VPtr虚表;
        派生类VBPtr表;        
        派生类成员；
        公共基类VPtr;
        公共基类成员；
        首个基类VPtr虚表; (继承列表顺序)
        首个基类VBPtr表;
        首个基类成员；
        第二个基类VPtr虚表;
        第二个基类VBPtr虚表
        第二个基类成员；
        …    

环境：VS2017

*.h

//基类3
class FBase3 : virtual public FBase
{
public:
	char m_cBase3Memeber;
public:
	//构造
	FBase3() {}
	//虚析构
	virtual ~FBase3() {}
public:
	virtual void Base3VirtualFun1() { std::cout << "FBase3::BaseVirtualFun1()\n"; }
	virtual void Base3VirtualFun2() { std::cout << "FBase3::BaseVirtualFun2()\n"; }
};
//基类4
class FBase4 : virtual public FBase
{
public:
	char m_cBase4Memeber;

public:
	//构造
	FBase4() {}
	//虚析构
	virtual ~FBase4() {}
public:
	virtual void Base4VirtualFun1() { std::cout << "FBase4::BaseVirtualFun1()\n"; }
	virtual void Base4VirtualFun2() { std::cout << "FBase4::BaseVirtualFun2()\n"; }
};

//菱形虚继承
class FDiamondInheritanceDerive : virtual public FBase4, virtual public FBase3
{
public:
	//构造
	FDiamondInheritanceDerive() {}
	//虚析构
	virtual ~FDiamondInheritanceDerive() {}
public:
	//重写 基类虚函数
	virtual void BaseVirtualFun1() override { std::cout << "FDiamondInheritanceDerive::BaseVirtualFun1()\n"; }
	//重写 基类3虚函数
	virtual void Base3VirtualFun1() override { std::cout << "FDiamondInheritanceDerive::Base3VirtualFun1()\n"; }
	//新增虚函数
	virtual void VirtualFun3() { std::cout << "FDiamondInheritanceDerive::VirtualFun3()\n"; }

public:
	//成员
	char m_cDiamondInheritanceDeriveMemeber;
};

/*	配置属性-》C++ -》命令行： /d1 reportAllClassLayout

//--------------------------------------------x86--------------------------------------------
1>class FDiamondInheritanceDerive	size(40):
1>	+---
1> 0	| {vfptr}
1> 4	| {vbptr}
1> 8	| m_cDiamondInheritanceDeriveMemeber
1>	+---

1>FDiamondInheritanceDerive::$vftable@:
1>	| &FDiamondInheritanceDerive_meta
1>	|  0
1> 0	| &FDiamondInheritanceDerive::VirtualFun3
1>
1>FDiamondInheritanceDerive::$vbtable@FDiamondInheritanceDerive@:
1> 0	| -4
1> 1	| 9 (FDiamondInheritanceDerived(FDiamondInheritanceDerive+4)FBase)
1> 2	| 14 (FDiamondInheritanceDerived(FDiamondInheritanceDerive+4)FBase4)
1> 3	| 27 (FDiamondInheritanceDerived(FDiamondInheritanceDerive+4)FBase3)
1>
1>FDiamondInheritanceDerive::$vftable@FBase@:
1>	| -13
1> 0	| &(vtordisp) FDiamondInheritanceDerive::BaseVirtualFun1
1> 1	| &FBase::BaseVirtualFun2
1>
1>FDiamondInheritanceDerive::$vftable@FBase4@:
1>	| -18
1> 0	| &FDiamondInheritanceDerive::{dtor}
1> 1	| &FBase4::Base4VirtualFun1
1> 2	| &FBase4::Base4VirtualFun2
1>
1>FDiamondInheritanceDerive::$vbtable@FBase4@:
1> 0	| -4
1> 1	| -9 (FDiamondInheritanceDerived(FBase4+4)FBase)
1>
1>FDiamondInheritanceDerive::$vftable@FBase3@:
1>	| -31
1> 0	| &(vtordisp) thunk: this-=13; goto FDiamondInheritanceDerive::{dtor}
1> 1	| &(vtordisp) FDiamondInheritanceDerive::Base3VirtualFun1
1> 2	| &FBase3::Base3VirtualFun2
1>
1>FDiamondInheritanceDerive::$vbtable@FBase3@:
1> 0	| -4
1> 1	| -22 (FDiamondInheritanceDerived(FBase3+4)FBase)
1>

//--------------------------------------------x64--------------------------------------------
1>class FDiamondInheritanceDerive	size(68):
1>	+---
1> 0	| {vfptr}
1> 8	| {vbptr}
1>16	| m_cDiamondInheritanceDeriveMemeber
1>	+---
1>17	| (vtordisp for vbase FBase)
1>	+--- (virtual base FBase)
1>21	| {vfptr}
1>29	| m_cBaseMemeber
1>	+---
1>	+--- (virtual base FBase4)
1>30	| {vfptr}
1>38	| {vbptr}
1>46	| m_cBase4Memeber
1>	+---
1>47	| (vtordisp for vbase FBase3)
1>	+--- (virtual base FBase3)
1>51	| {vfptr}
1>59	| {vbptr}
1>67	| m_cBase3Memeber
1>	+---
1>
1>FDiamondInheritanceDerive::$vftable@:
1>	| &FDiamondInheritanceDerive_meta
1>	|  0
1> 0	| &FDiamondInheritanceDerive::VirtualFun3
1>
1>FDiamondInheritanceDerive::$vbtable@FDiamondInheritanceDerive@:
1> 0	| -8
1> 1	| 13 (FDiamondInheritanceDerived(FDiamondInheritanceDerive+8)FBase)
1> 2	| 22 (FDiamondInheritanceDerived(FDiamondInheritanceDerive+8)FBase4)
1> 3	| 43 (FDiamondInheritanceDerived(FDiamondInheritanceDerive+8)FBase3)
1>
1>FDiamondInheritanceDerive::$vftable@FBase@:
1>	| -21
1> 0	| &(vtordisp) FDiamondInheritanceDerive::BaseVirtualFun1
1> 1	| &FBase::BaseVirtualFun2
1>
1>FDiamondInheritanceDerive::$vftable@FBase4@:
1>	| -30
1> 0	| &FDiamondInheritanceDerive::{dtor}
1> 1	| &FBase4::Base4VirtualFun1
1> 2	| &FBase4::Base4VirtualFun2
1>
1>FDiamondInheritanceDerive::$vbtable@FBase4@:
1> 0	| -8
1> 1	| -17 (FDiamondInheritanceDerived(FBase4+8)FBase)
1>
1>FDiamondInheritanceDerive::$vftable@FBase3@:
1>	| -51
1> 0	| &(vtordisp) thunk: this-=21; goto FDiamondInheritanceDerive::{dtor}
1> 1	| &(vtordisp) FDiamondInheritanceDerive::Base3VirtualFun1
1> 2	| &FBase3::Base3VirtualFun2
1>
1>FDiamondInheritanceDerive::$vbtable@FBase3@:
1> 0	| -8
1> 1	| -38 (FDiamondInheritanceDerived(FBase3+8)FBase)
1>




vtordisp
	vtordisp是一个C++编译器的实现细节，主要用于解决类的多继承中虚函数表指针的偏移问题。在C++多继承中，每个基类都有自己的虚函数表指针，但是在派生类中只能有一个虚函数表指针，所以需要通过vtordisp来计算每个基类的虚函数表指针在派生类中的偏移量，从而实现正确的调用。

vtordisp的具体实现方式因编译器而异，例如在Visual C++中使用了虚基类表和偏移量表来计算偏移量。虚基类表是一个全局表，用于存储虚基类的偏移量和虚函数表指针。偏移量表则是每个类的成员变量之前添加的一段空间，在其中存储了各个基类在当前类中的偏移量，包括虚基类和非虚基类。通过这些表的信息，编译器可以在派生类中正确地计算出每个基类的虚函数表指针在派生类中的偏移量。

需要注意的是，vtordisp只在多继承的情况下才会使用，对于单继承的类，虚函数表指针不需要进行偏移。同时，由于vtordisp是编译器的实现细节，因此不建议在代码中直接使用vtordisp。
*/

*.cpp

/*
菱形虚继承
	菱形虚继承是多继承和虚继承的复合
	验证：顺序	
*/
void DiamondInheritanceDerive_Test()
{
	std::cout << std::endl << std::endl << "------------------------------------DiamondInheritanceDerive_Test-------------------------Start" << std::endl;
	FDiamondInheritanceDerive DiamondInheritanceDerive;
	DiamondInheritanceDerive.m_cBaseMemeber = 10;
	DiamondInheritanceDerive.m_cBase3Memeber = 23;
	DiamondInheritanceDerive.m_cBase4Memeber = 24;
	DiamondInheritanceDerive.m_cDiamondInheritanceDeriveMemeber = 30;

	//结构大小
	STREXE_D(sizeof(DiamondInheritanceDerive));//x64-68;	x86-40;

	//DiamondInheritanceDerive Function
	pFun* DiamondInheritanceDeriveVptr = nullptr;	
	//Base Function
	pFun* BaseF1 = nullptr;
	int nPointerSize = 0;

#ifdef _WIN64
	
	long long *llV_ptr = (long long*)&DiamondInheritanceDerive;
	//首地址
	std::cout << "VPtr地址ll：" << std::hex << *llV_ptr << std::endl;
	std::cout << "&DiamondInheritanceDerive：" << std::hex << &DiamondInheritanceDerive << std::endl;
	STREXE_HEX((long long*)&(DiamondInheritanceDerive.m_cDiamondInheritanceDeriveMemeber));
	STREXE_HEX((long long*)&(DiamondInheritanceDerive.m_cBaseMemeber));
	STREXE_HEX((long long*)&(DiamondInheritanceDerive.m_cBase4Memeber));
	STREXE_HEX((long long*)&(DiamondInheritanceDerive.m_cBase3Memeber));

	//DiamondInheritanceDerive Function
	//pFun* DiamondInheritanceDeriveVptr = nullptr;
	BaseVirtualFun_Test* pBaseVPtr = nullptr;
	BaseVirtualFun_Test* pBase4VPtr = nullptr;
	BaseVirtualFun_Test* pBase3VPtr = nullptr;

	//默认构造内的一个指针，占4个字节
	nPointerSize = sizeof(long long);
	DiamondInheritanceDeriveVptr = (pFun*)((char*)(*llV_ptr));
	//虚基类表指针
	long long * pDiamondInheritanceDeriveMem = (long long *)((char*)(&DiamondInheritanceDerive) + nPointerSize);
	long long * pVbptr = (long long *)((char*)(pDiamondInheritanceDeriveMem)+sizeof(char));
	//long long* lBaseV_ptr = (long long*)((char*)(pVbptr) + nPointerSize);// (long long*)((((char*)pDiamondInheritanceDeriveMem) + nPointerSize));
	//BaseF1 = (pFun*)(*lBaseV_ptr);
	long long* BaseMemeber = (long long*)((char*)(&DiamondInheritanceDerive) + sizeof(DiamondInheritanceDerive) - sizeof(char));
	long long* lBaseV_ptr = (long long*)((char*)(&DiamondInheritanceDerive) + sizeof(DiamondInheritanceDerive) - sizeof(char) - nPointerSize);
	//long long * pVbptr = (long long*)((char*)(&DiamondInheritanceDerive) + sizeof(DiamondInheritanceDerive) - sizeof(char) - nPointerSize - nPointerSize);
	BaseF1 = (pFun*)(*lBaseV_ptr);//140699019104880		0x7FF7 0B0D D270

	
	pBaseVPtr = (BaseVirtualFun_Test*)(long long*)(*(long long*)((char*)&DiamondInheritanceDeriveVptr) + 24);
	pBase4VPtr = (BaseVirtualFun_Test*)(long long*)((long long*)((char*)pBaseVPtr+ 32) );
	pBase3VPtr = (BaseVirtualFun_Test*)(long long*)((long long*)((char*)pBase4VPtr+ 40) );

	//DiamondInheritanceDerive函数调用
	std::cout << "DiamondInheritanceDerive函数调用：--------------------------------" << std::endl;
	STREXE_HEX(DiamondInheritanceDeriveVptr);
	(*DiamondInheritanceDeriveVptr)();
	STREXE_HEX(pBaseVPtr);
	BaseVirtualFun_Test BaseF = *(BaseVirtualFun_Test *)(pBaseVPtr);
	(DiamondInheritanceDerive.*BaseF)();
	STREXE_HEX(pBase4VPtr);
	BaseVirtualFun_Test BaseF4_1 = *(BaseVirtualFun_Test *)(pBase4VPtr + 1);//跳过虚析构函数
	(DiamondInheritanceDerive.*BaseF4_1)();
	BaseVirtualFun_Test BaseF4_2 = *(BaseVirtualFun_Test *)(pBase4VPtr + 2);
	(DiamondInheritanceDerive.*BaseF4_2)();
	//STREXE_HEX(pBase3VPtr);
	BaseVirtualFun_Test BaseF3_1 = *(BaseVirtualFun_Test *)(pBase3VPtr + 1);//跳过虚析构函数
	BaseVirtualFun_Test BaseF3_2 = *(BaseVirtualFun_Test *)(pBase3VPtr + 2);
	(DiamondInheritanceDerive.*BaseF3_1)();
	(DiamondInheritanceDerive.*BaseF3_2)();
#else 
#ifdef _WIN32	
	//首地址
	long *lV_ptr = (long *)&DiamondInheritanceDerive;
	std::cout << "VPtr地址l：" << std::hex << *lV_ptr << std::endl;
	std::cout << "&DiamondInheritanceDerive：" << std::hex << &DiamondInheritanceDerive << std::endl;
	STREXE_HEX((long*)&(DiamondInheritanceDerive.m_cDiamondInheritanceDeriveMemeber));
	STREXE_HEX((long*)&(DiamondInheritanceDerive.m_cBaseMemeber));
	STREXE_HEX((long*)&(DiamondInheritanceDerive.m_cBase4Memeber));
	STREXE_HEX((long*)&(DiamondInheritanceDerive.m_cBase3Memeber));

	//默认构造内的一个指针
	nPointerSize = sizeof(long);
	DiamondInheritanceDeriveVptr = (pFun*)(*lV_ptr);
	//虚基类表指针
	long * pDiamondInheritanceDeriveMem = (long *)((char*)(&DiamondInheritanceDerive) + nPointerSize);
	long * pVbptr = (long *)(((char*)pDiamondInheritanceDeriveMem) + sizeof(char));
	long* lBaseV_ptr = (long*)((((char*)pVbptr) + nPointerSize));
	BaseF1 = (pFun*)(*lBaseV_ptr);
	long* BaseMemeber = (long*)((char*)lBaseV_ptr + nPointerSize);
			
	pFun* pBaseVPtr = nullptr;
	pFun* pBase4VPtr = nullptr;
	pFun* pBase4VBPtr = nullptr;
	pFun* pBase3VPtr = nullptr;
	
	pBaseVPtr = (pFun*)(((char*)DiamondInheritanceDeriveVptr) + 12);
	pBase4VPtr = (pFun*)(((char*)pBaseVPtr) + 16);
	pBase3VPtr = (pFun*)(((char*)pBase4VPtr) + 20);

	//DiamondInheritanceDerive函数调用
	std::cout << "DiamondInheritanceDerive函数调用：--------------------------------" << std::endl;
	STREXE_HEX(DiamondInheritanceDeriveVptr);
	(*DiamondInheritanceDeriveVptr)();	
	STREXE_HEX(pBaseVPtr);
	(*pBaseVPtr)();	
	STREXE_HEX(pBase4VPtr);
	(*(pBase4VPtr + 1))();//跳过虚析构函数
	(*(pBase4VPtr + 2))();
	STREXE_HEX(pBase3VPtr);
	(*(pBase3VPtr + 1))();//跳过虚析构函数
	(*(pBase3VPtr + 2))();


	STREXE_HEX((long *)(((char*)lV_ptr) + 8));
	STREXE_D((char)(*(((char*)lV_ptr) + 8)));
	STREXE_HEX((long *)(((char*)lV_ptr) + 8 + 9));
	STREXE_D((char)(*(((char*)lV_ptr) + 8 + 9)));
	STREXE_HEX((long *)(((char*)lV_ptr) + 8 + 9 + 9));
	STREXE_D((char)(*(((char*)lV_ptr) + 8 + 9 + 9)));
	STREXE_HEX((long *)(((char*)lV_ptr) + 8 + 9 + 9 + 13));
	STREXE_D((char)(*(((char*)lV_ptr) + 8 + 9 + 9 + 13)));
	
	STREXE_HEX(lV_ptr);
	STREXE_HEX(*lV_ptr);
	pFun *pVirtualFun3 = (pFun*)(*(long *)(((char*)lV_ptr) /*+ nPointerSize*/));
	STREXE_HEX(pVirtualFun3);
	//派生类新增虚函数
	(*(pVirtualFun3))(); //FDiamondInheritanceDerive::VirtualFun3()
	//m_cDiamondInheritanceDeriveMemeber
	STREXE_HEX((long *)(((char*)lV_ptr) + 2 * nPointerSize));
	STREXE_D((char)(*(((char*)lV_ptr) + 2 * nPointerSize)));
	//4个未知空间？？？？vtordisp

	//vbptr
	long* vbptr = (long *)((lV_ptr + 1));
	int nDerive2VBPtr = (int)(*(((long*)(*vbptr))));
	STREXE_D(nDerive2VBPtr);//nDerive2VBPtr: -4
	//Base
	int nBase2VBPtr = (int)(*(((long*)(*vbptr)) + 1));
	STREXE_D(nBase2VBPtr);//nBase2VBPtr: 9
	long* pBaseBPtr = (long*)(((char*)vbptr) + nBase2VBPtr);
	pFun * pBaseVirtualFun1 = (pFun *)(*pBaseBPtr);
	(*pBaseVirtualFun1)();//FDiamondInheritanceDerive::BaseVirtualFun1()
	pFun * pBaseVirtualFun2 = (pFun *)(*pBaseBPtr) + 1;
	(*pBaseVirtualFun2)(); //FBase::BaseVirtualFun2()
	//m_cBaseMemeber
	long* pm_cBaseMemeber = pBaseBPtr + 1;
	STREXE_HEX(pm_cBaseMemeber);
	STREXE_D((char)(*pm_cBaseMemeber));
	
	//Base4
	int nBase42VBPtr = (int)(*(((long*)(*vbptr)) + 2));
	STREXE_D(nBase42VBPtr);//nBase42VBPtr: 14
	long* pBase4BPtr = (long*)(((char*)vbptr) + nBase42VBPtr);
	pFun * pBase4VirtualFun1 = (pFun *)(*pBase4BPtr) + 1;//跳过虚析构
	(*pBase4VirtualFun1)(); //FBase4::BaseVirtualFun1()
	pFun * pBase4VirtualFun2 = (pFun *)(*pBase4BPtr) + 2;
	(*pBase4VirtualFun2)(); //FBase4::BaseVirtualFun2()
	//Base4::vbptr
	long* pBase4_vbptr = pBase4BPtr + 1;
	int nVBPtr42VPtr = (int)(*(((long*)(*pBase4_vbptr))));
	STREXE_D(nVBPtr42VPtr);//nVBPtr42VPtr: -4
	int nVBPtr42BaseVPtr = (int)(*(((long*)(*pBase4_vbptr)) + 1));
	STREXE_D(nVBPtr42BaseVPtr);//nVBPtr42BaseVPtr: -9
	//m_cBase4Memeber
	long* pm_cBase4Memeber = pBase4BPtr + 1 + 1;
	STREXE_HEX(pm_cBase4Memeber);
	STREXE_D((char)(*pm_cBase4Memeber));
	//4个未知空间？？？？vtordisp

	//Base3
	int nVBPtr2Base3VPtr = (int)(*(((long*)(*vbptr)) + 3));
	STREXE_D(nVBPtr2Base3VPtr);//nVBPtr2Base3VPtr: 27
	long* pBase3BPtr = (long*)(((char*)vbptr) + nVBPtr2Base3VPtr);
	pFun * pBase3VirtualFun1 = (pFun *)(*pBase3BPtr) + 1;//跳过虚析构
	(*pBase3VirtualFun1)(); //FDiamondInheritanceDerive::Base3VirtualFun1()
	pFun * pBase3VirtualFun2 = (pFun *)(*pBase3BPtr) + 2;
	(*pBase3VirtualFun2)(); //FBase3::BaseVirtualFun2()	
	//Base3::vbptr
	long* pBase3_vbptr = pBase3BPtr + 1;
	int nVBPtr32VPtr = (int)(*(((long*)(*pBase3_vbptr))));
	STREXE_D(nVBPtr32VPtr);//nVBPtr32VPtr: -4
	int nVBPtr32BaseVPtr = (int)(*(((long*)(*pBase3_vbptr)) + 1));
	STREXE_D(nVBPtr32BaseVPtr);//nVBPtr32BaseVPtr: -22
	//m_cBase3Memeber
	long* pm_cBase3Memeber = pBase3BPtr + 1 + 1;
	STREXE_HEX(pm_cBase3Memeber);
	STREXE_D((char)(*pm_cBase3Memeber));//(char)(*pm_cBase3Memeber): 23
	//4个未知空间？？？？vtordisp
#endif
#endif

	std::cout << "------------------------------------DiamondInheritanceDerive_Test-------------------------End" << std::endl;
}

DuGuYiZhao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
【C++】多态 ⑧ ( 验证指向 虚函数表 的 vptr 指针 | 对比定义了虚函数的类和没有定义虚函数类的大小 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-31 379
一、验证指向 虚函数表 的 vptr 指针 是否存在 1、虚函数表与 vptr 指针由来 2、虚函数类与普通函数类对比 - 多出了 vptr 指针的大小
分析c++内存泄露（使用VS 性能探查器）
无人等人的博客
02-21 3226
VS 性能探测器 分析 内存泄露
C++内存管理
须知少日拏云志，曾许人间第一流。
10-21 6003
很多人总是听到栈、堆以及静态区之类的说法，但是始终没有一个完整的概念关于C++程序中内存区域的结构分布。这一期，我们来详细介绍一下C++程序中的内存管理。 我们首先看下图：注释：通常来说，我们创建的局部变量和函数中的参数就是放在栈中。而我们之前动态开辟的内存，其实就是开辟在了堆区中。而全局变量以及通过我们 static 设置为静态的数据都会放在数据段。我们可以知道，在C语言中我们用了malloc以及calloc来进行动态的开辟空间，用free来释放空间。那么，在C++中又是如何进行动态的内存管理的呢？
C/C++内存管理详解
做技术人 · 产优质博客 · 找好工作
07-05 3441
本文主要从C/C++五大内存布局入手，整体贯穿性地介绍C++中new/delete的用法，带你掌握并吃透内存管理技术
C++内存分析工具
xiaofeilongyu的博客
02-28 2641
c++ 内存分析工具
C++内存管理及内存问题的分析
qq_40989769的博客
09-14 1839
写服务端的，内存是一个绕不过的问题，而用C++写的，这个问题就显得更严重。进程的内存持续上涨，有可能是正常的内存占用，也有可能是内存碎片，而C++写的，还有可能是内存泄漏，那就需要一些方法来检测到底是哪些问题引起的。
C++ 内存占用分析（内存泄漏）
chi's blog
01-25 630
在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当导致的。有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。C/C++什么是内存泄露，内存泄露如何避免？
C++内存泄露
Ango_的专栏
04-02 9879
一、内存泄漏是什么 内存泄漏，是指在程序代码中动态申请的、堆上的内存 由于某种原因、在使用后没有被释放，进而造成内存的浪费。 少部分的内存泄漏不会影响程序的正常运行，不过如果是持续的内存泄漏会耗光系统内存，最终会导致程序卡死甚至系统崩溃。为了避免系统崩溃，在无法申请到内存的时候，要果断调用exit()函数主动杀死进程，而不是试图挽救这个进程。 二、如何察觉到它 如果程序在正常地使用过程中，占用的内存随着时间推移不断增长，一般就说明存在内存泄漏的情况。也可以使用专门的工具来检测程序中的内存泄漏： 在
C++内存泄漏排查
lv_zj的专栏
01-13 5203
linux c++内存泄漏排查方案汇总 参考：https://www.cnblogs.com/kex1n/p/11572313.html 使用mtrace分析内存泄漏 参考：https://zhuanlan.zhihu.com/p/83547768
C++内存检查工具
10-16
BoundsChecker能检測的错误包含：1、指针操作和内存、资源泄露错误，比方：内存泄露；资源泄露；对指针变量的错误操作。 2、内存操作方面的错误，比方：内存读、写溢出；使用未初始化的内存。 3、API函数使用错误
C++对象内存分析
01-19
对C++模型的认识可以从本质上提高对语言和各种机制的理解，如果对底层机制一无所知，那么很多高级的机制都只能通过死记硬背的方式来运用，而且有时候有错误，也很难找出原因。C++相对与C语言，编译器做了很多的对...
C++内存管理经典分析
05-20
对于学习C++的兄弟们，内存管理分析是通向C++高手的必备历程 这个文档中把一些经典的内存管理容易出错的地方以及怎么最大程度的控制内存溢出等做了很好的诠释，很值得一看 主要牵涉到指针的应用
C++中类的内存空间大小（sizeof）分析
08-10
在C语言中存在关于结构体的存储空间大小是比较深入的话题，其中涉及计算机的基本原理、操作系统等。我认为对齐是C语言中让很多初学者都拿不准摸不透的问题，特别是在跨...而在Linux中，所有的对齐都是以4个字节对齐。
C++解决大数组栈内存不够问题的方法分析
08-27
主要介绍了C++解决大数组栈内存不够问题的方法,结合实例形式对比分析了C++针对大数组栈内存不足情况的常见解决方法及其优缺点,具有一定参考借鉴价值,需要的朋友可以参考下
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
Ddddddd_158的博客
06-04 321
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
C++/Python/Java AWS S3认证
一个大佬的博客
06-01 903
【代码】C++/Python/Java AWS S3认证。
【C++】B树
FZC206的博客
06-07 81
【代码】【C++】B树。
C语言从头学17——sizeof 运算符
最新发布
m0_72128260的博客
06-07 81
介绍sizeof，C 语言中的一个运算符，我们也可以理解为是一个函数。
C++内存泄漏分析工具
03-05
为了解决和分析C++内存泄漏问题，可以使用以下几种工具： 1. Valgrind：Valgrind是一个开源的内存调试和性能分析工具，它可以检测出内存泄漏、内存错误、线程错误等问题。Valgrind提供了Memcheck工具，可以用于检测...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值