常见内存泄露及解决方案转自OOD启示录

常见内存泄露及解决方案-选自ood启示录
new/delete,array new/arrray delete匹配
case 1:
在类的构造函数与析构函数中没有匹配地调用 new/delete!

解决方法:检查构造函数,在出现new的情况下,按相反的顺序在析构函数中匹配添加delete!
这里有两个意思:
1〉new与delete匹配,array new/array delete匹配;
2〉出现在前面的new要比出现在后面的new后匹配各自的delete;
比如:
构造函数:
m_x = new int[10];
...
m_y = new cstring;
则析构函数:
delete m_y;
...
delete []m_x;// 对于基本数据类型,用delete也可以,但为了统一,还// 是用array delete

case 2:
没有正确地清除嵌套的对象指针

也就是说,某个对象以引用语义(指针)了包含另一个对象,而不是以值的方式。
解决办法:
1〉养成好的成对编码习惯:
在外部函数分配的堆内存,不要在调用函数里面释放,而在外部函数内释放;
2〉尽量在构造函数里面分配内存,并注意不要犯case 1错误;
3〉在基类/继承类各管各的内存;(具体解析见下面的case 8)

for example:
#include <iostream>
#include <string>

// melon : 甜瓜,西瓜;
class melon
{
public:
melon(char * var);
~melon();
void print(void);

protected:
private:
char * m_variety;
};

melon::melon(char * var)
{
m_variety = new char[strlen(var) + 1];
strcpy(m_variety,var);
}

melon::~melon()
{
delete m_variety;
}

void melon::print()
{
std::cout << "i'm a " << m_variety << "melon/n";
}

// meal : 进餐;
class meal
{
public:
meal(char * var,char * res);
~meal();

void print(void);
protected:
private:
char * m_reastaurant; // 饭店
melon * m_pmelon;
// 方法2
// melon m_melon;
};

meal::meal(char * var,char * res)
// 方法2:改引用为值包含;
// : m_melon(var)
{
m_pmelon = new melon(var);
m_reastaurant = new char[strlen(res) + 1];
strcpy(m_reastaurant,res);
}

meal::~meal()
{
delete m_reastaurant;
delete m_pmelon;// 修改方法1;
}

void meal::print()
{
std::cout << "i'am a meal owned by ";
m_pmelon->print();
// 方法2
//m_melon.print();
}
int main(...)
{
cout << "case 2:/n";
meal m1("honeydew","four seasons"); // 蜜汁,四季饭店;
meal m2("cantaloup","brook manor pub"); // 香瓜,小溪家园酒吧;
m1.print();
m2.print();
return 0;
}

case 3:在释放对象数组时,没有使用delete [];
1>对于单个对象,单个基本类型(如int,double等)的变量,我们肯定采用delete,不会出错;
2>对于基本类型数组,由于不需要大小参数,因而,采用delete或array delete(delete []),均可以,如上例中,我便直接采用了delete m_variety,建议为了统一,采用delete []m_variety;
3>对于自定义的对象所组成的对象数组,则一定要采用array delete,这样编译器才会在释放内存前调用每个对象的析构函数,并调用
free释放对象数组空间;
for example:
#include <iostream>
#include <string>

class point
{
public:
point(int x = 0,int y = 0,char *col = "red");
~point();
protected:
private:
int m_x;
int m_y;
char *m_color;
};

point::point(int x,int y,char *col)
:m_x(x),m_y(y)
{
m_color = new char[strlen(col) + 1];
strcpy(m_color,col);
}

point::~point()
{
delete []m_color;
std::cout << "in the deconstuctor of point!/n";
}

int main(int argc,char *argv[])
{
cout << "case 3:/n";
point *p = new point[5];
delete p;
// 正确方法:
// delete []p;
return 0;
}

case 4:
指向由指向对象的指针构成的数组不等同于与对象数组。
也就是说,数组的基本类型是指向对象的指针,此时,是用delete 还是delete [](array delete),并不重要,关键是指针并没有析构函数,必须用户自己调用delete语句.

for example:
// point类和case 3一样;
int main(int argc,char *argv[])
{
cout << "case 4:/n";
point **pptrary = new point*[10];
// 循环为每个指针分配一个point对象;
int i = 0;
for (; i < 10; ++i)
{
pptrary[i] = new point(i,i,"green");
}

// 下面语句并没有释放10个point对象,释放的只是他们的指针所组成的数组
// 占用的10*sizeof(point*) 空间,造成了内存泄露
// (180 = 10*sizeof(point) + 10* 6; (6= sizeof("green")))
//delete []pptrary;

// 正确的方法:
for (i = 0; i < 10; ++i)
{
delete pptrary[i];
}
delete[]pptrary; // 或者delete pptrary;
return 0;
}

case 5:
缺少拷贝构造函数

这没什么好说的,主要是解决编译器缺省添加的拷贝构造函数不足!缺省的拷贝构造函数采用位拷贝,
如下代码:
point x;
point y(x);
这样会导致两个point对象 x,y的 m_color指向同一个"red"字符串;
当某个对象释放后,另外一个对象的 m_color变成悬空指针,从而导致程序异常;

解决方法:
编写自己的拷贝构造函数;
对于point类,编写如下:
point::point(const point& y)
: m_x(y.m_x),m_y(y.m_y)
{
m_color = new char[strlen(y.m_color) + 1];
::strcpy(m_color,y.m_color);

}

case 6:
缺少重载赋值运算符,理由和上面一样!
需要注意其实现的细节区别:
1> 拷贝构造函数编译器会自动阻止自己构造自己,比如:
point x(x); // 出错;
但是,赋值操作不会;
point x = x; // 编译期不会出错,但运行期会出错!
上面的错误原因在于,编译器虽然为x分配了内存,但调用拷贝构造函数时,m_color还没初始化;
建议,尽量不要用这种方法初始化,以便将错误在编译期间显示出来;
2> 赋值运算符必须区别是否自身赋值;
3> 在赋值前必须释放原有new操作分配的资源(当然,其他文件等资源也要释放,这里只讨论内存溢出,略过不提!)

最后实现如下:
const point& point::operator =(const point& rhs)
{
// 防止自己复制自己
// 这里采用简单的地址比较法,比较安全的是采用com相同的方法编一个唯一编码生成函数;
if (this != &rhs)
{
m_x = rhs.m_x;
m_y = rhs.m_y;
// 删除原有资源空间;
// 必须牢记;
delete m_color;
m_color = new char[strlen(rhs.m_color) + 1];
strcpy(m_color,rhs.m_color);
}
return *this;
}

注意,最左边的const声明可以不要,要得话是为了阻止如下语句:
(x = y) = z;
但由于基本类型也支持,为了与基本类型一致,可以去掉const约束;

case 7:
关于nonmodifying运算符重载的常见错误;
所谓nonmodifying运算符就是不改变操作数的值,并且返回结果类型与操作数一样;比如数学运算符;
而关系运算符则不满足,因为其结果为bool型;
赋值运算符也不是(=,+=,<<=等等);

主要原因是,大家可能将结果保存到一个局部变量里面,而返回结果为了效率采用了引用(&);
解决方法:
1> 利用static,将临时变量作为类的内部存储单元;
不足,不适合嵌套使用和多线程,比如 w = x+y+z;
for example:

// case 7,解决方法1:static
const point& point::operator +(const point& rhs) const
{
static point temp;
temp.m_x = this->m_x + rhs.m_x;
temp.m_y = this->m_y + rhs.m_y;
// 释放前一个值的资源;
delete temp.m_color;
temp.m_color = new char[strlen(this->m_color) + strlen(rhs.m_color) + 1];
sprintf(temp.m_color,"%s%s",this->m_color,rhs.m_color);
return temp;
}

注意,这里为了简单,并没有考虑类型转换,实际中二元运算符通常采用友元函数形式实现,具体判断方法请看effective c++ item 19;

2> 改引用语义为值语义;(最好办法,但会降低效率)
注意,有人也许会用指针方法,比如如下:
point *temp = new point;
...
return (*temp);
这样会产生一个无名对象,并且位于堆上,从而造成内存泄露;

const point point::operator +(const point& rhs) const
{
point temp;
temp.m_x = this->m_x + rhs.m_x;
temp.m_y = this->m_y + rhs.m_y;
// 释放前一个值的资源;
delete temp.m_color;
temp.m_color = new char[strlen(this->m_color) + strlen(rhs.m_color) + 1];
sprintf(temp.m_color,rhs.m_color);
return temp;
}

case 8:
没用将基类的析构函数定义成虚函数;
解决方法:
将基类的析构函数定义为虚函数;

这种情况主要出现在下面情况:
基类指针指向派生类;
for example:
apple is a kind of fruit,and banana also is;
so someone write such codes:

fruit *basket[20];
for (int i = 0; i < 10; ++i)
{
basket[i] = new apple;
// 输入水果信息;
...
}

for (; i < 20; ++i)
{
basket[i] = new banana;
// 输入香蕉信息;
...
}

// 如果fruitde析构函数不是虚函数,则会造成内存溢出(假设apple或banana的构造函数中有new语句,否则不会)
for (i = 0; i < 20; ++i)
{
delete basket[i];
}
具体实现略!

注意:1> 该错误具有隐蔽性,当所有派生类均没有新的new操作时,不会产生内存溢出;因而,最好遵循以下原则:将基类构造函数定义为非虚函数,则该类不允许扩展;2> 如果不是虚函数,则释放基类指针不会调用派生类的析构函数,即使它指向一个派生类对象;3> 不管是不是虚函数,释放派生类指针均会调用基类的析构函数,且调用顺序不变;

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐


什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结;使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性;设计模式使代码编制  真正工程化;设计模式使软件工程的 基石脉络, 如同大厦的结构一样;并不直接用来完成代码的编写,而是 描述 在各种不同情况下,要怎么解决问题的一种方案;能使不稳定依赖于相对稳定、具体依赖于相对抽象,避免引
单一职责原则定义(Single Responsibility Principle,SRP)一个对象应该只包含 单一的职责,并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t
动态代理和CGLib代理分不清吗,看看这篇文章,写的非常好,强烈推荐。原文截图*************************************************************************************************************************原文文本************
适配器模式将一个类的接口转换成客户期望的另一个接口,使得原本接口不兼容的类可以相互合作。
策略模式定义了一系列算法族,并封装在类中,它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码,它是针对软件开发中经常遇到的一些设计问题,总结出来的一套通用的解决方案。
模板方法模式在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中,使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤。
迭代器模式提供了一种方法,用于遍历集合对象中的元素,而又不暴露其内部的细节。
外观模式又叫门面模式,它提供了一个统一的(高层)接口,用来访问子系统中的一群接口,使得子系统更容易使用。
单例模式(Singleton Design Pattern)保证一个类只能有一个实例,并提供一个全局访问点。
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构,使得客户可以用一致的方式处理个别对象和对象组合。
装饰者模式能够更灵活的,动态的给对象添加其它功能,而不需要修改任何现有的底层代码。
观察者模式(Observer Design Pattern)定义了对象之间的一对多依赖,当对象状态改变的时候,所有依赖者都会自动收到通知。
代理模式为对象提供一个代理,来控制对该对象的访问。代理模式在不改变原始类代码的情况下,通过引入代理类来给原始类附加功能。
工厂模式(Factory Design Pattern)可细分为三种,分别是简单工厂,工厂方法和抽象工厂,它们都是为了更好的创建对象。
状态模式允许对象在内部状态改变时,改变它的行为,对象看起来好像改变了它的类。
命令模式将请求封装为对象,能够支持请求的排队执行、记录日志、撤销等功能。
备忘录模式(Memento Pattern)保存一个对象的某个状态,以便在适当的时候恢复对象。备忘录模式属于行为型模式。 基本介绍 **意图:**在不破坏封装性的前提下,捕获一个对象的内部状态,并在该
顾名思义,责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的链。这种模式给予请求的类型,对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为
享元模式(Flyweight Pattern)(轻量级)(共享元素)主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结