C++中避免内存泄露常见的解决方案

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);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"<<std::endl; }// Meal : 进餐; class Meal { public: Meal(char * var, char * res); ~Meal();void print(void); 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 "<<std::endl;; m_pMelon->print(); // 方法2 //m_Melon.print(); } int main(void) { std::cout << "case 2:"<<std::endl;; 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> 如果为虚函数，则释放基类指针且该指针指向一个派生类，则会先调用派生类的析构函数，再调用基内的析构函数!