【C++】多态 - 含3个案例

于 2024-08-03 22:55:56 发布
阅读量357 收藏 7
点赞数 17
分类专栏： C++ 文章标签： c++ 开发语言 笔记 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60546365/article/details/140882665
版权

目录

一、多态分类

二、多态区别

三、多态基本语法

四、多态原理

五、案例1：计算机类

六、纯虚函数和抽象类

七、案例2：制作饮品

八、虚析构和纯虚析构

九、案例3：电脑组装需求分析及实现

多态是C++面向对象三大特性之一

一、多态分类

①静态多态：函数重载、运算符重载、复用函数名

②动态多态：派生类、虚函数

二、多态区别

①静态多态：函数地址早绑定，编译阶段确定函数地址

②动态多态：函数地址晚绑定，运行阶段确定函数地址

三、多态基本语法
//动物类
class Animal
{
public:
    virtual void speak()
    {
        cout << "动物在讲话" << endl;
    }
};

//猫类
class Cat : public Animal
{
    void speak()
    {
        cout << "小猫在讲话" << endl;
    };
};

//狗类
class Dog : public Animal
{
    void speak()
    {
        cout << "小狗在讲话" << endl;
    };
};

//执行模块
//父类引用指向子类 C++中允许父子之间的类型转换 父类的引用/指针可以直接指向子类对象
//下面的函数属于地址早绑定，在编译阶段确定函数地址
//如果需要子类执行父类中的函数，函数地址不能早绑定，需要利用动态多态动态晚绑定【在父类中的函数前面加上virtual关键字】
void doSpeak(Animal &animal)
{
    animal.speak();
}

void test()
{
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}

** 动态多态满足条件 **

1、有继承关系

2、子类要重写父类虚函数（函数返回值类型、函数名字、参数列表一样）

** 动态多态的使用 **

父类的指针/引用指向子类的对象

四、多态原理

①当前动物类中只有一个非静态的成员函数（相当于空类），所以当前类的大小为：1

class Animal
{
public:
    void speak()
    {
        cout << "动物在讲话" << endl;
    }
};

②加上virtual关键字后，类的大小为：4，类中多了一个[vfptr]虚函数指针（大小为4个字节）

vfptr会指向vftable（虚函数表），表中会记录着虚函数地址（&Animal ：：speak）

class Animal
{
public:
    virtual void speak()
    {
        cout << "动物在讲话" << endl;
    }
};

当子类重写虚函数的时，vftable中的父类的虚函数地址会被覆盖掉然后变成（&Cat：：speak）

//猫类
class Cat : public Animal
{
    void speak()
    {
        cout << "小猫在讲话" << endl;
    };
};

所以当父类指针或引用指向子类对象时，发生多态

Animal & animal = cat;

animal.speak();

由于指向cat对象，所以编译器会从cat的vftable中找虚函数地址（&Cat：：speak）

五、案例1：计算机类

案例描述：利用普通方法和多态方法实现两个操作数运算的计算机类

多态的优点：

①代码组织结构清晰

②可读性强

③利于前期和后期的扩展及维护

1、普通方法

class Calculator
{
public:
    int getRet(string oper)
    {
        if(oper == "+")
        {
            return m_Num1 + m_Num2;
        }
        else if(oper == "-")
        {
            return m_Num1 - m_Num2;
        }
        else if(oper == "*")
        {
            return m_Num1 * m_Num2;
        }
        
    };

    int m_Num1;
    int m_Num2;
};

void test()
{
    Calculator c;
    c.m_Num1 = 10;
    c.m_Num2 = 10;

    cout << "num1+num2 = " << c.getRet("+") << endl;
    cout << "num1-num2 = " << c.getRet("-") << endl;
    cout << "num1*num2 = " << c.getRet("*") << endl;
}

在企业开发中，不建议使用该普通方法（因为想要扩展新的功能时需要修改源码）不利于维护

提倡使用开闭原则：对扩展进行开放，对修改进行关闭

2、多态方法

** 抽象类关键字：Abstract **

//实现计算器抽象类(基类)
class AbstractCalculator
{
public:
    virtual int getRet(string oper)
    {
       return 0;
    };

    int m_Num1;
    int m_Num2;
};

//加法计算器类
class Add() :public AbstractCalculator
{
public:
    int getRet(string oper)
    {
       return m_Num1 + m_Num2;
    };
};

//减法计算器类
class Sub() :public AbstractCalculator
{
public:
    int getRet(string oper)
    {
       return m_Num1 - m_Num2;
    };
};

//乘法计算器类
class Mul() :public AbstractCalculator
{
public:
    int getRet(string oper)
    {
       return m_Num1 * m_Num2;
    };
};

void test()
{
   //多态使用条件
   //父类指针或引用指向子类对象

   //加法
   AbstractCalculator * abc = new Add;
   abc->m_Num1 = 10;
   abc->m_Num2 = 10;
   cout << "num1 + num2 = " << abc->getRet() << endl;
   //用完后要手动释放堆区数据
   delete abc;
    
   //减法运算
   abc = new Sub;
   abc->m_Num1 = 10;
   abc->m_Num2 = 10;
   cout << "num1 - num2 = " << abc->getRet() << endl;
}
六、纯虚函数和抽象类

1、纯虚函数

①通常父类中虚函数的实现毫无意义，可以将其写为纯虚函数

②语法：virtual 返回值类型 函数名 （参数列表） = 0；

③当类中有了纯虚函数，这个类就是抽象类

2、抽象类

特点：①无法实例化对象 ②子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base
{
public:
    virtual void func() = 0;
};

class son :public Base
{
public:
    void func()
    {
        cout << "func函数调用" << endl;
    }
};

void test()
{
    Base * base = new Son;
    base->func();
}

七、案例2：制作饮品

制作流程：煮水 -> 冲泡 -> 倒入杯中 -> 加入材料

class AbstractDrinking
{
public:
    //煮水
    virtual void Boil() = 0;
    
    //冲泡
    virtual void Brew() = 0;
    
    //倒入杯中
    virtual void Pour() = 0;

    //加入材料
    virtual void Put() = 0;

    //制作饮料
    void makeDrink()
    {
        Boil();
        Brew();
        Pour();
        Put();
    }
};

class coffee :public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮百岁山水" << endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
    
    //倒入杯中
    virtual void Pour()
    {
        cout << "倒入纸杯中" << endl;
    }

    //加入材料
    virtual void Put()
    {
        cout << "加入糖浆和奶" << endl;
    }
};

class tea:public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮哇哈哈水" << endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout << "冲泡茶水" << endl;
    }
    
    //倒入杯中
    virtual void Pour()
    {
        cout << "倒入陶瓷杯中" << endl;
    }

    //加入材料
    virtual void Put()
    {
        cout << "加入水果片" << endl;
    }
};

void doWork(AbstractDrinking * abs)
{
    abs->makeDrink();
    delete abs;   
}

void test()
{
    doWork(new coffee);

    cout << "-----------------" << endl;

    doWork(new tea);
}

八、虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，父类指针释放时无法调用子类析构代码

解决方法：将父类中析构函数改为虚析构或纯虚析构

虚析构和纯虚析构共性：

①可以解决父类指针释放子类对象

②都需要具体的函数实现

虚析构和纯虚析构区别：

如果类中有纯虚析构函数，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名（）{ }；

纯虚析构语法：

virtual ~类名（）= 0；

类名::~类名（）{}

注意：虚析构函数和纯虚析构函数二者选其一即可；纯虚析构函数需要在类内声明类外实现[要保证父类中对象也有函数析构]

class Animal
(
pubulic:
    //纯虚函数
    virtual void speak() = 0;
    
    //构造函数
    Animal()
    {
        cout << "Animal的构造函数调用" << endl;
    }

    //虚析构函数
    //解决父类指针释放子类对象不干净的问题    
    virtual ~Animal()  
    {
        cout << "Animal的虚析构函数调用" << endl;
    }

    //纯虚析构函数
     virtual ~Animal() = 0 ;

);

//纯虚析构
Animal::~Animal()
{
    cout << "Animal的纯虚析构函数调用" << endl;
}

class Cat :public Animal
{
    
    Cat(string name)
    {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);//让小猫的姓名创建在堆区中   
    }

    void speak()
    {
        cout << *m_Name <<"小猫在说话" << endl;
    }

    ~Cat()
    {
        if(m_Name != NULL)
        {
            cout << "Cat的析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }

    string *m_Name;//创建指针维护 

};

void test()
{
    Animal * animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构时候，不会调用子类中的析构函数。导致子类如果有堆区数据/属性，会出现内存的泄露情况
    //解决问题：将父类析构函数改为虚析构函数
    delete animal;
}

九、案例3：电脑组装需求分析及实现
//写出每一个零件的抽象类

class CPU
{
public:
    virtual void calculate() = 0;
};

class VideoCard //显卡
{
public:
    virtual void display() = 0;
};

class Memory //内存条
{
public:
    virtual void storage() = 0;
};

class Computer
{
public:
    Computer(CPU &cpu, VideoCard &videocard, Memory &memory)
    {
       c = cpu;
       vc = videocard;
       mem = memory;
    }

    //让零件工作起来
    void work()
    {
        c->calculate();
        vc->display();
        mem->storage();
    }

    ~Computer()
    {
        if(c != NULL)
        {
            delete c;
            c = NULL;
        }
        else if(vc != NULL)
        {
            delete vc;
            vc = NULL;
        }
        else if(mem != NULL)
        {
            delete mem;
            mem = NULL;
        }
    }

private:
    
    CPU * c; //cpu零件指针
    VideoCard * vc;
    Memory * mem;
}

//Intel厂商
class IntelCpu :public CPU
{
public:
    void calculate()
    {
        cout << "Intel的CPU开始计算了" << endl;
    } 
}

class IntelVideoCard :public VideoCard 
{
public:
    void display()
    {
        cout << "Intel的显卡开始工作了" << endl;
    } 
}

class IntelMemory :public Memory
{
public:
    void storage()
    {
        cout << "Intel的内存条开始存储了" << endl;
    } 
}

//Lenovo厂商
class LenovoCpu :public CPU
{
public:
    void calculate()
    {
        cout << "Lenovo的CPU开始计算了" << endl;
    } 
}

class LenovoVideoCard :public VideoCard 
{
public:
    void display()
    {
        cout << "Lenovo的显卡开始工作了" << endl;
    } 
}

class LenovoMemory :public Memory
{
public:
    void storage()
    {
        cout << "Lenovo的内存条开始存储了" << endl;
    } 
}

//开始组装电脑
void test()
{
    //第一台电脑的零件
    CPU * intelCPU = new IntelCPU;
    VideoCard * intelCard = new IntelVideoCard;
    Memory * intelMem = new IntelMemory;

    //创建第一台电脑
    cout << "第一台电脑开始工作" << endl;
    Computer * computer1 = new Computer(intelCPU,intelCard,intelMem);
    computer1->work();
    delete computer1;

    //创建第二台电脑
    cout << "-----------------" << endl;
    cout << "第二台电脑开始工作" << endl;
    Computer * computer2 = new Computer(new LenovoCPU,new LenovoCard,new LenovoMem);
    computer2->work();
    delete computer2;

    cout << "-----------------" << endl;
    cout << "第三台电脑开始工作" << endl;
    Computer * computer3 = new Computer(new LenovoCPU,new IntelVideoCard,new LenovoMem);
    computer3->work();
    delete computer3;
}

XYN61
关注
  • 17
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C++多态的职工管理系统.zip
08-15
本案例设计到的知识点为：面向对象中的封装、继承、多态以及文件IO流，在设计中有Worker职工的基类，以及分别派生类为普通员工、经理、以及总裁，基类中有纯虚函数子类分别作了实现。然后有个文件管理类，对用户做出...
61 多态案例二-PK小游戏.rar
06-12
总结起来，这个“61 多态案例二-PK小游戏”是一个很好的学习资源，它将理论与实践相结合，帮助开发者深入理解C++中的多态、继承和虚函数等关键概念。通过实际编写和运行代码，可以更直观地体验到这些概念在解决实际...
C++多继承多态的实例详解
01-01
C++多继承多态的实现 如果一个类中存在虚函数，在声明类的对象时，编译器就会给该对象生成一个虚函数指针，该虚函数指针指向该类对应的虚函数表。 多态的实现是因为使用了一种动态绑定的机制，在编译期间不确定...
C++项目实例案例
02-27
这个压缩包包含29个不同的项目实例，每个实例都代表着一个特定的编程挑战或应用场景，涵盖了C++语言的多个核心概念和高级特性。 首先，C++是一种强大的面向对象编程语言，它以其灵活性、高效性和广泛的库支持而受到...
多个关于c++的实际详细案例
06-18
面向对象：C++支持面向对象编程（OOP）的概念，包括类（class）、对象（object）、继承（inheritance）、封装（encapsulation）和多态（polymorphism）。 泛型编程：C++通过模板提供了泛型编程的支持，允许开发者...
C语言——函数
attitude_lu的博客
08-01 776
函数的主要思想是：函数其实是从上到下逐步求解的过程，把一个大的问题拆成多个小的子问题或者说把一个大的功能拆成小的功能模块，通过实现小的功能最终实现大的功能的过程。
【C++】输入输出
2401_83948390的博客
08-02 316
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
【C++】类和对象（中）
2302_81149370的博客
08-02 581
✨✨欢迎大家来到Celia的博客✨✨。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 506
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
第六章 - c语言中的数组-二维数组（下）
百知_zmj的博客
08-02 205
二维数组案例：杨辉三角形。
【2024蓝桥杯/C++/B组/传送阵】
m0_73669127的博客
07-30 422
【代码】2024蓝桥杯/C++/B组/传送阵。
背单词工具(C++)
zeyeqianli的博客
07-24 4160
【代码】背单词工具(C++)
c语言之函数调用约定
qq_45583706的博客
08-02 408
在C和C++编程中，函数调用约定（Calling Convention）定义了函数参数如何传递、由谁负责清理栈（如果有的话）、以及返回值如何传递等规则。不同的平台和编译器可能采用不同的调用约定。不同的调用约定适用于不同的场景和需求。了解这些调用约定的特点和适用场景有助于编写更高效、更可移植的代码。在选择调用约定时，需要考虑目标平台、编译器、以及与其他代码或库的兼容性。
c++中的三种访问限定符：public、private、protected
change_xzt的博客
08-02 109
保护成员可以被类的成员函数、友元函数和派生类（子类）的成员函数访问，不能被类的外部访问。C++中有三种主要的访问限定符，用于控制类成员（变量和函数）的访问权限。私有成员只能被类的成员函数和友元函数访问，不能被类的外部访问。公有成员可以被任何地方访问，包括类的外部。
C：图案打印
2401_85010100的博客
07-23 1328
空心正方形，空心三角形，X形，沙漏图案打印
C语言之指针函数与函数指针
qq_45583706的博客
08-02 457
项目中时常遇到指正函数与函数指正的使用，时间一长容易出现概念混淆。本文记录了C语言中函数指针与指针函数的理解区分以及常见用法，如有不正之处，欢迎指正。
类和对象(上) - c++
2301_81336748的博客
08-01 622
class。
STL用法总结（二）（deque,map,set)
2301_80304432的博客
07-29 920
映射类似于函数的对应关系，每个x对应一个y，而map是每个键对应一个值。//头文件//初始化定义//node是结构体类型map特性：map会按照键的顺序从小到大自动排序，键的类型必须可以比较大小set容器中的元素不会重复，当插入集合中已有的元素时，并不会插入进去，而且set容器里的元素自动从小到大排序。即：set里面的元素不重复 且有序//头文件//初始化定义set s;代码含义s.begin()返回set第一个元素地址（迭代器）s.end()
c++| c++11左右值引用，完美转发，可变参数模板，functional包装器，bind函数
最新发布
学习笔记
08-02 373
左右值引用，完美转发，可变参数模板
C++多态案例详细代码及讲解
05-10
多态是C++中面向对象编程的重要特性之一，它可以让我们在编写程序时更加灵活和易于扩展。下面我们来看一个简单的多态案例。 假设我们有一个动物类（Animal），其中有一个虚函数makeSound()，用于输出动物的叫声。然后我们派生出几个动物子类（如狗Dog、猫Cat等），它们都重写了makeSound()函数输出自己的叫声。最后我们编写一个测试程序，用于创建不同的动物对象，并调用它们的makeSound()函数输出叫声。 下面是详细的代码及讲解： ```cpp #include <iostream> using namespace std; // 动物类 class Animal { public: virtual void makeSound() { cout << "动物叫声..." << endl; } }; // 狗类 class Dog : public Animal { public: virtual void makeSound() { cout << "汪汪汪..." << endl; } }; // 猫类 class Cat : public Animal { public: virtual void makeSound() { cout << "喵喵喵..." << endl; } }; // 测试函数 void test(Animal* animal) { animal->makeSound(); } // 主函数 int main() { Animal* animal1 = new Animal(); Animal* animal2 = new Dog(); Animal* animal3 = new Cat(); test(animal1); test(animal2); test(animal3); delete animal1; delete animal2; delete animal3; return 0; } ``` 上述代码中，Animal类是一个基类，我们将makeSound()函数声明为虚函数，表示它可以被子类重写。Dog和Cat类分别继承自Animal类，并重写了makeSound()函数，输出不同的叫声。 在测试函数test()中，我们将传入的动物指针参数强制转换为Animal类型，然后调用它们的makeSound()函数。这里需要注意的是，我们将动物指针参数声明为Animal*类型而不是Dog*或Cat*类型，这是因为在多态中，我们通常使用基类指针或引用来指向派生类对象，这样可以让我们更加灵活地操作对象。 在主函数中，我们创建了三个动物对象，分别为基类对象、狗类对象和猫类对象，并将它们作为参数传递给test()函数进行测试。由于makeSound()函数被声明为虚函数，因此在调用test()函数时会根据传入的实际对象类型来动态调用对应的函数，这就是多态的体现。 最后需要注意的是，在程序结束时我们需要释放动态分配的内存，以免出现内存泄漏。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值