c++多态

已于 2023-02-19 23:12:55 修改
阅读量202 收藏
点赞数
文章标签： c++ 开发语言 Powered by 金山文档
于 2023-02-19 13:44:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63178060/article/details/129100342
版权

一、多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会

产生出不同的状态。

二、多态的定义及实现

2.1虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

class Person {
public:
 virtual void fun() { cout << "Person::fun()" << endl;}
};

fun()就是虚函数

2.2虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的

返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class A
{
public:
    virtual void fun()
    {
        cout << "A::fun()" << endl;
        return nullptr;
    }
};
class B :public A
{
public:
    virtual void fun()
    {
        cout << "B::fun()" << endl;
        return nullptr;
    }
};

虚函数重写的俩个例外：

（1）协变：基类与派生类返回值类型不同，基类返回值是基类对象的指针或者引用，子类返回值是子类对象的指针或者引用，称为协变

//   协变(基类与派生类返回值类型不同)
//   基类返回基类对象的指针或引用，派生类返回派生类对象的指针或引用
class A
{
public:
    virtual A* fun()
    {
        cout << "A* fun()" << endl;
        return nullptr;
    }
};
class B :public A
{
public:
    virtual B* fun()
    {
        cout << "B* fun()" << endl;
        return nullptr;
    }
};
void test(A* a)
{
    a->fun();
}
int main()
{
    A a;
    test(&a);

    B b;
    test(&b);
    return 0;
}

（2）析构函数的重写

如果基类的析构函数为虚函数，此时子类只需要定义析构函数，虽然基类析构函数和子类析构函数名字不同，但是任然可以构成重写

//  析构函数重写
class A
{
public:
    //基类的析构函数为虚函数,则子类只需要定义析构函数即可实现重写
    virtual ~A()
    {
        cout << "~A()"<<endl;
    }
};
class B :public A
{
public:
    virtual ~B()
    {
        cout << "~B()" << endl;
    }
};
int main()
{
    A* pa = new A;
    A* pb = new B;
    delete pa;
    delete pb;
    return 0;
}

2.3多态的构成条件

（1）必须通过基类的指针或者引用调用虚函数

（2）被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

//1. 被调用的函数必须是虚函数，且派生类必须对基类进行重写
//2. 必须通过基类的指针或引用调用虚函数
class A
{
public:
    virtual void fun()
    {
        cout << "A::fun()" << endl;
    }
};
class B :public A
{
public:
    //子类必须重写基类的虚函数
    virtual void fun()
    {
        cout << "B::fun()" << endl;
    }
};
//通过基类引用调用
void test01(A& a)
{
    a.fun();
}
//通过基类指针调用
void test02(A* a)
{
    a->fun();
}
int main()
{
    A a;
    test01(a);
    test02(&a);
    B b;
    test01(b);
    test02(&b);
    return 0;
}

2.4 C++11 override 和 fifinal

override：检查派生类函数是否重写了基类的某个函数，如果没有重写，则编译报错

//override 检查派生类虚函数是否重写了某个虚函数，如果没有重写，则编译报错
//只能修饰子类的虚函数，修饰基类的虚函数没有意义
class A
{
public:
    virtual void fun()
    {
        cout << "A::fun()" << endl;
    }
};
class B :public A
{
public:
    virtual void fun()override   //检测fun()虚函数是否重写了基类的某个函数
    {
        cout << "B::fun()" << endl;
    }

    //编译报错，fun1()没有重写基类中的任何一个函数
    /*virtual void fun1()override
    {
        cout << "B::fun1()" << endl;
    }*/
};
int main()
{
    return 0;

final：修饰虚函数，表示该虚函数不能再被重写

//1. 修饰类，表明这个类不能被继承
class A final
{
public:
    void fun()
    {
        cout << "A::fun()" << endl;
    }
};
class B :public A      //编译报错，类B被final修饰，表明类B不能被继承
{
public:
    void fun()
    {
        cout << "B::fun()" << endl;
    }
};
int main()
{
    return 0;
}


//2. 修饰虚函数，表明该虚函数不能被重写
class A
{
public:
    virtual void fun()
    {
        cout << "A::fun()" << endl;
    }
};
class B :public A   
{
public:
    //final修饰B类中的fun()函数，说明fun()不能在之后的继承类中被重写
    virtual void fun() final 
    {
        cout << "B::fun()" << endl;
    }
};
class C :public B
{
public:
    virtual void fun()   //编译报错
    {
        cout << "C::fun()" << endl;
    }
};
int main()
{
    return 0;
}

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

//重载：1.两个函数在同一作用域
// 2.函数名以及参数相同
//重写：1.两个函数分别在基类和派生类中
// 2.函数名相同，参数相同，返回值相同(协变和析构函数除外)
// 3.两个函数都必须是虚函数
//重定义(同名隐藏)：1.两个函数分别在基类和派生类中
// 2.函数名形同(参数和返回值可以不相同)

三、抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口

类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生

类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class A
{
public:
    //写函数体和不写函数体都可以
    virtual void fun() = 0;
    virtual void display() = 0{}
};

int main()
{
    //A a;  编译报错，A为抽象类，无法实例化对象
    return 0;
}
class A
{
public:
    virtual void fun() = 0 {};
};
class B:public A
{
public:
    //解决方案
    /*virtual void fun()
    {
        cout << "B::fun()" << endl;
    }*/
    void fun1()
    {
        cout << "B::fun1()" << endl;
    }
};
int main()
{
    B b;   //编译报错，B中没有重写A中的纯虚函数fun()
    return 0;
}

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实

现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成

多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

四、多态的原理（vs2019 32位环境下）

4.1虚函数表

在上述例子中A对象的大小为8个字节，这是因为除了_a成员以外，还有4个字节的_vfptr指针在对象前面，这个指针指向虚函数表，这个指针被称为虚函数表指针

我们发现，如果一个类中有虚函数，则：

  1. 类对象大小多了4个字节

  1. 多的4个字节中存放的是一个地址，这个地址指向的空间中存放的是虚函数的地址，这4个字节的地址被称为徐表指针，指向的空间被称为虚表

  1. 编译器会给该类生成构造方法，因为在生成的构造方法中会将虚表的地址填充到对象的前4个字节中

  1. 在编译阶段，编译器会将该类中的虚函数按照声明次序依次添加到虚表中

  1. 同一个类的多个对象共享一张虚表，即该类创建的对象，前4个字节都是相同的虚表地址

那么如果子类继承自基类，子类对象在内存中的模型是怎么样的呢？

下面举例进行说明

class A
{
public:
    virtual void fun1()
    {
        cout << "A::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "A::fun2()" << endl;
    }
    virtual void fun3()
    {
        cout << "A::fun3()" << endl;
    }
    int _a;
};
class B :public A
{
public:
    virtual void fun1()
    {
        cout << "B::fun1()" << endl;
    }
    virtual void fun3()
    {
        cout << "B::fun3()" << endl;
    }
    int _b;
};
int main()
{
    A a;
    a._a = 3;

    B b;
    b._a = 1;
    b._b = 2;

    cout << sizeof(b) << endl;
    return 0;
}

其次，当子类中新增自己的虚函数的时候，那么该虚函数是否也在虚表中，在虚表中的什么位置？

将上述例子中部分代码进行修改：

class B :public A
{
public:
    virtual void fun1()
    {
        cout << "B::fun1()" << endl;
    }
    virtual void fun3()
    {
        cout << "B::fun3()" << endl;
    }
    virtual void fun4()
    {
        cout << "B::fun4()" << endl;
    }
    int _b;
};

上述情况的验证方法：

class A
{
public:
    virtual void fun1()
    {
        cout << "A::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "A::fun2()" << endl;
    }
    virtual void fun3()
    {
        cout << "A::fun3()" << endl;
    }
    int _a;
};
class B :public A
{
public:
    virtual void fun1()
    {
        cout << "B::fun1()" << endl;
    }
    virtual void fun3()
    {
        cout << "B::fun3()" << endl;
    }
    virtual void fun4()
    {
        cout << "B::fun4()" << endl;
    }
    int _b;
};
typedef void (*PVFT)();

int main()
{
    A a;
    a._a = 3;

    B b;
    b._a = 1;
    b._b = 2;

    int* p = (int*)&b; //取出对象b内存模型的前4个字节
    int data = *p;     //将这4个字节转换为整形数字

    PVFT* pf = (PVFT*)data;  //将这data强转为函数指针类型
    while (*pf)
    {
        (*pf)();
        pf++;
    }
    return 0;
}

运行结果：

通过运行结果，我们可分析出，子类新增的虚函数也在虚表中，而且按照子类中声明的顺序存放在虚表中对应的位置

从汇编代码的角度理解：

class A
{
public:
    virtual void fun1()
    {
        cout << "A::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "A::fun2()" << endl;
    }
    virtual void fun3()
    {
        cout << "A::fun3()" << endl;
    }
    void fun4()
    {
        cout << "A::fun4()" << endl;
    }
    int _a;
};
class B :public A
{
public:
    virtual void fun1()
    {
        cout << "B::fun1()" << endl;
    }
    virtual void fun3()
    {
        cout << "B::fun3()" << endl;
    }
    int _b;
};
void Test(A* a)
{
    a->fun1();
    a->fun2();
    a->fun3();
    a->fun4();
}
int main()
{
    B b;
    Test(&b);
    return 0;
}

当满足多态的条件之后，父类的指针或引用调用虚函数时，不是编译的时候确定的，而是运行时到指向的对象的虚函数表中找对应的虚函数去调用

4.2动态绑定和静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，

比如：函数重载

2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体

行为，调用具体的函数，也称为动态多态。

总结

1.什么是多态？

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

产生出不同的状态。多态分为静态多态和动态多态，静态多态在编译的时候就已经确定好了，常见的静态多态是函数重载；动态多态则是子类通过对父类虚函数的重写，通过虚表，达到传入不同对象就调用不同对象的函数的目的

2.什么是重载、重写(覆盖)、重定义(隐藏)？

答：重载：同一作用域内，函数名相同参数不同

重定义：作用在不同作用域，子类和父类的函数名相同（其他可以不相同），称子类隐藏了父类的某个函数

重写：作用在不同的作用域，子类和父类必须都是虚函数，而且函数名，参数列表，返回值必须相同

3.多态的实现原理

答：父类和子类中保存的虚表指针是不一样的，通过传入指针或者引用，确定去子类还是父类的虚表中调用对应的函数，实现多态

4.静态成员函数可以是虚函数吗？

答：不能，静态成员函数中没有this指针，静态成员函数是属于整个类的，并不属于某一个对象，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

5.构造函数可以是虚函数吗？

答：不可以。对象的虚函数指针是在构造函数的初始化列表阶段才进行初始化，在构造函数阶段，虚函数指针还没有初始化成功，自然无法找到对应的虚表。

6.析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

答：析构函数可以为虚函数，并且最好把基类的析构函数定义为虚函数，因为只要基类的析构函数为虚函数，子类只需要声明自己的析构函数，尽管子类析构函数和基类析构函数的名称不一样，也可以实现重写，从而实现多态

7.对象访问普通函数快还是虚函数更快？

答：如果不构成多态，在编译的时候就确定了该如何调用，则对象访问普通函数和访问虚函数一样快；如果构成多态，则对象访问普通函数快，因为在访问虚函数的时候，要通过虚表指针，找到对应的虚函数表，在从虚函数表中找到对应的函数进行访问

8.虚函数表是在什么阶段生成的，存放在哪？

答：错误回答：虚函数存在在虚表中，虚表存在在对象中； 虚表中存放的虚函数的地址，并不是虚函数，虚函数和普通函数一样，都是存放在代码段的，只是指向它的指针存放在虚表中；其次对象的前4个字节中存放的是虚表的地址，即指向虚表的指针，实际上虚表也是存放在代码段的

9.什么是抽象类？抽象类的作用？

答：包含纯虚函数的类被称为抽象类，抽象类不能实例化对象，继承抽象类的类必须重写抽象类中的纯虚函数才能实例化对象，否则也不能实例化对象。抽象类体现出了接口继承的关系

HLKL.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
C++ 多态
jun8086的博客
10-31 570
c++ 多态
c++多态 详解
qq_39117115的博客
03-09 948
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++多态详解
米莱虾
10-12 896
目录 多态的概念 多态的实现 虚函数的定义要遵循以下重要规则： 多态的概念 多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。 那为什么要用多态呢，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不是也可以吗? -------- 这是不可以的。下面我们用一个例子来解释为什么要用多态： 将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但各不相同。在写驱动的时候，用个父类表示外设接口，然后在子类中重写父类那个读取设备..
c++ 多态详解
不倒翁.
05-02 5440
c++多态详解
c++ 多态
RSH的博客
07-24 353
1、多态 多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 虚函数表存放的是虚函数的入口地址，当子类重写了虚函数后，子类会把继承于父类的虚函数表进行覆盖，所以当用父类指针或引用指向子类对象的时候，由于本身还是子类，所以当调用公共接口时，它会从子类去
C++多态的底层原理
分享学习的知识，记录我的技术成长道路
04-27 2770
要了解C++多态的底层原理需要我们对C指针有着深入的了解，这个在打印虚表的时候就可以见功底，理解了多态的本质我们才能记忆的更牢，使用起来更加得心应手。
C++多态（超级详细版）
kkbca的博客
10-28 9552
在继承中要构成多态还有两个条件：1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写public:virtual void BuyTicket() { cout
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
C++ 多态和虚函数 高清PDF
08-15
多态性（在C + +中用虚函数实现）是面向对象程序设计语言继数据抽象和继承之后的第三个基本特征。 它提供了与具体实现相隔离的另一类接口，即把“ w h a t”从“h o w”分离开来。多态性提高了代码的组织性和可读性...
详解C++ 多态的实现及原理
01-20
C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用...
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 613
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
c++习题08-计算星期几
码到成龚的博客
07-03 570
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
关键路径——C语言（理论）
2302_80790488的博客
06-28 845
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
Android 开发中 C++ 和Java 日志调试
最新发布
小羊子的技术专栏
07-04 875
Android 开发中 C++ 和Java 日志调试方法小结

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值