《21天学通C++》（第十一章）多态

2024-04-30 08:36
文章标签 c++ 21 多态 第十一章 天学通

本文主要是介绍《21天学通C++》（第十一章）多态，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

为什么需要多态？
为了最大限度地减少代码，提高可读性

1.虚函数

虚函数是C++中的一种特殊成员函数，它允许在派生类（也称为子类）中重写（覆盖）基类的实现，使用virtual进行声明

在C++中，如果基类中的成员函数不是虚函数，派生类中的同名函数并不会覆盖或重写基类中的函数，而是产生函数隐藏，意味着如果你通过基类类型的指针或引用调用该函数，实际上调用的是基类中的版本，而不是派生类中的版本。

不使用虚函数：

#include <iostream>
using namespace std;class Base {
public:// 普通函数，不是虚函数void func() {cout << "Base func" << endl;}
};class Derived : public Base {
public:// 看起来像是重写，实际上是函数隐藏void func() {cout << "Derived func" << endl;}
};int main() {Base* basePtr = new Derived();basePtr->func(); // 调用 Base::func，而不是 Derived::func//输出结果为Base funcdelete basePtr;system("pause");return 0;
}

使用虚函数

#include <iostream>
using namespace std;class Base {
public:// 声明为虚函数virtual void func() {cout << "Base func" << endl;}
};class Derived : public Base {
public://真正地重写void func() {cout << "Derived func" << endl;}
};int main() {Base* basePtr = new Derived();basePtr->func(); // 正确调用 Derived::func//输出结果为Derived funcdelete basePtr;system("pause");return 0;
}

2.使用虚函数实现多态行为

通过函数引用实现

#include <iostream>
using namespace std;// 基类 Fish，定义了鱼类的通用行为
class Fish {
public:// 虚函数 swim，允许派生类重写，实现多态virtual void swim() const {cout << "Fish is swimming" << endl;}
};// 派生类 Tuna，继承自 Fish
class Tuna : public Fish {
public:// 重写 Fish 类的 swim 函数，实现 Tuna 类特有的游泳行为void swim() const override {cout << "Tuna is swimming fast" << endl;}
};// 派生类 Carp，继承自 Fish
class Carp : public Fish {
public:// 重写 Fish 类的 swim 函数，实现 Carp 类特有的游泳行为void swim() const override {cout << "Carp is swimming slowly" << endl;}
};// 函数，使用 Fish 类的引用参数来实现多态
void makeFishSwim(const Fish& fish) {fish.swim(); // 根据传入对象的实际类型调用相应的 swim 方法
}int main() {Tuna tuna;Carp carp;// 通过引用传递给函数，实现多态makeFishSwim(tuna); // 输出 "Tuna is swimming fast"makeFishSwim(carp); // 输出 "Carp is swimming slowly"system("pause");return 0;
}

通过指针实现：

#include <iostream>
using namespace std;// 基类 Fish，定义了鱼类的通用行为
class Fish {
public:// 虚函数 swim，允许派生类重写，实现多态virtual void swim() {cout << "Fish is swimming" << endl;}// 虚析构函数virtual ~Fish() {cout << "Fish is deconstructed" << endl;}
};// 派生类 Tuna，继承自 Fish
class Tuna : public Fish {
public:// 重写 Fish 类的 swim 函数，实现 Tuna 类特有的游泳行为void swim() override {cout << "Tuna is swimming fast" << endl;}// Tuna 类的析构函数~Tuna() {cout << "Tuna is deconstructed" << endl;}
};// 派生类 Carp，继承自 Fish
class Carp : public Fish {
public:// 重写 Fish 类的 swim 函数，实现 Carp 类特有的游泳行为void swim() override {cout << "Carp is swimming slowly" << endl;}// Carp 类的析构函数~Carp() {cout << "Carp is deconstructed" << endl;}
};int main() {// 创建派生类对象Fish* fish = new Tuna();fish->swim(); // 调用 Tuna::swim，输出 "Tuna is swimming fast"Fish* carp = new Carp();carp->swim(); // 调用 Carp::swim，输出 "Carp is swimming slowly"// 删除对象，调用相应的析构函数delete fish;delete carp;system("pause");return 0;
}

3.虚函数的工作原理——虚函数表

虚函数表（通常称为vtable）是C++中实现运行时多态的一种机制。当一个类包含至少一个虚函数时，编译器会为这个类创建一个虚函数表，这张表包含了类中所有虚函数的地址。

工作流程如下：

1.虚函数表的创建： 当一个类中包含至少一个虚函数时，编译器会为这个类创建一个虚函数表。这个表包含了该类所有虚函数的地址。

2.虚函数表指针： 编译器为每个对象添加一个指针，指向其类的虚函数表。这个指针通常存储在对象的内存布局的最前面。

3.调用虚函数： 当你通过一个基类指针或引用调用一个虚函数时，编译器生成的代码首先会访问对象的虚函数表指针，然后查找并调用表中对应的函数。

4.动态绑定： 由于虚函数表的存在，函数调用的解析是在运行时进行的，这称为动态绑定或晚期绑定。这意味着即使基类指针指向的是派生类对象，调用的也是派生类中重写的函数版本。

class Base {
public:virtual void show() {std::cout << "Base show" << std::endl;}virtual ~Base() {}  // 虚析构函数
};class Derived : public Base {
public:void show() override {  // 重写基类中的虚函数std::cout << "Derived show" << std::endl;}
};int main() {Base* basePtr = new Derived();  // 创建Derived对象的指针，但声明为Base类型basePtr->show();  // 调用show()，虽然basePtr是Base类型，但实际调用的是Derived的show()delete basePtr;return 0;
}

4.抽象基类和纯虚函数

抽象基类： 至少包含一个纯虚函数，而且无法被实例化，只能用于派生其他类，简称为ABC

纯虚函数： 它在基类中声明但故意不提供实现，其声明的函数体部分使用 = 0 来标识

virtual ReturnType FunctionName() = 0;

抽象基类使用方法如下：

#include <iostream>
using namespace std;// 抽象基类
class Shape {
public:// 纯虚函数，用于定义绘制形状的接口virtual void draw() const = 0;// 虚析构函数，确保派生类的析构函数被正确调用virtual ~Shape() {}
};// 派生类 Circle，表示圆形
class Circle : public Shape {
public:// 实现 Circle 的 draw 方法void draw() const override {std::cout << "Drawing a circle." << std::endl;}
};// 派生类 Rectangle，表示矩形
class Rectangle : public Shape {
public:// 实现 Rectangle 的 draw 方法void draw() const override {std::cout << "Drawing a rectangle." << std::endl;}
};int main() {// 创建一个指向 Shape 的指针数组，用于存储不同形状的指针Shape* shapes[] = { new Circle(), new Rectangle() };// 使用基类指针调用 draw 方法，实现多态for (Shape* shape : shapes) {shape->draw(); // 根据对象的实际类型调用相应的派生类的 draw 方法}// 释放动态分配的内存for (Shape* shape : shapes) {delete shape;}system("pause");return 0;
}

5.使用虚继承解决菱形问题

菱形问题： 即一个派生类继承自两个中间基类，而这两个中间基类又都继承自同一个基类时。这种继承结构在类图上看起来像一个菱形，因此得名。
在这里插入图片描述
田园犬类同时继承狗类和哺乳类，而哺乳类和狗类又同时继承动物类，呈现一个菱形结构。

在这个例子中田园犬类会分别从狗类和哺乳类中各自继承一个动物类，导致内存浪费和潜在的一致性问题，所以为了解决这个问题，可以使用虚函数继承来解决

#include <iostream>
using namespace std;// 定义基类 Animal
class Animal {
public:// 动物的呼吸方法virtual void breathe() { cout << "Animal breathes" << endl; }// 虚析构函数，确保派生类可以正确释放资源virtual ~Animal() {}
};// 定义中间基类 Mammal，使用虚继承自 Animal
class Mammal : virtual public Animal {
public:// 哺乳动物特有的哺育行为void nurse() { cout << "Mammal nurses its young" << endl; }// 虚析构函数virtual ~Mammal() {}
};// 定义中间基类 Dog，使用虚继承自 Animal
class Dog : virtual public Animal {
public:// 狗的吠叫行为void bark() { cout << "Dog barks" << endl; }// 虚析构函数virtual ~Dog() {}
};// 定义派生类 Poodle，同时继承自 Dog 和 Mammal
class Poodle : public Dog, public Mammal {
public:// 贵宾犬特有的行为void prance() { cout << "Poodle prances" << endl; }// 虚析构函数virtual ~Poodle() {}
};// 主函数
int main() {// 创建 Poodle 对象Poodle myPoodle;// 调用从各个基类继承来的方法myPoodle.bark();    // Dog 类的 bark 函数myPoodle.nurse();   // Mammal 类的 nurse 函数myPoodle.breathe();  // Animal 类的 breathe 函数myPoodle.prance();   // Poodle 类的 prance 函数system("pause"); // 用于在控制台程序结束前暂停，以便查看输出return 0;
}

6.表明覆盖意图的限定符override

使用override关键字有助于编译器检查函数签名是否与基类中的虚函数相匹配，从而提高代码的可读性和安全性。

使用方法如下：

class Base {
public:virtual void function() {// 基类}
};class Derived : public Base {
public:void function() override { // 使用 override 明确指出重写// 派生类}
};

7.使用final禁止覆盖函数

final关键字用于阻止派生类进一步重写（覆盖）基类中的虚函数。当你希望某个虚函数在派生类中保持最终实现，不允许任何进一步的重写时，可以使用final关键字。

class Base {
public:virtual void function() final {//使用final禁止覆盖// 基类实现}
};class Derived : public Base {
public:void function() override { // 这里会编译错误，因为 Base::function() 被声明为 final// 派生类实现}
};

这篇关于《21天学通C++》（第十一章）多态的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/948382。

相关文章

C++ 中的 if-constexpr语法和作用

C++ 中的 if-constexpr语法和作用

《C++中的if-constexpr语法和作用》if-constexpr语法是C++17引入的新语法特性,也被称为常量if表达式或静态if（staticif）,：本文主要介绍C++中的if-c... 目录1 if-constexpr 语法1.1 基本语法1.2 扩展说明1.2.1 条件表达式1.2.2 fa
阅读更多...
C++中::SHCreateDirectoryEx函数使用方法

C++中::SHCreateDirectoryEx函数使用方法

《C++中::SHCreateDirectoryEx函数使用方法》::SHCreateDirectoryEx用于创建多级目录,类似于mkdir-p命令,本文主要介绍了C++中::SHCreateDir... 目录1. 函数原型与依赖项2. 基本使用示例示例 1：创建单层目录示例 2：创建多级目录3. 关键注
阅读更多...
C++从序列容器中删除元素的四种方法

C++从序列容器中删除元素的四种方法

《C++从序列容器中删除元素的四种方法》删除元素的方法在序列容器和关联容器之间是非常不同的,在序列容器中,vector和string是最常用的,但这里也会介绍deque和list以供全面了解,尽管在一... 目录一、简介二、移除给定位置的元素三、移除与某个值相等的元素3.1、序列容器vector、deque
阅读更多...
C++常见容器获取头元素的方法大全

C++常见容器获取头元素的方法大全

《C++常见容器获取头元素的方法大全》在C++编程中,容器是存储和管理数据集合的重要工具,不同的容器提供了不同的接口来访问和操作其中的元素,获取容器的头元素（即第一个元素）是常见的操作之一,本文将详细... 目录一、std::vector二、std::list三、std::deque四、std::forwa
阅读更多...
C++字符串提取和分割的多种方法

C++字符串提取和分割的多种方法

《C++字符串提取和分割的多种方法》在C++编程中,字符串处理是一个常见的任务,尤其是在需要从字符串中提取特定数据时,本文将详细探讨如何使用C++标准库中的工具来提取和分割字符串,并分析不同方法的适用... 目录1. 字符串提取的基本方法1.1 使用 std::istringstream 和 >> 操作符示
阅读更多...
C++原地删除有序数组重复项的N种方法

C++原地删除有序数组重复项的N种方法

《C++原地删除有序数组重复项的N种方法》给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度,不要使用额外的数组空间,你必须在原地修改输入数组并在使用O(... 目录一、问题二、问题分析三、算法实现四、问题变体：最多保留两次五、分析和代码实现5.1、问题分析5.
阅读更多...
C++ 各种map特点对比分析

C++ 各种map特点对比分析

《C++各种map特点对比分析》文章比较了C++中不同类型的map（如std::map,std::unordered_map,std::multimap,std::unordered_multima... 目录特点比较C++ 示例代码 ​​​​​​代码解释特点比较1. std::map底层实现：基于红黑
阅读更多...
C++中函数模板与类模板的简单使用及区别介绍

C++中函数模板与类模板的简单使用及区别介绍

《C++中函数模板与类模板的简单使用及区别介绍》这篇文章介绍了C++中的模板机制,包括函数模板和类模板的概念、语法和实际应用,函数模板通过类型参数实现泛型操作,而类模板允许创建可处理多种数据类型的类,... 目录一、函数模板定义语法真实示例二、类模板三、关键区别四、注意事项 ‌在C++中，模板是实现泛型编程
阅读更多...
利用Python和C++解析gltf文件的示例详解

利用Python和C++解析gltf文件的示例详解

《利用Python和C++解析gltf文件的示例详解》gltf,全称是GLTransmissionFormat,是一种开放的3D文件格式,Python和C++是两个非常强大的工具,下面我们就来看看如何... 目录什么是gltf文件选择语言的原因安装必要的库解析gltf文件的步骤1. 读取gltf文件2. 提
阅读更多...
C++快速排序超详细讲解

C++快速排序超详细讲解

《C++快速排序超详细讲解》快速排序是一种高效的排序算法,通过分治法将数组划分为两部分,递归排序,直到整个数组有序,通过代码解析和示例,详细解释了快速排序的工作原理和实现过程,需要的朋友可以参考下... 目录一、快速排序原理二、快速排序标准代码三、代码解析四、使用while循环的快速排序1.代码代码1.由快
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2