C++内存泄露

C++内存泄露,第1张


一、内存泄漏是什么

内存泄漏,是指在程序代码中动态申请的、堆上的内存 由于某种原因、在使用后没有被释放,进而造成内存的浪费。


少部分的内存泄漏不会影响程序的正常运行,不过如果是持续的内存泄漏会耗光系统内存,最终会导致程序卡死甚至系统崩溃。


为了避免系统崩溃,在无法申请到内存的时候,要果断调用exit()函数主动杀死进程,而不是试图挽救这个进程。



二、如何察觉到内存泄漏

如果程序在正常地使用过程中,占用的内存随着时间推移不断增长,一般就说明存在内存泄漏的情况。


也可以使用专门的工具来检测程序中的内存泄漏:

在vc++中可以使用 VLD(Visual LeakDetector) 进行检测,VLD 是一个免费开源的工具,只需要包含头文件即可,并且可以获取到内存泄漏的代码文件行号。


Tencent tMem Monitor是腾讯推出的一款运行时C/C++内存泄漏检测工具。


TMM认为在进程退出时,堆内存中没有被释放且没有指针指向的无主内存块即为内存泄漏,并进而引入垃圾回收(GC, Garbage Collection)机制,在进程退出时检测出堆内存中所有没有被引用的内存单元,因而内存泄露检测准确率为100%。


gperftools 是 google 开源的一组套件,提供了高性能的、支持多线程的 malloc 实现,以及一组优秀的性能分析工具。


gperftools 的 heap chacker 组件可以用于检测 C++ 程序中的内存泄露问题,它可以在不重启程序的情况下,进行内存泄露检查。



三、内存泄漏是如何产生的

最简单的解释就是,主动申请的内存块在使用后没有被释放。


最常见的几种造成内存泄漏的原因有:

1. malloc/new申请的内存没有主动释放

使用 malloc 申请的内存要主动调用 free,new 申请的内存要主动调用 delete,否则就会导致内存泄漏。


例如下面代码中的内存 ptr 在申请后没有被释放就造成了内存泄漏。


int main(){
	void* ptr = malloc(1);
	// use ptr ...
	return 0;
}
2. 使用free释放new申请的内存

malloc/free以及new/delete必须是各自成对出现,如果混用,就会导致意想不到的情况出现。


另外,如果用delete释放void指针指向的对象同样也会造成内存泄露。


3. 使用delete去删除数组

使用 new 申请的数组,释放的时候要用 delete[] 删除,如果错误地使用 delete 删除,就会造成内存泄漏。


int main(){
	int* ptr = new int[2];
	// usr ptr ...
	// delete ptr; // 错误!释放数组要用 delete[]
	delete[] ptr; // 正确!
	return 0;
}
4. 基类的析构函数没有定义为虚函数

当基类指针指向子类对象时,如果基类的析构函数不是virtual,那么子类的析构函数将不会被调用,子类的资源没有正确是释放,因此造成内存泄露。


例如下面代码中析构函数 ~A() 不是virtual,在调用 delete pa 的时候就不会调用子类 B 的析构函数,该对象中子类 B 中的内存无法被释放干净。


class A
{
public:
	A(){}
	~A(){}
}

class B : public A 
{
public:
	B(){}
	~B(){}
private:
	int num;
}

void main(){
	A* pa = new B();
	delete pa;
}

四、该如何避免内存泄漏

内存泄漏会导致程序不稳定,如果是在一个非常复杂的项目中去排查一处内存泄漏的地方,也是非常让人头疼的一件事情,与其研究如何更好地解决问题,不如研究如何避免问题的发生。


在写代码的时候多花些时间保证代码的质量,往往是一种更为高效的方式。


前期如果为了赶进度,匆匆写下的代码,在后期用则需要更多的时间去填坑,这就是“欲速则不达”。


为了避免内存泄漏的情况,有几种方法可以尝试。


1. 谨慎使用动态内存

在编写代码的时候,对动态内存保持警惕,保证每一块儿申请的内存都要得到释放。


特别是在每个 return 之前,要想一想是否还有内存没有被释放,如果这里不释放,在其他地方是否会正常释放。


这是一种靠脑袋的方式,需要编写代码的时候时刻保持敏感,但是脑袋往往是不可靠的。


最好选用其他的方式来保障。


2. 使用RAII

RAII,全称资源获取即初始化(英语:Resource Acquisition Is Initialization),通过对象的初始化实现资源获取,通过对象的销毁实现资源的释放,我们所说的资源就是动态内存。


RAII要求,资源的有效期与持有资源的对象的生命周期严格绑定,通过构造函数获取资源,通过析构函数释放资源,这样就有效地避免了资源泄漏。


例如下面的例子中,通过 MemBlock 类的构造函数分配内存,通过析构函数释放内存,在需要使用动态内存的地方只需要定义一个 MemBlock 对象 buff,通过成员函数 get() 获取内存地址,使用之后无需手动释放内存,在 buff 离开作用域的时候,buff 会被自动释放(调用析构函数),在析构函数中调用 free 释放 buff 所持有的内存。


如果在所有需要使用内存的地方都用这种方法,只要保证 MemBlock 对象能被析构,就不会造成内存泄漏。


class MemBlock
{
public:
	MemBlock(size_t size) 
	{
		_ptr = malloc(size);
	}
	~MemBlock()
	{
		free(_ptr);
	}
public:
	void* ptr() 
	{
		return _ptr;
	}
protected:
	void* _ptr;
};

void main(){
	MemBlock buff(1024);
	memset(buff.ptr(), 0x00, 1024);
	// 使用内存后无需主动释放
}

当然,如果通过 new 来申请 MemBlock 对象,就又会存在该对象没有被释放的风险,这个时候使用智能指针来存档 MemBlock 对象将会是一个好的选择。


3. 使用智能指针

就是为了解决动态内存的使用安全问题,C++ 才引入了智能指针的概念,智能指针除了具备普通内存的所有功能之外,还可以保证所指向的对象不再被被引用的时候,自动释放该对象。


就这样 C++ 开发人员可以通过智能指针挪走头顶的达摩克里斯之剑。


标准库提供的两种智能指针 shared_ptr 和 unique_ptr,二者的区别在于管理底层指针的方法不同,shared_ptr允许多个指针指向同一个对象,内部通过引用计数知道对象被几个指针引用,当引用为0的时候就是该对象将被释放的时候;unique_ptr 则“独占”所指向的对象,它不能被赋值,智能通过 std::move() 将引用转移到另一个 unique_ptr。


标准库还定义了一种名为weak_ptr的伴随类,它是一种弱引用,作为观察者指向 shared_ptr 所管理的对象,不会改变对象的引用计数。


这三种智能指针都定义在memory头文件中。


使用智能指针直接管理动态内存,在使用之后不需要手动释放,当这段内存不再被引用的时候,这段内存会被调用 free 函数来释放,free函数是作为自定义的释放函数传给智能指针的,如果是其他类型的对象,不需要传入释放函数,会默认调用类型的析构函数来释放。


shared_ptr ptr(malloc(1024), free); // 传入指定的释放函数
//auto ptr = make_shared(malloc(1024), free); // 等价
memset(ptr.get(), 0x00, 1024);

使用智能指针结合RAII管理动态内存,通过 RAII 将内存的申请和释放进行封装,再使用智能指针管理封装后的类对象。


这样实现对内存的自动管理,可以像使用 C# 或 Java 一样使用内存,无需担心内存的释放问题。


结合上面定义的 MemBlock 类:

auto mem = make_shared(1024);
memset(mem->ptr(), 0x00, 1024);
// 使用内存后无需主动释放

内存的申请释放通过MemBlock类的构造函数和析构函数实现,MemBlock 类的对象 mem 使用智能指针管理,不再使用内存的时候,mem 的引用计数变为0,自动被释放析构,同时 free 掉其拥有的内存。


欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/langs/564008.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-04-03
下一篇 2022-04-03

发表评论

登录后才能评论

评论列表(0条)

保存