C++：内存泄漏的八种情况

最新推荐文章于 2024-07-21 22:14:04 发布

日尼禾尔_怪怪

最新推荐文章于 2024-07-21 22:14:04 发布

阅读量1k

点赞数 1

分类专栏： C++ 文章标签： c++

原文链接：https://www.cnblogs.com/mfrbuaa/p/4265483.html

版权

C++ 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

文章目录

前言
1、在类的构造函数和析构函数中没有匹配的调用new和delete函数
2、没有正确地清除嵌套的对象指针
3、在释放对象数组时在delete中没有使用方括号
4、指向对象的指针数组不等同于对象数组
5、缺少拷贝构造函数
6. 缺少重载赋值运算符
7、关于nonmodifying运算符重载的常见错误
8、没用将基类的析构函数定义成虚函数;
参考

前言

转一篇内存泄漏的情况总结，之后会继续补充的

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

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

也就是说，某个对象以引用语义（指针）了包括还有一个对象，而不是以值的方式。解决的方法：
1〉养成好的成对编码习惯：
在外部函数分配的堆内存，不要在调用函数里面释放，而在外部函数内释放；
2〉尽量在构造函数里面分配内存，并注意不要犯case 1错误；
3〉在基类/继承类各管各的内存；（详细解析见以下的case 8）

#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;
}

3、在释放对象数组时在delete中没有使用方括号

方括号是告诉编译器这个指针指向的是一个对象数组，同时也告诉编译器正确的对象地址值并调用对象的析构函数，如果没有方括号，那么这个指针就被默认为只指向一个对象，对象数组中的其他对象的析构函数就不会被调用，结果造成了内存泄露。如果在方括号中间放了一个比对象数组大小还大的数字，那么编译器就会调用无效对象（内存溢出）的析构函数，会造成堆的奔溃。如果方括号中间的数字值比对象数组的大小小的话，编译器就不能调用足够多个析构函数，结果会造成内存泄露。
释放单个对象、单个基本数据类型的变量或者是基本数据类型的数组不需要大小参数，释放定义了析构函数的对象数组才需要大小参数。
1>对于单个对象，单个基本类型（如int，double等）的变量，我们肯定採用delete，不会出错；
2>对于基本类型数组，因为不须要大小參数，因而，採用delete或array delete（delete []），均能够，如上例中，我便直接採用了delete m_variety,建议为了统一，採用delete []m_variety;
3>对于自己定义的对象所组成的对象数组，则一定要採用array delete,这样编译器才会在释放内存前调用每一个对象的析构函数，并调用free释放对象数组空间；

#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;
}

4、指向对象的指针数组不等同于对象数组

对象数组是指：数组中存放的是对象，只需要delete []p，即可调用对象数组中的每个对象的析构函数释放空间
指向对象的指针数组是指：数组中存放的是指向对象的指针，不仅要释放每个对象的空间，还要释放每个指针的空间，delete []p只是释放了每个指针，但是并没有释放对象的空间，正确的做法，是通过一个循环，将每个对象释放了，然后再把指针释放了
也就是说，数组的基本类型是指向对象的指针,此时，是用delete 还是delete [](array delete),并不重要，关键是指针并没有析构函数，必须用户自己调用delete语句.

//二维指针的开辟与释放的正确姿势
int **b = NULL;
b = new int*[10];
for(int i = 0; i != 10; ++i)
{
     b[i] = new int[50];
     memset(b[i], 0, sizeof(int)*50);
}

//这样就在堆上开辟了int类型的二维指针，大小为10*50，相当于在堆上一个二栈数组int b[10][50];
for(int i = 0; i != 10; ++i)
{
     delete []b[i];
     b[i] = NULL;
}
delete []b;
b = NULL;

//三维指针的开辟与释放的正确姿势
int ***a = NULL;
a = new int**[10];
for(int i = 0; i != 10; ++i)
{
    a[i] = new int*[50];
    for(int j = 0; j != 50; ++j)
    {
        a[i][j] = new int[30];
        memset(a[i][j], 0, sizeof(int)*30);
    }
}

//这样就在堆上开辟了int类型的三维指针，大小为10*50*30，相当于在栈上一个二维数组int a[10][50][30];
for(int i = 0; i != 10; ++i)
{
    for(int j = 0; j != 50; ++j)
    {
       delete []a[i][j];
       a[i][j] = NULL;           
    }
    delete []a[i];
    a[i] = NULL;
}
delete []a;
a = NULL;

参考：https://blog.csdn.net/xdmdth/article/details/50544668

5、缺少拷贝构造函数

两次释放相同的内存是一种错误的做法，同时可能会造成堆的奔溃。
按值传递会调用（拷贝）构造函数，引用传递不会调用。
在C++中，如果没有定义拷贝构造函数，那么编译器就会调用默认的拷贝构造函数，会逐个成员拷贝的方式来复制数据成员（位拷贝），如果是以逐个成员拷贝的方式来复制指针被定义为将一个变量的地址赋给另一个变量。这种隐式的指针复制结果就是两个对象拥有指向同一个动态分配的内存空间的指针。当释放第一个对象的时候，它的析构函数就会释放与该对象有关的动态分配的内存空间。而释放第二个对象的时候，它的析构函数会释放相同的内存，这样是错误的。
所以，如果一个类里面有指针成员变量，要么必须显示的写拷贝构造函数和重载赋值运算符，要么禁用拷贝构造函数和重载赋值运算符

例如以下代码:

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);
}

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约束;

7、关于nonmodifying运算符重载的常见错误

所谓nonmodifying运算符就是不改变操作数的值，而且返回结果类型与操作数一样；比方数学运算符;
而关系运算符则不满足,由于其结果为bool型;
赋值运算符也不是(=, += ,<<=等等);
主要原因是，大家可能将结果保存到一个局部变量里面，而返回结果为了效率采用了引用(&);
1、返回栈上对象的引用或者指针（也即返回局部对象的引用或者指针）。导致最后返回的是一个空引用或者空指针，因此变成野指针
2、返回一个泄露内存的动态分配的对象。导致内存泄露，并且无法回收

补充知识：

野指针：指向被释放的或者访问受限内存的指针。
造成野指针的原因：
指针变量没有被初始化（如果值不定，可以初始化为NULL）
指针被free或者delete后，没有置为NULL, free和delete只是把指针所指向的内存给释放掉，并没有把指针本身干掉，此时指针指向的是“垃圾”内存。释放后的指针应该被置为NULL.
指针操作超越了变量的作用范围，比如返回指向栈内存的指针就是野指针。

解决方法:

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;
}

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];
}

详细实现略!

注意：
该错误具有隐蔽性,当全部派生类均没有新的new操作时，不会产生内存溢出;因而，最好遵循下面原则：
1> 将基类构造函数定义为非虚函数，则该类不同意扩展;
2> 假设不是虚函数，则释放基类指针不会调用派生类的析构函数，即使它指向一个派生类对象;
3> 无论是不是虚函数，释放派生类指针均会调用基类的析构函数，且调用顺序不变;
4> 假设为虚函数，则释放基类指针且该指针指向一个派生类，则会先调用派生类的析构函数，再调用基内的析构函数!