【C++】类和对象-多态

已于 2022-08-01 19:42:04 修改
阅读量236 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-07-20 20:35:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuan3215/article/details/125878603
版权

目录

一、多态的基本概念

        1、静态多态

        2、动态多态

二、多态的原理剖析

三、多态案例 —— 计算器类

四、纯虚函数和抽象类

五、虚析构和纯虚析构

        1、虚析构

        2、纯虚析构

六、多态案例 —— 组装电脑

一、多态的基本概念

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

-

两类多态

  • 静态多态：函数重载和运算符重载（复用函数名）
  • 动态多态：派生类和虚函数实现运行时多态

-

静态和动态的多态区别：

  • 静态多态的函数地址早绑定，编译阶段确定函数地址
  • 动态多态的函数地址晚绑定，运行阶段确定函数地址

1、静态多态

测试代码：

#include<iostream>
using namespace std;

class Person1
{
public:
    void print(){
        cout << "Person1" << endl;
    }
};

class Person2 :public Person1
{
public:
    void print(){
        cout << "Person2" << endl;
    }
};

void myPrint(Person1& p1){
    p1.print();
}

int main(){
    Person2 p2;
    myPrint(p2); // 父类引用接受子类对象
    system("pause");
    return 0;
}

运行结果：

 地址早绑定，编译阶段就确定了地址，无论传入的是子类的什么引用，调用的都是父类的函数。

-

想要调用子类的函数就要地址晚绑定（动态多态）

2、动态多态

在父类的函数前加关键字 virtual 让函数成为虚函数

测试代码：

#include<iostream>
using namespace std;

class Person1 {
public:
    // 虚函数
    virtual void print() {
        cout << "Person1" << endl;
    }
};

class Person2 :public Person1 {
public:
    void print() {
        cout << "Person2" << endl;
    }
};

void myPrint(Person1& p1) {
    p1.print();
}

int main() {
    Person2 p2;
    myPrint(p2);
    system("pause");
    return 0;
}

 运行结果：

根据传入对象执行类的函数，print() 函数不能提早确定。

-

动态多态满足条件

1、有继承关系

2、子类重写父类虚函数

（重写需要函数完全一致，参数列表，返回值，函数名，子类 virtual 可以写也可以不写）

二、多态的原理剖析

 计算类中含有虚函数所占的空间大小

64bit 指针大小 8 字节

vs 开发者命令提示符工具，当子类继承父类虚函数

三、多态案例 —— 计算器类

描述：
利用多态技术，设计实现两个操作数进行运算的计算器类

-

多态的优点

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的拓展以及维护

-

实际开发中提倡 开闭原则 

开闭原则：对拓展进行开放，对修改进行关闭

测试代码：

#include<iostream>
using namespace std;

// 实现计算器抽象类
class AbstractCalculator {
public:
    virtual int getResult(){
        return 0;
    }
    int m_Num1;
    int m_Num2;
};
// 乘法类
class MulCalculator :public AbstractCalculator{
public:
    virtual int getResult(){
        return m_Num1 * m_Num2;
    }
};
// 加法类
class AddCalculator :public AbstractCalculator{
public:
    virtual int getResult(){
        return m_Num1 + m_Num2;
    }
};
//
// 可继续添加

void test(){
    AbstractCalculator* abc = new AddCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    
    cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
}
int main(){
    test();
    system("pause");
    return 0;
}

运行结果：

四、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是无意义的，主要都是调用子类重写的内容

-

因此可以将虚函数改为纯虚函数

-

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

-

当类中有纯虚函数（父类），这个类称为 抽象类

-

抽象类特点：

  • 无法实例化对象

  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象函数

测试代码：

#include<iostream>
using namespace std;

// 抽象类
class Base{
public:
    // 纯虚函数
    virtual void func() = 0;
};

class Son1 :public Base{
public:
    // 重写父类虚函数
    virtual void func()
    {
        cout << "Son1::func 函数调用" << endl;
    }
};

class Son2 :public Base
{
public:
    // 重写父类虚函数
    virtual void func()
    {
        cout << "Son2::func 函数调用" << endl;
    }
};

void test()
{
    // 通过父类指针调用不同子类的函数
    Base* base1 = new Son1;
    base1->func();
    Base* base2 = new Son2;
    base2->func();
}

int main(){
    test();
    system("pause");
    return 0;
}

运行结果：

五、虚析构和纯虚析构

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

-

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

-

虚析构和纯虚析构共性：

  • 解决父类指针释放子类对象
  • 都要有具体函数实现

虚析构和纯虚析构区别：

  • 类中有纯虚析构，该类属于抽象类，无法实例化

-

虚析构语法：virtual  ~类名()  { } ;

纯虚析构语法：virtual  ~类名()  { }  =  0;

问题：父类指针在析构时候不会调用子类中的析构函数，导致子类如果有堆区属性，就会出现内存泄漏

1、虚析构

测试代码：

#include<iostream>
#include<string>
using namespace std;

class Person1 {
public:
    // 构造
    Person1() {
        cout << "父类 构造函数调用" << endl;
    }
    // 纯虚函数
    virtual void Print() = 0;
    // 析构
    ~Person1() {
        cout << "父类 析构函数调用" << endl;
    }
};

class Person2 :public Person1 {
public:
    // 构造
    Person2(string name) {
        cout << "子类 构造函数调用" << endl;
        m_Name = new string(name);
    }
    // 重写
    virtual void Print() {
        cout << *m_Name << " 子类 中 Print" << endl;
    }
    // 析构函数释放堆区数据
    ~Person2() {
        if (m_Name != NULL) {
            cout << "子类 析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
    string* m_Name;
};

void test() {
    // 父类指针指向子类对象，开辟堆区数据
    Person1* p1 = new Person2("lihua");
    p1->Print();
    // 释放堆区数据
    delete p1;
}

int main(){
    test();
    system("pause");
    return 0;
}

运行结果：

 修改：将父类的析构变成虚析构

2、纯虚析构

virtual ~Person1() = 0;

如果纯虚析构只有声明会产生一个无法解析外部命令的错误（链接阶段的错误）

需要代码实现

class Person1 {
public:
    // 纯虚析构
    virtual ~Person1() = 0;
};

// 纯虚析构带代码实现
Person1::~Person1() {
    cout << "Person1 下的纯虚析构函数" << endl;
}

 类中含有纯虚函数这个类变为抽象类，无法实例化

六、多态案例 —— 组装电脑

代码：

#include<iostream>
using namespace std;

// cpu 抽象类
class CPU{
public:
    // cpu计算纯虚函数
    virtual void calculator() = 0;
};

// gpu抽象类
class GPU{
public:
    // gpu显示纯虚函数
    virtual void display() = 0;
};

// 内存抽象类
class MEM{
public:
    // memory存储纯虚函数
    virtual void sterage() = 0;
};

// 继承 CPU 的子类，重写父类纯虚函数
class Intel_CPU :public CPU{
public:
    // 重写
    virtual void calculator(){
        cout << "Inter_CPU" << endl;
    }
};

// 继承 GPU 的子类，重写父类纯虚函数
class Intel_GPU :public GPU{
public:
    // 重写
    virtual void display(){
        cout << "Inter_GPU" << endl;
    }
};

// 继承 MEM 的子类，重写父类纯虚函数
class Intel_MEM :public MEM{
public:
    // 重写
    virtual void sterage(){
        cout << "Inter_MEM" << endl;
    }
};

class AMD_CPU :public CPU{
public:
    // 重写
    virtual void calculator(){
        cout << "AMD_CPU" << endl;
    }
};

class AMD_GPU :public GPU{
public:
    // 重写
    virtual void dispaly(){
        cout << "AMD_GPU" << endl;
    }
};

class AMD_MEM :public MEM
{
public:
    // 重写
    virtual void sterage(){
        cout << "AMD_MEM" << endl;
    }
};

// computer类
class Computer
{
public:
    // 构造
    Computer(CPU* cpu, GPU* gpu, MEM* mem){
        m_cpu = cpu;
        m_gpu = gpu;
        m_mem = mem;
    }
    // 拼装函数
    void work(){
        m_cpu->calculator();
        m_gpu->display();
        m_mem->sterage();
    }
    // 析构
    ~Computer(){
        if (m_cpu != NULL) {
            delete m_cpu;
            m_cpu = NULL;
        }
        if (m_gpu != NULL) {
            delete m_gpu;
            m_gpu = NULL;
        }
        if (m_mem != NULL) {
            delete m_mem;
            m_mem = NULL;
        }
    }
private:
    CPU* m_cpu;
    GPU* m_gpu;
    MEM* m_mem;
};

void test(){
    // 堆区创建配件
    CPU* IntelCPU = new Intel_CPU;
    GPU* IntelGPU = new Intel_GPU;
    MEM* AMDMEM   = new AMD_MEM;
    // 实例化 Computer类 对象，传入指针
    Computer* computer = new Computer(IntelCPU, IntelGPU, AMDMEM);
    // 调用对象成员函数 - 拼装函数
    computer->work();
    // 销毁堆区数据
    delete computer;
}

int main()
{
    test();

    system("pause");
    return 0;
}

L1099
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++类和对象之多态
qq_26134355的博客
10-31 206
多态是面向对象的三大特性之一 多态分为两类 静态多态：函数重载和运算符属于静态多态，复用函数名 动态多态：派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定——编译阶段确定函数地址 动态多态的函数地址晚绑定——运行阶段确定函数地址 下面通过多态进行讲解多态 #include<iostream> using namespace std; //多态 //动物类 class Animal { public: void speak() { cout <&l
c++基础复习——多态的纯虚函数和抽象类
sagghab的博客
08-05 195
在多态中，通常父类中的虚函数的实现是毫无意义的，主要都是调用子类重写的内容 因此可以把虚函数改为纯虚函数 当类中有了纯虚函数，这个类也叫做抽象类 抽象类的特点： 无法实例化对象 子类必须重写抽象类中的纯虚函数，不然也属于抽象类 class animal { public: //只要有一个纯虚函数，就称为抽象类 virtual void speak() = 0; }; ...
（C++）类与对象——多态基础知识
Lemon_CHA的博客
08-28 144
目录一、多态的基本概念二、多态的原理剖析 一、多态的基本概念 #include <string> #include <iostream> using namespace std; /*动态多态的满足条件 1.有继承关系 2.子类中重写父类的虚函数 重写：函数返回值类型 函数名 参数列表 完全一致称为重写 动态多态的使用 父类的指针或者引用， 执行子类对象*/ class Animal { public: virtual void speak() { cout &l
C++多态案例——计算机类
weixin_43867777的博客
02-12 398
案例描述： 分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类 多态的优点： 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 //普通实现 class Calculator { public: int getResult(string oper) { if (oper == "+") { return m_Num1 + m_Num2; } else...
c++学习之多态演示案例
weixin_42097108的博客
11-22 167
1.案例描述 利用多态技术实现两个操作数进行运算的计算器类 2.多态的优点 （1）代码组织结构清晰 （2）可读性强 （3）利于前期和后期的扩展以及维护 3.代码示例 #include <iostream> using namespace std; class Calculator { public: virtual void getResult() //在子类中重写 { cout<< "cal" <<endl; } void getVa
C++面向对象之多态的实现和应用详解
12-31
本文主要给大家介绍的是关于C++面向对象之多态的实现和应用的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 多态 大家应该都听过C++三大特性之一多态，那么什么多态呢？多态有什么用...
类的多态练习_C++_类的多态练习_
09-29
在C++编程语言中，"类的多态性"（Polymorphism）是面向对象编程的三大特性之一，另外两个是封装和继承。多态性允许我们使用一个接口来表示不同的类型，使得代码更加灵活，易于扩展。在这个“类的多态练习”中，我们...
C++day15-多态 文档
10-28
在C++中，多态主要通过虚函数（Virtual Functions）和纯虚函数（Pure Virtual Functions）实现，同时也涉及到动态绑定（Dynamic Binding）和面向对象设计原则中的接口概念。 首先，虚函数是C++中实现多态的关键。在...
C++物品销售系统、多态、类、继承
11-25
总的来说，这个C++物品销售系统是面向对象设计的一个实例，通过类的封装、继承和多态实现了功能模块化，增强了代码的复用性和可扩展性。同时，采用单例模式管理和访问数据，确保了数据的一致性。项目的结构和文件...
4.7.2 多态案例--计算器类
qq_38872537的博客
02-01 315
4.7.2 多态案例--计算器类案例描述多态的优点示例 案例描述 分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类 多态的优点 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 示例 #include <iostream> #include <vector> #include <cstdlib> using namespace st...
多态案例-计算器类
LuckyStar的博客
05-01 90
/如果想要扩展功能，那么需要查看原始地方的所有代码，进行修改。分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类。//因此，在真实开发中，不提倡这种写法，一般提倡 “开闭原则”//“开闭原则”-对扩展进行开放，对修改进行关闭。
C++编程笔记(GPU并行编程)
刀刀的博客
11-10 5370
window+CLion配置并行编程
C++类与对象
HDBLM的博客
12-25 729
C++面向对象 一.面向对象程序设计方法概述 1.凡是以类对象为基本构成单位的程序称为基于对象的程序 2.面向对象和面向过程的区别： 在笔者看来，通俗地讲，“面向对象”就是在描述一个对象，“面向过程”则是在描述一个过程。 在程序设计方面，“面向过程”的特点是以过程为主，分析问题时，着眼于解决问题的步骤，并通过代码实现这些步骤。值得注意的是，面向过程不会对问题进行抽象总结，也就是说当我们面对一个问题...
C++笔试强训7
m0_74189279的博客
07-21 970
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 320
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 255
C++笔记3：基类指针delete子类对象的内存泄漏问题
C语言动态内存管理
最新发布
m0_62183318的博客
07-22 1018
⚽️动态内存管理是一种内存管理方法。它允许程序在运行时根据需要🍤动态地申请和回收内存空间🍤。与静态内存管理（如变量和数组的预先分配）不同，动态内存管理根据程序的需求即时分配内存，并且分配的内存大小就是程序要求的大小。🥪能更好地适应系统的动态需求，提高内存的利用率🥪可以根据程序的实际需要分配内存，而不是预先分配固定大小的内存🥪允许程序在不需要时释放内存空间，供其他应用程序使用总结来说，🍔动态内存管理。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 4万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值