c++中的多态

最新推荐文章于 2024-05-10 16:48:02 发布
最新推荐文章于 2024-05-10 16:48:02 发布
阅读量237 收藏 1
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/A_supi/article/details/89499032
本文详细探讨了C++中的多态性，包括多态的定义、虚函数的概念与重写、抽象类、C++11中的`override`和`final`关键字以及多态的原理，如虚函数表的运作机制。通过对虚函数表的分析，解释了动态绑定与静态绑定的区别，并讨论了单继承和多继承关系中虚函数表的特点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 多态的定义及实现
  • 抽象类
  • c++11中的override和final
  • 多态的原理
  • 单继承和多继承关系中的虚函数表

1. 多态的定义及实现

1.1 多态的概念

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

1.2 多态定义的构成条件

0.前提是继承

  1. 调用函数的对象必须是指针或者引用。
  2. 被调用的函数必须是虚函数，且完成了虚函数的重写。

1.3 虚函数的概念及虚函数的重写

虚函数的概念：就是在类的成员函数的前面加virtual关键字

虚函数的重写：

虚函数的重写：派生类中有一个跟基类的完全相同虚函数，我们就称子类的虚函数重写了基类的虚函数，完全相同是指：函数名、参数、返回值都相同。另外虚函数的重写也叫作虚函数的覆盖。

//多态前提：继承
class Person {
public:
    virtual void BuyTicket() { cout << "买票-全价"  << endl; }
};
class Student : public Person {
public:
    virtual void BuyTicket() { cout << "买票-半价"  << endl; }
};
void Func(Person& p)
{
    p.BuyTicket();   
}
int main()
{
    Person ps;
    Student st;
    //多态看实际指向的对象，调用对象对应类型的代码
    //非多态看类型
    Func(ps);
    Func(st);
    return 0;
}

1.4 虚函数重写的例外：协变

虚函数重写有一个例外：重写的虚函数的返回值可以不同，但是必须分别是基类指针和派生类指针或者基类引用和派生类引用。

class A{};
class B : public A {};
class Person {
public:
    virtual A* f() { return new A; }
};
class Student : public Person {
public:
    virtual B* f() { return new B; }
};

1.5 析构函数的重写问题

基类中的析构函数如果是虚函数，那么派生类的析构函数就重写了基类的析构函数。这里他们的函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，这也说明的基类的析构函数最好写成虚函数。

public:
 virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
 virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多
态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
 Person* p1 = new Person;
 Person* p2 = new Student;
 delete p1;
 delete p2;
 return 0;
}

1.6 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

1.7 重载、覆盖（重写）、隐藏（重定义）的对比
在这里插入图片描述
2. 抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car
{
public:
 virtual void Drive() = 0;
};
class Benz :public Car
{
public:
 virtual void Drive()
 {
 cout << "Benz-舒适" << endl;
 }
};
class BMW :public Car
{
public:
 virtual void Drive()
 {
 cout << "BMW-操控" << endl;
 }
};
void Test()
{
 Car* pBenz = new Benz;
 pBenz->Drive();
 Car* pBMW = new BMW;
 pBMW->Drive();
}

3. C++11 override 和 final
3.1 final 修饰基类的虚函数不能被派生类重写

class Car
{
public:
 virtual void Drive() final {}
};
class Benz :public Car
{
public:
 virtual void Drive() {cout << "Benz-舒适" << endl;}
};

3.2 override 修饰派生类虚函数强制完成重写，如果没有重写会编译报错

class Car{
public:
 virtual void Drive(){}
};
class Benz :public Car {
public:
 virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

4. 多态的原理
4.1 虚函数表

// 求：sizeof(Base)是多少？
class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};

在这里插入图片描述

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针，一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，。那么派生类中这个表放了些什么呢？我们接着往下分析

// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
 virtual void Func1()
 {
 cout << "Base::Func1()" << endl;
 }
 virtual void Func2()
 {
 cout << "Base::Func2()" << endl;
 }
 void Func3()
 {
 cout << "Base::Func3()" << endl;
 }
private:
 int _b = 1;
};
class Derive : public Base
{
public:
 virtual void Func1()
 {
 cout << "Derive::Func1()" << endl;
 }
private:
 int _d = 2;
};
int main()
{
 Base b;
 Derive d;
 return 0;
}

在这里插入图片描述
通过观察和测试，我们发现了以下几点问题：

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
  2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
  4. 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
  5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

4.2 虚表在vs下存放在代码段（测试代码如下）

//通过以下代码验证发现vs下虚表是存放在代码段的
class Base
{
public:
    virtual void Func1()
    {
         cout << "Func1()" << endl;
    }
    virtual void Func2()
    {
         cout << "Func2()" << endl;
    }
     void Func3()
    {
         cout << "Func3()" << endl;
    }
private:
    int _b = 1;
};
class Drive :public Base
{
public:
    virtual void Func1()
    {
         cout << "Drive::Func1()" << endl;
    }
private:
    int _d = 2;
};
int global = 10;//数据段
int main()
{
    Base b;
    Drive d;
    int tmp = 2;//栈上
    int*ptr = new int;//堆上
    cout << "栈: " << &tmp << endl;
    cout << "堆: " << ptr << endl;
    cout << "数据段: " << &global << endl;
    printf( "代码段:  %p\n", &Base :: Func3);
    printf("虚表： %p\n", *((int*)&d));
    return 0;
}

4.3 多态的原理
上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的
Person::BuyTicket，传Student调用的是Student::BuyTicket
在这里插入图片描述

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
 virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
 p.BuyTicket();
}
int main()
{
 Person Mike;
 Func(Mike);
 
 Student Johnson;
 Func(Johnson);
 return 0;
}

在这里插入图片描述

  1. 观察上图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  2. 观察上图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
  4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
  5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
void Func(Person* p)
{
p->BuyTicket();
}
int main()
{
Person mike;
Func(&mike);
mike.BuyTicket();
return 0;
}
// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
...
p->BuyTicket();
// p中存的是mike对象的指针，将p移动到eax中
001940DE mov eax,dword ptr [p]
// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1 mov edx,dword ptr [eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE mov eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的
中取找的。
001940EA call eax
00头1940EC cmp esi,esp
}
int main()
{
...
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
mike.BuyTicket();
00195182 lea ecx,[mike]
00195185 call Person::BuyTicket (01914F6h)
...
}

4.4 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

5.单继承和多继承关系的虚函数表

5.1 单继承中的虚函数表

class Base { 
public :
 virtual void func1() { cout<<"Base::func1" <<endl;}
 virtual void func2() {cout<<"Base::func2" <<endl;}
private :
 int a;
};
class Derive :public Base { 
public :
 virtual void func1() {cout<<"Derive::func1" <<endl;}
 virtual void func3() {cout<<"Derive::func3" <<endl;}
 virtual void func4() {cout<<"Derive::func4" <<endl;}
private :
 int b;
};

在这里插入图片描述
观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

class Base
{
public:
    virtual void func1(){ cout <<  "Base::func1<<endl"; }
    virtual void func2(){ cout <<  "Base::func2<<endl"; }
private:
    int a;
};
class Drive :public Base
{
public:
    virtual void func1(){ cout <<  "Drive::func1<<endl"; }
    virtual void func3(){ cout <<  "Drive::func3<<endl"; }
    virtual void func4(){ cout <<  "Drive::func4<<endl"; }
private:
    int b;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
         printf(" 第%d个虚函数地址 :0X%x,->", i,  vTable[i]);
         VFPTR f = vTable[i];
         f();
         cout << endl;
    }
    cout << endl;
}
int main()
{
    Base b;
    Drive d;
// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的
//指针数组，这个数组最后面放了一个nullptr
// 1.先取b的地址，强转成一个int*的指针
// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
// 4.虚表指针传递给PrintVTable进行打印虚表
// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有
//放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再编译就好了。
    VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    PrintVTable(vTableb);
    VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    PrintVTable(vTabled);
    return 0;
}

5.2 多继承中的虚函数表

class Base1
{
public:
    virtual void func1(){ cout << "Base1::func1" <<  endl; }
    virtual void func2(){ cout << "Base1::func2" <<  endl; }
private:
    int b1;
};
class Base2
{
public:
    virtual void func1(){ cout << "Base2::func1" <<  endl; }
    virtual void func2(){ cout << "Base2::func2" <<  endl; }
private:
    int b2;
};
////子类的虚表和父类的个数相同，子类自己定义的虚函数放在第一个直接父类的虚表中
class Drive :public Base1, public Base2
{
    virtual void func1(){ cout << "Drive::func1" <<  endl; }
    virtual void func3(){ cout << "Drive::func3" <<  endl; }
private:
    int d1;
};
//定义一个函数指针， 表示一类返回值为void,参数个数为0的函数
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
         printf(" 第%d个虚函数地址 :0X%x,->", i,  vTable[i]);
         VFPTR f = vTable[i];
         f();
    }
    cout << endl;
}
int main()
{
    Base1 b1;
    Base2 b2;
    Drive d;
    Base2* pb2 = &d;
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&b1);
    PrintVTable(vTableb1);
    VFPTR* vTableb2 = (VFPTR*)(*(int*)&b2);
    PrintVTable(vTableb2);
    VFPTR* vTableb3 = (VFPTR*)(*(int*)&d);
    PrintVTable(vTableb3);
    VFPTR* vTableb4 = (VFPTR*)(*(int*)pb2);
    //VFPTR* vTableb4 = (VFPTR*)(*(int*)((char*)&d  + sizeof(Base1)));
    PrintVTable(vTableb4);
    return 0;
}
A_supi
关注
【C++】多态
m0_74091744的博客
09-16 1990
多态是⼀个继承关系的下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。⽐如Student继承了Person。Person对象买票全价，Student对象优惠买票。• 必须指针或者引⽤调⽤虚函数• 被调⽤的函数必须是虚函数。说明：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向派⽣类对象；第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有不同的函数，多态的不同形态效果才能达到。
C++中的多态
shanshenyuyou的博客
07-09 302
多态的概念 1. What is Polymorphism? 1.1. 广义的多态：不同类型的实体/对象对于同一消息有不同的响应，就是OOP中的多态性。 1.2. 截止目前：多态性有两种表现的方式 1.2.1. 重载多态： class C { public: int f(int x); int f( ); }; 1.2.2. 子类型多态：不同的对象...
C++之多态
flyingcloud6的博客
11-22 779
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态 ,例如：买车票，有人买的是全票，而有的人是学生票。
从汇编看c++中多态的应用
12-26
在c++中，当一个类含有虚函数的时候，类就具有了多态性。构造函数的一项重要功能就是初始化vptr指针，这是保证多态性的关键步骤。构造函数初始化vptr指针下面是c++源码: 代码如下:class X {private: int i;public:...
C++中多态特性的详细解析与示例代码（包含详细的完整的程序和数据）
最新发布
10-07
主要内容包括多态的定义及其在C++中通过虚函数的应用；多态的基础、必要条件和常见应用场景；介绍了如何实现多态以及与多态密切相关的高级主题和技术细节。 适用人群：软件开发者及具备一定C++基础知识的工程技术...
深度剖析C++中多态的原理
weixin_45725144的博客
05-10 945
代码中第13行的doSpeak函数需要传的参数是Animal类型，而在20行传递的参数是Cat类型，这说明在调用doSpeak函数的时候，父类的指针指向了子类的对象，这时就发生了多态。从上图可以很清洗的看出Animal类的内部结构，当注释掉子类的重写代码（第11行）时，利用工具查看Cat的内部结构，如下图，此时Cat继承的还是Animal的函数。Cat类内部的结构为：子类vfptr（虚函数指针）指向子类vftable（虚函数表），其中vftable记录了子类虚函数的地址。2）子类重写父类的虚函数。
《C++》13 C++ 多态
学编程找莫离，莫离老师更懂你！
03-30 625
C++ 多态多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。下面的实例中，基类 Shape 被派生为两个类，如下所示：#include <iostream> using namespace std;class Shape { protected: int w
c++中多态实现过程
11-27
C++中多态的实现过程如下： 1. 定义一个基类，其中包含一个或多个虚函数。 2. 派生出一个或多个子类，这些子类重写了基类中的虚函数。 3. 在程序中创建基类的指针，并将其指向子类的对象。 4. 调用基类的虚函数，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值