| 订阅 | 在线投稿
分享
 
 
 

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

来源:互联网网民  宽屏版  评论
2006-01-09 08:40:22

常见内存泄露及解决方案-选自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> 如果为虚函数,则释放基类指针且该指针指向一个派生类,则会先调用派生类的析构函数,再调用基内的析构函数!

 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
 
常见内存泄露及解决方案-选自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> 如果为虚函数,则释放基类指针且该指针指向一个派生类,则会先调用派生类的析构函数,再调用基内的析构函数!
󰈣󰈤
 
 
 
>>返回首页<<
 
 热帖排行
 
 
静静地坐在废墟上,四周的荒凉一望无际,忽然觉得,凄凉也很美
©2005- 王朝网络 版权所有