C++类与对象笔记十四：多态六：虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码。
即：父类指针无法调用子类实例对象内的析构函数。造成堆区内存泄漏。
解决方案:将父类中的析构函数改为虚析构或者纯虚析构。
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现。
虚析构和纯虚析构区别：
- 如果是纯虚析构，该类属于抽象类，无法实例化对象。
虚析构语法：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. 拥有纯虚析构函数的类也属于抽象类