编程语言

img zlf_jack

常见内存泄露及解决方案-选自ood启示录

发表于2004/10/17 0:26:00  1376人阅读

分类: 标准C/C++

  常见内存泄露及解决方案-选自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, "%s%s", this->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> 不管是不是虚函数,释放派生类指针均会调用基类的析构函数,且调用顺序不变;
 4> 如果为虚函数,则释放基类指针且该指针指向一个派生类,则会先调用派生类的析构函数,再调用基内的析构函数!

阅读全文
0 0

相关文章推荐

img
取 消
img