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> 假设为虚函数，则释放基类指针且该指针指向一个派生类，则会先调用派生类的析构函数，再调用基内的析构函数!

转载自：http://hi.baidu.com/zhujian0622/blog/item/8ccf46d7d5986adca044dfd1.html