多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用子类的析构代码。
即:父类指针无法调用子类实例对象内的析构函数。造成堆区内存泄漏。
解决方案:将父类中的析构函数改为虚析构或者纯虚析构。
虚析构语法:virtual ~类名(){}
纯虚析构语法:virtual ~类名() = 0;
纯虚函数没有函数体;纯虚析构函数也没有函数体;类似声明,直接赋值为0。
父类将虚函数写为纯虚函数,是因为,子类调用不到,或者说不知道如何写,没有通用写法,所以干脆不要写。
看一个案例:
#include
using namespace std;
class Animal
{
public:
virtual void speak() = 0;
};
class Cat : public Animal
{
void speak()
{
cout << "小猫喵喵叫..." << endl;
}
};
int main()
{
Animal* animal = new Cat; // 必须是指针或者应用类型,否则编译不过去。
animal->speak();
delete animal;
system("pause");
return 0;
}
以上是我们曾经写过的案例:现在我们想在子类Cat上,增加一些新的特性,这个特性是一个指针类型的;比如我们加一个指针类型的名字,这个特性指针保存在堆中。需要我们手动开辟,手动释放。
#include
using namespace std;
#include
class Animal
{
public:
virtual void speak() = 0;
};
class Cat : public Animal
{
public:
Cat(string name)
{
m_Name = new string(name);
}
void speak()
{
cout << "小猫" << *m_Name << "喵喵叫..." << endl; // 解引用
}
private:
string* m_Name;
};
int main()
{
Animal* animal = new Cat("Tom"); // 必须是指针或者应用类型,否则编译不过去。
animal->speak();
delete animal;
system("pause");
return 0;
}
为了释放这个堆区的属性,我们需要写一个析构函数,来手动释放内存。
同时为了捕获执行的先后顺序,我们增加父类的构造函数和析构函数,在里面打印输出执行情况。
#include
using namespace std;
#include
class Animal
{
public:
Animal()
{
cout << "父类Animal构造函数执行完毕。" << endl;
}
~Animal()
{
cout << "父类Animal析构函数执行完毕。" << endl;
}
virtual void speak() = 0;
};
class Cat : public Animal
{
public:
Cat(string name)
{
m_Name = new string(name);
cout << "Cat类构造函数执行完毕。" << endl;
}
~Cat()
{
if (m_Name != NULL) // 如果非空则释放。
{
delete m_Name;
m_Name = NULL;
}
cout << "Cat类析构函数执行完毕。" << endl;
}
void speak()
{
cout << "小猫" << *m_Name << "喵喵叫..." << endl; // 解引用
}
private:
string* m_Name;
};
int main()
{
Animal* animal = new Cat("Tom"); // 必须是指针或者应用类型,否则编译不过去。
animal->speak();
delete animal;
system("pause");
return 0;
}
执行结果:
父类Animal构造函数执行完毕。
Cat类构造函数执行完毕。
小猫Tom喵喵叫...
父类Animal析构函数执行完毕。
我们发现:子类Cat的析构函数并没有执行。堆区数据没有释放干净,导致内存泄漏。
产生的原因:是因为我们用父类的指针指向了子类对象。所以当我们去delete父类指针时,并没有调用子类的析构函数,而是调用了父类的析构函数。导致子类如果有堆区的数据,会出现内存泄漏情况。
为了执行子类的析构函数,需要将父类的析构函数写为虚析构函数。此时就会执行子类的析构函数。把堆区数据释放干净。
#include
using namespace std;
#include
class Animal
{
public:
Animal()
{
cout << "父类Animal构造函数执行完毕。" << endl;
}
virtual ~Animal()
{
cout << "父类Animal析构函数执行完毕。" << endl;
}
virtual void speak() = 0;
};
class Cat : public Animal
{
public:
Cat(string name)
{
m_Name = new string(name);
cout << "Cat类构造函数执行完毕。" << endl;
}
~Cat()
{
if (m_Name != NULL) // 如果非空则释放。
{
delete m_Name;
m_Name = NULL;
}
cout << "Cat类析构函数执行完毕。" << endl;
}
void speak()
{
cout << "小猫" << *m_Name << "喵喵叫..." << endl; // 解引用
}
private:
string* m_Name;
};
int main()
{
Animal* animal = new Cat("Tom"); // 必须是指针或者应用类型,否则编译不过去。
animal->speak();
delete animal;
system("pause");
return 0;
}
输出:
父类Animal构造函数执行完毕。
Cat类构造函数执行完毕。
小猫Tom喵喵叫...
Cat类析构函数执行完毕。
父类Animal析构函数执行完毕。
利用父类虚析构函数可以解决,父类指针释放子类对象时不干净的问题。
虚析构和纯虚析构二者只能有一个。
虚析构和纯虚析构都必须有代码实现:因为假设在父类中也有一些特性开辟在了堆中,那么就需要析构函数来释放,无论这个析构函数是不是虚的。
因此:以下代码会报错:
#include
using namespace std;
#include
class Animal
{
public:
Animal()
{
cout << "父类Animal构造函数执行完毕。" << endl;
}
// 析构函数
//virtual ~Animal()
//{
// cout << "父类Animal析构函数执行完毕。" << endl;
//}
// 纯虚析构函数
virtual ~Animal() = 0; // 只有一个声明,此时如果执行会报错。在链接阶段出现错误,因为析构函数必须要有一个函数实现。为啥?因为假设,我们在父类中也有一些属性开辟到内存堆中,就需要析构函数来释放。
// 纯虚函数
virtual void speak() = 0;
};
class Cat : public Animal
{
public:
Cat(string name)
{
m_Name = new string(name);
cout << "Cat类构造函数执行完毕。" << endl;
}
~Cat()
{
if (m_Name != NULL) // 如果非空则释放。
{
delete m_Name;
m_Name = NULL;
}
cout << "Cat类析构函数执行完毕。" << endl;
}
void speak()
{
cout << "小猫" << *m_Name << "喵喵叫..." << endl; // 解引用
}
private:
string* m_Name;
};
int main()
{
Animal* animal = new Cat("Tom"); // 必须是指针或者应用类型,否则编译不过去。
animal->speak();
delete animal;
system("pause");
return 0;
}
出错的原因
就在:父类的析构函数只有一个类似声明的存在,无法完成释放类空间的作用。
纯虚析构函数:类内声明;类外实现。
有了纯虚析构函数之后,这个类也就属于抽象类了。无法实例化对象。
总结:
如果子类在堆中有数据存放,而父类无法调用子类的析构函数,多态实现中,必须要将父类析构函数写为虚析构函数或者纯虚析构函数。
主要解决的问题是:父类的指针或者引用无法调用子类的析构函数。导致父类无法释放子类在堆中的数据,从而会产生内存泄漏问题。
总结:
- 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
- 2. 如果子类中没有堆区数据,可以不写为虚析构或纯虚析构
- 3. 拥有纯虚析构函数的类也属于抽象类