虚函数的定义、用法以及纯虚函数和虚析构函数

shaohua_du

已于 2024-08-18 15:32:54 修改

阅读量1k

点赞数 36

文章标签： c++ 数据结构 c语言程序人生经验分享

于 2024-08-17 18:50:39 首次发布

本文链接：https://blog.csdn.net/shaohua_du/article/details/141284926

版权

虚函数

虚函数是一种成员函数，它允许子类重写（override）父类中定义的函数。
虚函数的重要意义便是实现多态性。
多态性是面向对象编程的一个核心概念：即同一个接口可以有不同的实现,从而实现代码的灵活性和通用性

#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 方法。