c++多态

最新推荐文章于 2024-03-29 18:27:47 发布
最新推荐文章于 2024-03-29 18:27:47 发布
阅读量658 收藏
点赞数 1
分类专栏： c++ 文章标签： c++ 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_27435045/article/details/52988825
版权

运行环境：win10+vs2015，数据以小端字节序存储

多态，顾名思义“多种状态”。
首先，要想知道多态的运行了机制，首先要了解一下对象的类型。

对象的类型：

  • 静态类型：对象声明时的类型，是在编译时确定的
  • 动态类型：目前所指向对象的类型，是在运行时确定的

举个例子：

class Base{};
class Deri1:public Base{};
class Deri2:public Base{};

int main(){
    Deri1* p1 = new Deri1;//p1的静态类型是Deri1*，动态类型是Deri1*
    Base* pBase = p1;     //pBase的静态类型是Base*，动态类型是Deri1*
    Deri2* p2 = new Deri2;
    pBase = p2;           //pBase的动态类型是Deri2*
}

由上可知，多态就是一个指针拥有多种动态类型。

多态分为两种：

  • 静态多态：函数重载，泛型编程
  • 动态多态：虚函数

静态多态
编译器在编译期间完成的，编译器更具函数实参的类型（可能会进行隐式类型转换），可推断出要调用哪个函数，如果有对应的函数就调用该函数，没有就会报错

动态多态
动态绑定：在程序执行期间（非编译期）判断所引用函数的实际类型，通过其实际类型调用相应的方法
动态绑定条件：
1. 必须是虚函数
2. 通过基类类型的引用或者指针调用虚函数
使用virtual关键字修饰类的成员函数，指明该函数为虚函数，派生类需要重新实现，编译器将实现动态绑定
例如

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

int main() {
    Base* b=new Base;//此时指针b的动态类型是Base*，调用的是基类的fun()函数
    b->fun();
    b = new Deri;//此时指针b的动态类型是Deri*，调用的是派生类的fun()函数
    b->fun();
    return 0;
}

运行结果：
Base::fun()
Deri::fun()
这种就是只有程序运行到这里的时候才知道调用哪个函数，称为动态多态。

但是有引发了一个问题，基类和派生类的函数重名了，他们之间的关系是什么呢？
继承体系同名成员函数的关系
- 重载：在同一作用域，函数名相同、参数不同，返回值可以不同
- 重写（覆盖）：不在同一作用域（分别在基类和派生类），函数名相同、参数相同、返回值相同（协变例外），基类函数必须有virtual关键字，访问修饰符可以不同
- 重定义（隐藏）：在不同作用域中（分别在基类和派生类）、函数名相同、在基类和派生类中只要不构成重写的就是重定义

纯虚函数
在虚成员函数的形参后面写上“=0”，则成员函数为纯虚函数，包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象，纯虚函数在派生类中重定义以后，派生类才能实例化出对象。

虚表：
只要类中包含有虚函数，则这个类的对象就有一个虚表指针，指向虚表
虚表指针：是在类对象的头4个字节存入虚表的地址，里面包括该类的所有虚函数的地址，且由定义的顺序由声明顺序依次排序存于虚表中。在派生类中，前面是基类的虚函数，后面是派生类的虚函数。
派生类虚表的生成：

  1. 先拷贝基类的虚函数表
  2. 如果派生类重写了基类的某个虚函数，就会替换同位置的基类虚函数
  3. 跟上派生类自己新定义的虚函数

通过基类的引用或指针调用虚函数时，调用基类还是派生类的虚函数，要根据运行时所引用（指针）实际引用（指向）的类型确定；调用非虚函数时，则无论基类指向的是何种类型，都调用的是基类的函数

多态的内存结构：
单继承分为单虚继承和单非虚继承。
单非虚继承的内存结构没有偏移量表，其他内存分布与单虚继承相同
这里具体讨论单虚继承
单虚继承分为派生类重写基类虚函数、派生类新添虚函数、派生类既重写又新添虚函数。
例如：

class Base {
public:
    virtual void fun() {
        cout << "Base::fun()" << endl;
    }
    int b_data;
};
class Deri :public Base {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    int v_data;
};
int main() {
    Deri* d = new Deri;
    d->b_data = 1;
    d->v_data = 2;  
    return 0;
}

该代码执行后的d所指向地址空间为
0x0123EDD0 50 9b 13 01 //指向虚函数表
0x0123EDD4 01 00 00 00 //基类成员变量
0x0123EDD8 02 00 00 00 //自己的成员变量

将继承改成虚继承后，即使用virtual关键字将程序改为：

class Deri :virtual public Base {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    int v_data;
};

d所指向空间的内存分布为

0x00C1D370  58 9b ef 00       //跟进这个内存可知其存放的是派生类对基类和自己的偏移量表
    0x00EF9B58  00 00 00 00   //对自己的偏移量
    0x00EF9B5C  08 00 00 00  //对基类的偏移量
0x00C1D374  02 00 00 00  
0x00C1D378  50 9b ef 00        //跟进可知其指向的是一张虚表，由于满足重写的条件，所以只有一个函数指针
    0x00EF9B50  7f 13 ef 00    
    0x00EF9B54  00 00 00 00
0x00C1D37C  01 00 00 00

如果派生类的成员函数与基类的成员函数名不同，即

class Deri :virtual public Base {
public:
    virtual void fun1() {
        cout << "Deri::fun1()" << endl;
    }
    int v_data;
};

运行后，派生类的内存分布：

0x009DEFB8  50 9b 31 00       //指向一个虚函数表
    0x00319B50  83 14 31 00  
    0x00319B54  00 00 00 00 
0x009DEFBC  88 9c 31 00       //指向偏移量表
    0x00319C88  fc ff ff ff         //对自己的偏移量
    0x00319C8C  08 00 00 00   //对基类的偏移量 
0x009DEFC0  02 00 00 00  
0x009DEFC4  5c 9b 31 00       //指向一个虚函数表
    0x00319B5C  69 10 31 00  
    0x00319B60  00 00 00 00
0x009DEFC8  01 00 00 00

重写基类函数并且自己新添虚函数

class Deri :virtual public Base {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    virtual void fun1() {
        cout << "Deri::fun1()" << endl;
    }
    int v_data;
};

运行后派生类的内存结构

0x00B6BEF0  50 9b 2a 00         //指向虚函数的地址
    0x002A9B50  83 14 2a 00  
    0x002A9B54  00 00 00 00
0x00B6BEF4  88 9c 2a 00         //偏移量表
    0x002A9C88  fc ff ff ff  
    0x002A9C8C  08 00 00 00 
0x00B6BEF8  02 00 00 00  
0x00B6BEFC  5c 9b 2a 00        //虚函数表
    0x002A9B5C  88 14 2a 00  
    0x002A9B60  00 00 00 00
0x00B6BF00  01 00 00 00

多继承
多继承也可以分为
例如：

class Base1 {
public:
    virtual void fun() {
        cout << "Base1::fun()" << endl;
    }
    int b1_data;
};
class Base2 {
public:
    virtual void fun() {
        cout << "Base2::fun()" << endl;
    }
    int b2_data;
};
class Deri :public Base1,public Base2 {
public:
    int v_data;
};

int main() {
    Deri* d = new Deri;
    d->b1_data = 1;
    d->b2_data = 2;
    d->v_data = 3;  
    return 0;
}

程序运行后的d的内存结构

0x0111E6A8  a0 9c ff 00             //第一继承类虚表指针  
    0x00FF9CA0  a1 14 ff 00 
    0x00FF9CA4  00 00 00 00
0x0111E6AC  01 00 00 00  
0x0111E6B0  94 9c ff 00             //第二继承类虚表指针
    0x00FF9C94  9c 14 ff 00  
    0x00FF9C98  00 00 00 00
0x0111E6B4  02 00 00 00  
0x0111E6B8  03 00 00 00

添加virtual关键字后，变成虚继承

class Deri :virtual public Base1,virtual public Base2 {
public:
    int v_data;
};

运行后派生类的空间结构

0x007ADD48  88 9d a6 00         //派生类偏移量表
    0x00A69D88  00 00 00 00  
    0x00A69D8C  08 00 00 00
0x007ADD4C  03 00 00 00  
0x007ADD50  a0 9c a6 00             //第一继承虚函数表
    0x00A69CA0  a1 14 a6 00  
    0x00A69CA4  00 00 00 00
0x007ADD54  01 00 00 00  
0x007ADD58  94 9c a6 00             //第二继承虚函数表
    0x00A69C94  9c 14 a6 00  
    0x00A69C98  00 00 00 00
0x007ADD5C  02 00 00 00

在派生类里面加一个与基类同名的函数

class Deri :virtual public Base1,virtual public Base2 {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    int v_data;
};

运行后d的内存空间结构

0x0089F318  88 9d a9 00             //指向派生类偏移量表
    0x00A99D88  00 00 00 00  
    0x00A99D8C  08 00 00 00
0x0089F31C  03 00 00 00  
0x0089F320  a0 9c a9 00             //第一继承虚函数表
    0x00A99CA0  88 14 a9 00  
    0x00A99CA4  00 00 00 00 
0x0089F324  01 00 00 00  
0x0089F328  94 9c a9 00             //第二继承虚函数
    0x00A99C94  8d 14 a9 00  
    0x00A99C98  00 00 00 00
0x0089F32C  02 00 00 00

将派生类改为虚继承且新添虚函数后

class Deri :virtual public Base1,virtual public Base2 {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    virtual void fun1() {
        cout << "Deri::fun1()" << endl;
    }
    int v_data;
};

0x00BABE98  a0 9c 2f 00         //指向派生类虚表
    0x002F9CA0  83 14 2f 00  
    0x002F9CA4  00 00 00 00 
0x00BABE9C  94 9d 2f 00         //指向偏移量表
    0x002F9D94  fc ff ff ff  
    0x002F9D98  08 00 00 00
0x00BABEA0  03 00 00 00  
0x00BABEA4  94 9c 2f 00         //第一继承虚表
    0x002F9C94  88 14 2f 00  
    0x002F9C98  00 00 00 00
0x00BABEA8  01 00 00 00  
0x00BABEAC  8c 9d 2f 00         //第二继承虚表
    0x002F9D8C  8d 14 2f 00  
    0x002F9D90  00 00 00 00 
0x00BABEB0  02 00 00 00

菱形继承
菱形继承是一种特殊的继承，如图所示
菱形继承

未使用虚继承的菱形继承，但是会产生二义性

class A {
public:
    virtual void fun() {
        cout << "A::fun()" << endl;
    }
    int a_data;
};

class Base1:public A {
public:
    virtual void fun() {
        cout << "Base1::fun()" << endl;
    }
    int b1_data;
};
class Base2:public A {
public:
    virtual void fun() {
        cout << "Base2::fun()" << endl;
    }
    int b2_data;
};
class Deri :public Base1,public Base2 {
public:
    int v_data;
};

int main() {
    Deri* d = new Deri;
    d->Base1::a_data = 4;
    d->Base2::a_data = 5;
    d->b1_data = 1;
    d->b2_data = 2;
    d->v_data = 3;  
    return 0;
}

运行后d的内存结构

0x00F1D300  84 9b 14 01
    0x01149B84  4c 14 14 01  
    0x01149B88  00 00 00 00  
0x00F1D304  04 00 00 00 
0x00F1D308  01 00 00 00 
0x00F1D30C  90 9b 14 01 
    0x01149B90  44 12 14 01  
    0x01149B94  00 00 00 00
0x00F1D310  05 00 00 00  
0x00F1D314  02 00 00 00  
0x00F1D318  03 00 00 00

使用虚函数且派生类添加自己的虚函数，则变成

class A {
public:
    virtual void fun() {
        cout << "A::fun()" << endl;
    }
    int a_data;
};

class Base1:virtual public A {
public:
    virtual void fun() {
        cout << "Base1::fun()" << endl;
    }
    int b1_data;
};
class Base2:virtual public A {
public:
    virtual void fun() {
        cout << "Base2::fun()" << endl;
    }
    int b2_data;
};
class Deri :public Base1,public Base2 {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    int v_data;
};

生成d的内存空间：

0x0078D3C0  9c 9b e6 00  
    0x00E69B9C  00 00 00 00  
    0x00E69BA0  14 00 00 00
0x0078D3C4  01 00 00 00  
0x0078D3C8  c8 9c e6 00 
    0x00E69CC8  00 00 00 00 
    0x00E69CCC  0c 00 00 00
0x0078D3CC  02 00 00 00 
0x0078D3D0  03 00 00 00  
0x0078D3D4  7c 9b e6 00  
    0x00E69B7C  92 14 e6 00  
    0x00E69B80  00 00 00 00
0x0078D3D8  05 00 00 00

每层继承都有新添加的虚函数，也重写了基类的虚函数

class A {
public:
    virtual void fun() {
        cout << "A::fun()" << endl;
    }
    int a_data;
};

class Base1:virtual public A {
public:
    virtual void fun() {
        cout << "Base1::fun()" << endl;
    }
    virtual void fun2() {
        cout << "Base1::fun2()" << endl;
    }
    int b1_data;
};
class Base2:virtual public A {
public:
    virtual void fun() {
        cout << "Base2::fun()" << endl;
    }
    virtual void fun3() {
        cout << "Base2::fun3()" << endl;
    }
    int b2_data;
};
class Deri :public Base1,public Base2 {
public:
    virtual void fun() {
        cout << "Deri::fun()" << endl;
    }
    virtual void fun4() {
        cout << "Deri::fun4()" << endl;
    }
    int v_data;
};

运行后d的内存空间

0x00BA9818  d4 9b 02 01  
    0x01029BD4  4c 14 02 01  
    0x01029BD8  01 14 02 01  
0x00BA981C  f8 9b 02 01 
    0x01029BF8  fc ff ff ff  
    0x01029BFC  18 00 00 00
0x00BA9820  01 00 00 00  
0x00BA9824  e4 9b 02 01  
    0x01029BE4  29 14 02 01  
    0x01029BE8  00 00 00 00  
0x00BA9828  04 9c 02 01  
    0x01029C04  fc ff ff ff  
    0x01029C08  0c 00 00 00
0x00BA982C  02 00 00 00  
0x00BA9830  03 00 00 00  
0x00BA9834  f0 9b 02 01  
    0x01029BF0  8e 13 02 01  
    0x01029BF4  00 00 00 00
0x00BA9838  05 00 00 00

上面的例子只是说明了一些分析方法的思想，还有很多种情况没有讨论，但是只要知道了这一种的分析方法，就可以得到其他的内存结构分布。
综上所述，派生类的结构与其继承的关系有关，但是整体位置思想是不变的，即：虚函数表–>偏移量表–>成员数据。
其他的都是一些基类与派生类的叠放次序问题。
如果想知道函数指针指向的的地址是什么，可用函数指针来访问，具体代码如下：

typedef void(*vpf)();
void PriFun(){
    Deri* d=new Deri();
    vpf* p = (vpf*)(*(int*)d);
    while (*p != 0) {
        (*p)();
        p++;
    } 
}

该段代码可以查看派生类的第一张虚表里的函数，稍作修改即可查看派生类所有的虚表。
总结：

  1. 派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值相同（协变除外）
  2. 基类定义了虚函数，在派生类中该函数始终保持虚函数特性
  3. 只有类的非静态成员函数才能定义为虚函数，静态成员函数不能定义为虚函数
  4. 如果在类外定义虚函数，只能在声明函数时加virtual关键字，定义时不用加
  5. 如果在类外定义虚函数，虽然可以将poerator=定义为虚函数，但是最好不要这样做，使用时会容易混淆
  6. 不要再构造函数和析构函数中调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会出现未定义的行为
  7. 最好将基类的析构函数声明为虚函数（析构函数比较特殊，因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖，这里编译器做了特殊处理）
  8. 虚表是所有类对象实例共用的
dh爱你的我
关注
专栏目录
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
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++ 多态
jun8086的博客
10-31 642
c++ 多态
C++多态详解
最新发布
lim6ere的博客
03-29 816
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
c++多态 详解
qq_39117115的博客
03-09 1159
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++ 多态类型
索命的博客
11-06 500
C++ 多态入门
c++多态实现原理
karl2000的专栏
03-07 482
我们可以为每个“类”定义一个结构体，其中包含数据成员和一个指向函数指针数组的指针（模拟 vptr）。
c++ 多态详解
不倒翁.
05-02 5727
c++多态详解
C++多态（超级详细版）
kkbca的博客
10-28 1万+
在继承中要构成多态还有两个条件：1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写public:virtual void BuyTicket() { cout
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚...
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...
#pragma once和#ifundef的区别
dh爱你的我的博客
12-06 1665
在某些高版本中可以使用 #pragma once，这里区别一下#ifundef和#pragma once #pragma once兼容性不好，不是所有编译器都支持，#ifundef是C/C++的标准，所有编译器都支持 #pragma once将作用与整个文件，#ifundef可以自定义作用范围 #pragma once可以防止同文件引入，但是不能防止同内容文件引入；#ifundef既可以防止同文件一
通用寄存器
dh爱你的我的博客
10-31 1487
计算的内置寄存器结构分布，以8086CPU的内部寄存器为例：16位CPU通用寄存器共有8个，AX,BX,CX,DX,SP,BP,SI,DI AH和AL是将一个16位的寄存器分别作为两个独立的寄存器，高8位记作H，低8位记作L。 其中有的有特殊的用途：AX为累加器，CX为计数器，BX，BP为基址寄存器，SI,DI为变址寄存器，BP还可以是基指针，SP为堆栈指针。 32位CPU通用寄存器共也有8个
栈应用实例--迷宫问题
dh爱你的我的博客
12-02 824
调试环境：vs2015+win10众所周知，栈是一个非常常见且有用的数据结构。 这里讲解一下利用栈来实现迷宫问题。使用递归实现假设有一迷宫 其中：1代表墙；0代表路径 为简化编程，假设左边界0处为迷宫入口，下边界0处为迷宫出口库。分析问题： 创建一个结构体，表示在迷宫的坐标 从文件中读取迷宫 获取迷宫路径，需要判断是否可走，将走过的地方标记为2 代码实现：#include<assert.h
c++模板函数
dh爱你的我的博客
11-02 633
调试环境 win10+vs2015 模板是c++中泛型编程的基础，一个模板就是一创建类或函数的蓝图或者说公式。（c++ primer） 其实模板对于我们生活来说是十分常见的，在编程这里也不例外。 对于编程的初学者来说，多写一点代码，可以增加代码熟练度，但是对于工程来说，那就是浪费时间。 所以c++提供了模板这个机制。如何编写一个通用的加法函数 使用函数重载，针对每个所需相同行为的不同类型重新
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值