虚函数
虚函数是一种成员函数，它允许子类重写（override）父类中定义的函数。
虚函数的重要意义便是实现多态性。
多态性是面向对象编程的一个核心概念：即同一个接口可以有不同的实现,从而实现代码的灵活性和通用性
目录
1.虚函数的定义
2.虚函数的用法
3.纯虚函数和抽象类
4.虚析构函数
5.虚析构函数的作用
6.将派生类的对象并将其赋值给基类指针的意义
虚函数的定义
- 关键字：使用
virtual关键字来声明一个函数为虚函数。 - 目的：允许派生类重写该函数，以提供特定的实现。
- 调用：通过基类的指针或引用调用虚函数时，将根据对象的实际类型来调用相应的函数实现。
虚函数的用法
- 声明虚函数：
class Base
{
public:
virtual void show()
{
std::cout << "Base show" << std::endl;
}//这里定义了一个名为show的虚函数。
};
- 重写虚函数：
class Derived : public Base
{
public:
void show() override // 使用override关键字可以明确表示重写
{
std::cout << "Derived show" << std::endl;
}
};
此时，Base的子类Derived调用show函数时，将调用重写后的show函数，此例中即输出：
Derived show
纯虚函数和抽象类
- 纯虚函数：纯虚函数在基类中，没有定义一个基础默认的函数实现。因此如果想要调用该函数，必须要在子类中重写该函数的具体实现后才能够调用。纯虚函数没有实现，使用
= 0来声明。
class Base
{
public:
virtual void show() = 0;
};
//这里定义了一个名为show的纯虚函数。
可以发现，纯虚函数与虚函数的不同之处在于，虚函数有一个基础默认的函数实现：
virtual void show()
{
std::cout << "Base show" << std::endl;
}//定义了一个虚函数，同时有该函数的具体实现，这里即cout << "Base show" << endl; 。
//如果子类没有重写该函数，那就调用这里的show()函数。
- 抽象类：如果一个类中有一个或多个纯虚函数，那么这个类就被称为抽象类，抽象类不能实例化，通常用作接口或基类。
class Base
{
public:
virtual void show() = 0;
};
//这里定义了一个名为show的纯虚函数。
int main()
{
Base test();
//这里当你想实例化一个名为test的Base类时 会报错，因为Base为抽象类。
//大白话就是Base里还有个 纯虚函数show 没有具体实现呢，怎么能让你创建一个Base类的实例 test 呢？
return 0;
}
虚析构函数
- 虚析构函数即使用
virtual关键字来声明一个类的析构函数：
#include <iostream>
class Base
{
public:
virtual ~Base(){std::cout<<"Deleted Base!"<<std::endl;};
};//这里便声明了一个虚析构函数
int main()
{
Base e1;
return 0;
}
虚析构函数的作用
看到这里，你一定想问，为什么我们需要虚析构函数呢？有什么作用吗？
我们先来看看这段代码：
#include <iostream>
class Base //简单的基类
{
public:
Base(){std::cout<<"Created Base!"<<std::endl;}//构造函数，构造时输出Created Base!
~Base(){std::cout<<"Derived Base!"<<std::endl;}//析构函数，析构时输出Derived Base!
};
class Der: public Base//Base类的子类Der
{
public:
Der(){std::cout<<"Created Der!"<<std::endl;}
~Der(){std::cout<<"Derived Der!"<<std::endl;}
};
int main()//主函数部分
{
Der* ptr = new Der();
delete ptr;
std::cout<<"================"<<std::endl;
Base* poly = new Der();//关键代码，创建一个派生类的对象并将其赋值给基类指针。
delete poly;
return 0;
}
其中的
Der* ptr = new Der();
delete ptr;
和
Base* poly = new Der();
delete poly;
最终输出结果会一样吗？
答案是不一样：
输出结果如下所示：
Created Base!
Created Der!
Derived Der!
Derived Base!
================
Created Base!
Created Der!
Derived Base!
可以看到，第二种少了一次Derived Der!。即当用基类指针来引用派生类对象时，删除对象只会调用基类（Base）的析构函数，不会调用派生类（Der）的析构函数。
为什么会是这样呢？
当派生类的对象通过基类指针被删除时，C++ 调用哪个析构函数取决于基类的析构函数是否被声明为 virtual。如果基类的析构函数不是虚函数，那么只会调用基类的析构函数，而不会调用派生类的析构函数。这背后的原因和原理主要与对象的内存布局和析构过程有关。
内存布局
每个C++对象在内存中都有一个特定的布局。对于继承的情况，派生类对象的内存布局通常包含基类部分和派生类特有的部分。基类部分位于对象的起始位置，并且包含了基类的所有成员变量和虚函数表指针（如果有虚函数的话）。
析构过程
当一个对象被销毁时，析构过程遵循以下步骤：
-
如果对象是通过
new关键字分配的，使用delete操作符时，编译器首先检查对象的类型来确定调用哪个析构函数。 -
如果对象是通过基类指针删除的，编译器会使用指向的对象的类型信息（通过虚函数表指针）来确定调用哪个析构函数。
虚析构函数的作用
当基类的析构函数被声明为 virtual 时，编译器会在对象的内存布局中放置一个指向虚函数表的指针。这个指针允许编译器在运行时确定对象的实际类型，并调用相应的析构函数。
-
如果基类的析构函数是虚函数：通过基类指针删除派生类对象时，编译器会使用对象的虚函数表来查找并调用派生类的析构函数，然后依次调用所有基类的析构函数（如果它们也是虚函数）（当子类发生析构时，子类内存开始释放，因内存包涵关系，触发父类析构执行，层层向上递进，至到子类所包涵的所有内存释放完成。）。
-
如果基类的析构函数不是虚函数：编译器只能看到指针指向的基类类型，而没有足够的信息来调用派生类的析构函数。因此，它只会调用基类的析构函数，而派生类特有的资源可能不会被释放，导致资源泄漏。
举个简单的例子：
比如，Der类有一个在堆上分配的数组成员my_array（比如为int*类型），然后在析构函数中delete它以释放内存：
class Der: public Base//Base类的子类Der
{
public:
Der()
{
m_array = new int[5];
std::cout<<"Created Der!"<<std::endl;
}
~Der()
{
delete[] m_array;
std::cout<<"Derived Der!"<<std::endl;
}
private:
int* m_array;
};
如果第二种情况发生，这里就会因为没有调用派生类（Der）的析构函数，delete[] m_array;没有成功运行，而导致内存泄漏。
这时你可能会说，既然将一个派生类的对象赋值给基类指针会有这样潜在的问题，那我干嘛这么做呢？即：
将一个派生类的对象赋值给基类指针有什么意义呢？
将派生类的对象并将其赋值给基类指针的意义
这就要重新提到本文开头提及的多态性了。
多态性：是面向对象编程的核心概念之一。即可以通过基类指针，可以统一处理不同类型的派生类对象使得代码更加通用和灵活。
将派生类对象赋值给基类指针的做法在面向对象编程中非常常见，其意义包括：
-
多态性：这是面向对象编程的核心概念之一。通过基类指针，可以统一处理不同类型的派生类对象使得代码更加通用和灵活。
-
接口抽象：基类通常定义了一组接口（即虚函数），派生类实现这些接口的具体行为。使用基类指针可以调用这些接口而不需要关心具体的实现细节。
-
代码复用：通过基类指针，可以编写处理多种派生类对象的通用代码从而提高代码的复用性。
-
设计灵活性：在设计阶段，使用基类指针可以更容易地替换或修改派生类而不需要修改使用这些对象的代码。
举一个简单的示例，演示如何使用基类指针来处理派生类对象：
#include <iostream>
#include <vector>
#include <memory>
// 基类 Shape
class Shape
{
public:
virtual void draw() const = 0; // 纯虚函数，定义接口
virtual ~Shape() {} // 虚析构函数
};
// 派生类 Circle
class Circle : public Shape
{
public:
void draw() const override
{
std::cout << "Drawing a circle." << std::endl;
}
};
// 派生类 Square
class Square : public Shape
{
public:
void draw() const override
{
std::cout << "Drawing a square." << std::endl;
}
};
// 一个函数，接受基类指针并调用 draw 方法
void drawShape(const Shape* shape)
{
shape->draw();
}
int main()
{
// 创建一个包含不同形状的容器
std::vector<std::unique_ptr<Shape>> shapes;
// 添加不同形状的对象
shapes.push_back(std::make_unique<Circle>());
shapes.push_back(std::make_unique<Square>());
// 遍历容器，使用基类指针调用 draw 方法
for (const auto& shape : shapes)
{
drawShape(shape.get());
}
return 0;
}
在例子中：
-
Shape是一个抽象基类，定义了一个纯虚函数draw，表示所有形状都应该有一个自己的绘制方法。 -
Circle和Square是Shape的派生类，分别实现了draw方法。 -
drawShape函数接受一个Shape类型的指针，并调用它的draw方法。由于draw是虚函数，所以会调用相应派生类的具体实现。 -
在
main函数中创建了一个shapes容器，存储了指向Shape对象的智能指针。向容器中添加Circle和Square对象，然后遍历容器，调用每个形状的draw方法。
这里即展示了如何使用基类指针来统一处理不同类型的派生类对象，实现了多态性和代码的通用性。
看到这里，你应该明白了为什么我们需要虚析构函数，以及将派生类对象赋值给基类指针的意义这两个问题了。
所以在基类中声明虚析构函数，以确保在删除通过基类指针指向的派生类对象时，能够正确调用派生类的析构函数。这就是虚析构函数的作用。
仍在学习C/C++中, 如有概念上的错误，恳请斧正！
往期回顾
-
作者：
- @shaohua_du