多态的学习

最新推荐文章于 2024-06-27 18:21:59 发布

小甜瓜zzw

最新推荐文章于 2024-06-27 18:21:59 发布

阅读量53

点赞数

分类专栏： c++ 文章标签：学习 c++ 开发语言

本文链接：https://blog.csdn.net/m0_62583559/article/details/128718977

版权

c++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1多态的基本概念

多态分为两类：

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

静态多态和动态多态的区别：

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

动态多态满足条件：

得有继承关系
子类重写父类的虚函数（重写：函数返回值类型函数名称参数列表完全相同）

动态多态的使用：
父类的指针或者引用指向子类对象

#include <iostream>
using namespace std;
class Animal
{
public:
    virtual void speak()  //虚函数,地址不绑定为Animal
    {
        cout<<"动物在说话"<<endl;
    }
};
class Cat:public Animal
{
public:
    void speak()
    {
        cout<<"小猫在说话"<<endl;
    }
};
//地址早绑定，所以是动物在说话
void speak(Animal &animal)//引用
{
    animal.speak();
}
void test1()
{
    Cat cat;
    speak(cat);
}
int main() {
    test1();
    return 0;
}

2多态的原理剖析

#include <iostream>
using namespace std;
class Animal
{
public:
     virtual void speak()  //虚函数,地址不绑定为Animal
    {
        cout<<"动物在说话"<<endl;
    }
};
class Cat:public Animal
{
public:
    void speak()
    {
        cout<<"小猫在说话"<<endl;
    }
};
//地址早绑定，所以是动物在说话
void speak(Animal &animal)
{
    animal.speak();
}
void test1()
{
    Cat cat;
    speak(cat);
}
void test2()
{
    cout<<"sizeof Animal="<<sizeof(Animal)<<endl;//去掉virtual空类大小为1
    //加上virtual为8 多了一个指针
    //vfptr ：virtual function pointer 虚函数（表）指针
    //指向虚函数表 vftable virtual function table
    //表的内部记录虚函数的地址， &Animal::speak
    //子类继承后，会同时继承虚函数指针和表，
    //当子类重写父类的虚函数，子类的虚函数表内会替换成子类的虚函数地址 &Cat::speak
    //当父类的指针或者引用指向子类对象时候，发生多态
    //Animal &animal =cat;
    //animal.speak;
}
int main() {
    //test1();
    test2();
    return 0;
}

3多态-案例1-计算器类

案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

代码组织结构清晰
可读性强
对于前期和后期的拓展和维护性高

#include <iostream>
#include <string>
using namespace std;
//普通写法
class Calculator
{
public:
    int getResult(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 test01()
{
    Calculator c;
    c.m_Num1=10;
    c.m_Num2=10;
    cout<<c.m_Num1<<"+"<<c.m_Num2<<"="<<c.getResult("+")<<endl;
    cout<<c.m_Num1<<"-"<<c.m_Num2<<"="<<c.getResult("-")<<endl;
    cout<<c.m_Num1<<"*"<<c.m_Num2<<"="<<c.getResult("*")<<endl;

}
//--------------------------------------------------------
//利用多态
//实现计算器的抽象类
class AbstractCaculator
{
public:
    virtual int getResult()
    {
        return 0;
    }
    int m_Num1;
    int m_Num2;

};
class AddCaculator:public AbstractCaculator
{
public:
    int getResult()
    {
        return m_Num2+m_Num1;
    }

};
class SubCaculator:public AbstractCaculator//subtraction减法
{
public:
    int getResult()
    {
        return m_Num2-m_Num1;
    }

};
class MulCaculator:public AbstractCaculator
{
public:
    int getResult()
    {
        return m_Num2*m_Num1;
    }

};
void test02()
{
    //多态使用条件
    //父类指针或者引用指向子类对象
    AbstractCaculator *abc =new AddCaculator;//堆区
    abc->m_Num1=10;
    abc->m_Num2=10;
    cout<<abc->m_Num1<<"+"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
    delete abc;//数据释放，指针类型没变
    abc=new SubCaculator;
    abc->m_Num1=10;
    abc->m_Num2=10;
    cout<<abc->m_Num1<<"-"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
    delete abc;
}


int main()
{
    //test01();
    test02();
}

4纯虚函数和抽象类

在多态中，父类中虚函数的实现是毫无意义的，通常会调用子类重写的内容。
因此可以将虚函数改为纯虚函数

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

当类中有了纯虚函数，这个类也称为抽象类。

抽象类特点：

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

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

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

    }
};
void test01()
{
    Base *base = new Son;
    base->func();
}
int main ()
{
    test01();
}