C++系列-多态的基本语法

weixin_486681142024-08-22 14:31

多态的基本语法

《游山西村》

南宋·陆游

莫笑农家腊酒浑，丰年留客足鸡豚。

山重水复疑无路，柳暗花明又一村。

箫鼓追随春社近，衣冠简朴古风存。

从今若许闲乘月，柱杖无时夜叩门。

多态的含义

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

  • C++多态性（Polymorphism）是面向对象编程(OOP)的一个重要特性之一。
  • 它允许我们使用统一的接口来处理不同类型的对象。
  • 多态性使得程序更加灵活、可扩展并且易于维护。

静态多态

  • 函数重载，运算符重载这些都属于静态多态，复用函数名。
  • 编译阶段就确定了函数的地址。

动态多态

  • 使用了一种动态绑定的技术，这个技术的核心就是虚函数表(virtual table)。
  • 运行阶段才确定函数的地址。

看一下下面这段代码，执行eat函数，想通过父类的引用指向子类的对象，用于实现子类的函数调用，可是事与愿违。

查看父类的大小，因为非静态成员函数并非属于类的对象上，所以size是1。

cpp 复制代码 
code:
#include<iostream>
using namespace std;

class Vegetable
{
public:
	void eat()
	{
		cout << "多吃蔬菜对身体好哦！" << endl;
	}
};

class Spinach :public Vegetable
{
public:
	void eat()
	{
		cout << "多吃 菠菜 对身体好哦！" << endl;
	}
};

class Taro :public Vegetable
{
public:
	void eat()
	{
		cout << "多吃 芋头 对身体好哦！" << endl;
	}
};

void eat(Vegetable &veg)
{
	veg.eat();
}

int main()
{
	Spinach sp1;
	eat(sp1);
	Taro ta1;
	eat(ta1);
	cout << "sizeof(Vegetable) = " << sizeof(Vegetable) << endl;
	cout << "sizeof(Spinach) = " << sizeof(Spinach) << endl;
	cout << "sizeof(Taro) = " << sizeof(Taro) << endl;
	system("pause");
	return 0;
}

result:
多吃蔬菜对身体好哦！
多吃蔬菜对身体好哦！
sizeof(Vegetable) = 1
sizeof(Spinach) = 1
sizeof(Taro) = 1

接着改变一个地方，在父类函数前加上virtual关键字，同时对子类中的函数进行重写。

通过父类的引用指向子类的对象，实现了子类的函数调用。

查看类的结构，大小变为4，vfptr virtual function pointer, 它指向一个vftable，和操作系统有关，有的是8。

  • 所谓的虚函数，就是被virtual修饰的类成员函数。
  • 子类中有一个跟父类完全相同的虚函数(即子虚函数与父类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了父类的虚函数。
  • 子类在重写父类的虚函数时，在函数前可以加virtual，可以不加，建议加。
cpp 复制代码 
code:
#include<iostream>
using namespace std;

class Vegetable
{
public:
	virtual void eat()
	{
		cout << "多吃蔬菜对身体好哦！" << endl;
	}
};

class Spinach :public Vegetable
{
public:
	virtual void eat()
	{
		cout << "多吃 菠菜 对身体好哦！" << endl;
	}
};

class Taro :public Vegetable
{
public:
	virtual void eat()
	{
		cout << "多吃 芋头 对身体好哦！" << endl;
	}
};

void eat(Vegetable &veg)		// 父类的引用指向子类的对象
{
	veg.eat();
}

int main()
{
	Spinach sp1;
	eat(sp1);
	Taro ta1;
	eat(ta1);
	cout << "sizeof(Vegetable) = " << sizeof(Vegetable) << endl;
	cout << "sizeof(Spinach) = " << sizeof(Spinach) << endl;
	cout << "sizeof(Taro) = " << sizeof(Taro) << endl;
	system("pause");
	return 0;
}

result:
多吃 菠菜 对身体好哦！
多吃 芋头 对身体好哦！
sizeof(Vegetable) = 4
sizeof(Spinach) = 4
sizeof(Taro) = 4

如果子类中不重写父类中的虚函数，类的结构如下：

vftable中的函数地址父类和子类是相同的，执行的都是父类的函数。

多态的底层原理

  • 在类的结构中，有一个vfptr指向一个vftable。
  • vftable中放置了虚函数的地址，当子类中未重写该函数时，该地址是父类函数的地址，否则为子类函数的地址。
  • 如果有多个虚函数，vftable放置的是虚函数的地址对应的数组。

多态中的final和override

  • 有些情况下由于疏忽，比如函数名书写错误，导致无法实现多态，这种错误在编译期间是不会报出的，但在运行期间得不到正确的结果。
  • C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

final

  • 修饰虚函数，表示该虚函数不能再被重写。
  • virtual 返回类型 函数名(形参) final {}

override:

  • 检查子虚函数是否重写了父类某个虚函数，如果没有重写编译报错。
  • virtual 返回类型 函数名(形参) override {}

多态的应用和优点

  • 代码组织结构清晰
  • 可读性强
  • 利于代码维护

计算器简单实现

cpp 复制代码 
//在上述代码中，我们首先定义了一个抽象基类  Operation ，其中包含一个纯虚函数  calculate 。
//然后，分别创建了加法、减法、乘法和除法的子类来实现具体的计算逻辑。
//在 main 函数中，根据用户的选择创建相应的子类对象，让父类指针指向它，并通过多态调用计算函数得到结果。
#include <iostream>
using namespace std;

// 抽象父类，纯虚函数
class Operation 
{
public:
    virtual double calculate(double num1, double num2) = 0;     // 纯虚函数
};

// 加法操作类
class Add : public Operation 
{
public:
    double calculate(double num1, double num2) override         // override表示是重写父类中的函数
    {
        return num1 + num2;
    }
};

// 减法操作类
class Subtract : public Operation 
{
public:
    double calculate(double num1, double num2) override
    {
        return num1 - num2;
    }
};

// 乘法操作类
class Multiply : public Operation 
{
public:
    double calculate(double num1, double num2) override 
    {
        return num1 * num2;
    }
};

// 除法操作类
class Divide : public Operation {
public:
    double calculate(double num1, double num2) override 
    {
        if (num2 != 0) {
            return num1 / num2;
        }
        else {
            cout << "除数不能为 0" << endl;
            return 0;
        }
    }
};

int main() 
{
    Operation* op;      // 父类指针
    double num1, num2, result;
    int choice;
    while (1)
    {
        cout << "------------ 请选择操作 ------------" << endl;
        cout << "1. 加法" << endl;
        cout << "2. 减法" << endl;
        cout << "3. 乘法" << endl;
        cout << "4. 除法" << endl;
        cout << "0. 退出" << endl;
        cin >> choice;          // 
        if (choice == 0)
        {
            cout << "退出计算过程" << endl;
            break;
        }

        else
        {
            cout << "请输入第一个数：";
            cin >> num1;
            cout << "请输入第二个数：";
            cin >> num2;
            switch (choice)
            {
            case 1:
                op = new Add();     // 父类指针指向子类对象
                break;
            case 2:
                op = new Subtract();
                break;
            case 3:
                op = new Multiply();
                break;
            case 4:
                op = new Divide();
                break;
            default:
                cout << "无效的选择" << endl;
                return 1;
            }
            result = op->calculate(num1, num2);     // 通过父类指针指向的是哪一个子类对象实现其对应的计算

            cout << "结果是：" << result << endl;
            delete op;
        }
    }
    system("pause");
    return 0;
}

电脑组装的实现

  • 假设电脑的主要部件为CPU，内存条，显卡, 各有不同的厂家，不同厂家的器件特性不一样，后续可能会不断增加。
  • 将每个零件封装出抽象父类，然后不同的厂家的零件定义子类，这样可以便于后续的维护和增加。
  • 定义一个计算机类，其中实现初始化，组装操作等。
    在组装过程中，打印出各零件的厂家及零件类型信息。
cpp 复制代码 
#include <iostream>
using namespace std;

// 假设电脑的主要部件为CPU，内存条，显卡, 各有不同的厂家，不同厂家的器件特性不一样，后续可能会不断增加。
// 将每个零件封装出抽象父类，然后不同的厂家的零件定义子类，这样可以便于后续的维护和增加。
// 定义一个计算机类，其中实现初始化，组装操作等。

// 每个零件定义父类，实现多态应用，定义虚函数或者纯虚函数。
class Cpu
{
public:
    virtual void calculate() {};
};

class Memory
{
public:
    virtual void storage() {};
};

class VideoCard
{
public:
    virtual void display() {};
};

// 不同厂家的零件继承零件父类，并实现具体的函数，实现多态应用。
class AmdCpu: public Cpu
{
public:
    void calculate() 
    {
        cout << "amd cpu calculate." << endl;
    };
};

class IntelCpu : public Cpu
{
public:
    void calculate()
    {
        cout << "intel cpu calculate." << endl;
    };
};

class SamsungMemory : public Memory
{
public:
    void storage()
    {
        cout << "samsung memory save data." << endl;
    };
};

class MicronMemory : public Memory
{
public:
    void storage()
    {
        cout << "micron memory save data." << endl;
    };
};

class AmdVideoCard : public VideoCard
{
public:
    void display()
    {
        cout << "amd video card display." << endl;
    };
};

class NvidiaVideoCard : public VideoCard
{
public:
    void display()
    {
        cout << "nvidia video card display." << endl;
    };
};

// 定义计算机类，实现初始化，组装操作等，因为子类对象开辟在堆区，所以重写析构函数，实现堆区内存释放
class Computer
{
public:
    Computer(Cpu *cpu, Memory *memory, VideoCard *video_card)
    {
        m_cpu = cpu;
        m_memory = memory;
        m_video_card = video_card;
    }
    void assemble()
    {
        m_cpu->calculate();
        m_memory->storage();
        m_video_card->display();
    }
    // 释放堆区内存
    ~Computer()
    {
        if (m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        if (m_memory != NULL)
        {
            delete m_memory;
            m_memory = NULL;
        }
        if (m_video_card != NULL)
        {
            delete m_video_card;
            m_video_card = NULL;
        }
    }
private:
    Cpu *m_cpu;
    Memory *m_memory;
    VideoCard *m_video_card;
};

void test01()
{
    Cpu *intel_cpu = new IntelCpu;
    Memory *samsung_memory = new SamsungMemory;
    VideoCard* amd_video_card = new AmdVideoCard;
    Computer *com1 = new Computer(intel_cpu, samsung_memory, amd_video_card);
    com1->assemble();
    delete com1;
}

void test02()
{
    Cpu* amd_cpu = new AmdCpu;
    Memory* micron_memory = new MicronMemory;
    VideoCard* amd_video_card = new AmdVideoCard;
    Computer* com1 = new Computer(amd_cpu, micron_memory, amd_video_card);
    com1->assemble();
    delete com1;
}


int main()
{
    cout << "\n-------- 第 1 台电脑组装 --------" << endl;
    test01();
    cout << "\n-------- 第 2 台电脑组装 --------" << endl;
    test02();
    system("pause");
    return 0;
}

result:
-------- 第 1 台电脑组装 --------
intel cpu calculate.
samsung memory save data.
amd video card display.

-------- 第 2 台电脑组装 --------
amd cpu calculate.
micron memory save data.
amd video card display.

注意：部门内容来自黑马视频课程

相关推荐
Re.不晚3 分钟前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea
老秦包你会6 分钟前
Qt第三课 ----------容器类控件
开发语言·qt
凤枭香8 分钟前
Python OpenCV 傅里叶变换
开发语言·图像处理·python·opencv
ULTRA??12 分钟前
C加加中的结构化绑定（解包，折叠展开）
开发语言·c++
远望清一色29 分钟前
基于MATLAB的实现垃圾分类Matlab源码
开发语言·matlab
confiself38 分钟前
大模型系列——LLAMA-O1 复刻代码解读
java·开发语言
凌云行者1 小时前
OpenGL入门005——使用Shader类管理着色器
c++·cmake·opengl
XiaoLeisj1 小时前
【JavaEE初阶 — 多线程】Thread类的方法＆线程生命周期
java·开发语言·java-ee
凌云行者1 小时前
OpenGL入门006——着色器在纹理混合中的应用
c++·cmake·opengl
杜杜的man1 小时前
【go从零单排】go中的结构体struct和method
开发语言·后端·golang
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解