多态&对象模型

最新推荐文章于 2024-07-08 21:32:26 发布
最新推荐文章于 2024-07-08 21:32:26 发布
阅读量369 收藏
点赞数
分类专栏： C/C++ 文章标签： 多态 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiyingkang___/article/details/76222615
版权

多态： 即多种状态，在C++中有着更广泛的含义，多态分为静态多态和动态多态。
这里写图片描述
静态多态：编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。
这里写图片描述
动态多态：
【动态多态】
动态绑定：在程序执行期间(非编译期)判断所引用对象的实际类型，根据其实际类型调用相应的方法。
使用virtual关键字修饰类的成员函数时，指明该函数为虚函数，派生类需要重新实现，编译器将实现动态绑定。
实例代码：

#include<iostream>
using namespace std;

class WC
{
public:
    void ManWC()
    {
        cout<<"man-->please left"<<endl;
    }
    void WoManWC()
    {
        cout<<"woman-->please right"<<endl;
    }
};

class WCRoom
{
public:
    virtual void GoToWC(WC& _wcroom)=0;
};

class Man:public WCRoom
{
    virtual void GoToWC(WC& _wcroom)
    {
        _wcroom.ManWC();
    }
};
class WoMan:public WCRoom
{
    virtual void GoToWC(WC& _wcroom)
    {
        _wcroom.WoManWC();
    }
};


void FunTest()
{
    WC wc;
    for(int i = 1;i<+10;++i)
    {
        WCRoom* pWCRoom;
        int iWCRoom = rand()%i;
        if(iWCRoom&0x01)
        {
            pWCRoom = new Man;
        }
        else
        {
            pWCRoom = new WoMan;
        }
        pWCRoom->GoToWC(wc);
        delete pWCRoom;
        pWCRoom = NULL;
    }
}

int main()
{
    FunTest();
    return 0;
}

代码中通过上厕所问题，完美解释什么是动态多态，在程序运行中，有程序本身去选择实现怎样的功能，而不是想静态多态那样在编译阶段就已经确定了代码后面会走调用哪个函数。

测试结果：这里写图片描述

【动态绑定条件】
1、必须是虚函数
2、通过基类类型的引用或者指针调用虚函数

继承体系下同名函数的关系：
1、重载：在同一作用域下，函数名相同，参数类型不同的函数，可以构成重载
2、重写（覆盖）：函数本身不在同一作用域内，一个在基类中，一个在派生类中，函数的返回值相同，函数名相同，参数列表相同，而且基类中的函数被virtual修饰，不管是基类还是派生类的对象，都要使用基类的指针或者引用调用，才能实现重载。
3、重定义：在不同作用域下，一个基类，一个派生类，函数名相同，只要不构成重写，基类的函数就会被隐藏，调用时只会调用派生类的函数。
4、协变：基类中虚函数返回类型是Base&或者Base*，派生类中虚函数的返回类型是Derived&或者Derived*。

重写：

#include<iostream>
using namespace std;

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

class Derived:public Base
{
public:
    virtual void FunTest()
    {
        cout<<"Derived::FunTest()"<<endl;
    }
};
void FunTest1(Base& b)
{
    b.FunTest();
}


int main()
{
    Base b;
    Derived d;
    FunTest1(b);
    FunTest1(d);
    return 0;
}

这里写图片描述

重定义：

#include<iostream>
using namespace std;

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

class Derived:public Base
{
public:
    virtual void FunTest()
    {
        cout<<"Derived::FunTest()"<<endl;
    }
};

int main()
{
    Base b;
    Derived d;

    b.FunTest();
    d.FunTest();
    return 0;
}

这里写图片描述

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

class Base
{
    virtual void Display() = 0;
};

class Derived:public Base
{};

Base类包含纯虚函数，是一个抽象类，自己不能实例化出自己的对象，而继承于他的派生类，却可以构建自己的对象。

无继承下的虚函数表：
这里写图片描述
如果一个类中出现了虚函数，则这个类在构建对象时会生成一张虚函数表，而这张虚函数表的起始地址存放在对象内存中前四个字节，也就是说这个对象内存中的前四个字节存放着一个指针，指向这个类的虚函数表，并且这个类构建的所有对象是公用一张虚函数表的。
测试代码：

#include<iostream>
using namespace std;

typedef void (*p)();

class Base
{
public:
    Base()
        :_b(1)
    {
    }
    virtual void FunTest1()
    {
        cout<<"FunTest1()"<<endl;
    }
    virtual void FunTest2()
    {
        cout<<"FunTest2()"<<endl;
    }
    virtual void FunTest3()
    {
        cout<<"FunTest3()"<<endl;
    }
private:
    int _b;
};

void FunTest(Base* b)
{
    p* pt = (p*)(*(int*)b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}

int main()
{
    Base b;
    cout<<sizeof(b)<<endl;
    FunTest(&b);
    return 0;
}

单继承下的虚函数表：
这里写图片描述
单继承下的虚函数表，如果派生类中对基类的函数进行了重写，则虚函数表中原本是基类的虚函数会被重写成派生类的虚函数，派生类中如果添加了新的虚函数，则这些虚函数会被放在虚函数表的后面，顺序是虚函数在派生类中声明的顺序。
测试代码：

#include<iostream>
using namespace std;

typedef void (*p)();

class Base
{
public:
    Base()
        :_b(1)
    {
    }
    virtual void FunTest1()
    {
        cout<<"Base::FunTest1()"<<endl;
    }
    virtual void FunTest2()
    {
        cout<<"Base::FunTest2()"<<endl;
    }
    virtual void FunTest3()
    {
        cout<<"Base::FunTest3()"<<endl;
    }
    int _b;
};

class Derived:public Base
{
public:
    Derived()
        :_d(2)
    {}
    virtual void FunTest2()
    {
        cout<<"Derived::FunTest2()"<<endl;
    }
    virtual void FunTest4()
    {
        cout<<"Derived::FunTest4()"<<endl;
    }
    int _d;
};

void FunTest(Base* b)
{
    p* pt = (p*)(*(int*)b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}

int main()
{
    Derived d;
    cout<<sizeof(d)<<endl;
    FunTest(&d);

多继承下虚函数表：
这里写图片描述
多继承下，虚函数表是分为两个表的，一个是A1的，一个是B1的，这两张表分别放在不同的地方，如果派生类对A1,B1里面的虚函数进行了重写，那么A1,B1相对应的虚函数表中，被重写的函数会被替换成派生类的虚函数，如果派生类中有新添加的虚函数，则这些新添加的虚函数会被放在第一张虚函数表的后面，顺序是这些虚函数在派生类中声明的顺序。
测试代码：

#include<iostream>
using namespace std;

typedef void (*p)();

class A1
{
public:
    A1()
        :_a1(1)
    {
    }
    virtual void FunTest1()
    {
        cout<<"A1::FunTest1()"<<endl;
    }
    virtual void FunTest2()
    {
        cout<<"A1::FunTest2()"<<endl;
    }
    int _a1;
};
class B1
{
public:
    B1()
        :_b1(3)
    {
    }
    virtual void FunTest3()
    {
        cout<<"B1::FunTest3()"<<endl;
    }
    virtual void FunTest4()
    {
        cout<<"B1::FunTest4()"<<endl;
    }
    int _b1;
};

class Derived:public A1,public B1
{
public:
    Derived()
        :_d(2)
    {}
    virtual void FunTest2()
    {
        cout<<"Derived::FunTest2()"<<endl;
    }
    virtual void FunTest3()
    {
        cout<<"Derived::FunTest3()"<<endl;
    }
    virtual void FunTest5()
    {
        cout<<"Derived::FunTest5()"<<endl;
    }
    int _d;
};

void FunTest1(A1* b)
{
    p* pt = (p*)(*(int*)b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
void FunTest2(B1* b)
{
    p* pt = (p*)(*(int*)b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}

int main()
{
    Derived d;
    cout<<sizeof(d)<<endl;
    FunTest1(&d);
    FunTest2(&d);
    return 0;
}

菱形继承下的虚函数表：
这里写图片描述
菱形继承基本上同前面的多继承差不多，第一张虚函数表是A1继承C得来的，C中的虚函数若在A1中被重写，则第一张虚函数表里的C的虚函数会被A1的虚函数给替换掉，同理在第二张虚函数表中，被重写的基类的虚函数都会被替换掉，A1,B1新添加的虚函数会分别添加在这两张表的后面，顺序是虚函数在A1,B1中的声明顺序，被派生类重写的A1,B1的虚函数也会分别在这两张虚函数表中被替换掉，而派生类新添加的虚函数只会被添加在第一张虚函数表的后面，顺序也是虚函数在派生类中的声明顺序。
测试代码：

#include<iostream>
using namespace std;

typedef void (*p)();

class C
{
public:
    C()
        :_c(4)
    {}
    virtual void FunTest1()
    {
        cout<<"C::FunTest1()"<<endl;
    }
    virtual void FunTest4()
    {
        cout<<"C::FunTest4()"<<endl;
    }
    int _c;
};

class A1:public C
{
public:
    A1()
        :_a1(1)
    {
    }
    virtual void FunTest1()
    {
        cout<<"A1::FunTest1()"<<endl;
    }
    virtual void FunTest2()
    {
        cout<<"A1::FunTest2()"<<endl;
    }
    int _a1;
};
class B1:public C
{
public:
    B1()
        :_b1(3)
    {
    }
    virtual void FunTest3()
    {
        cout<<"B1::FunTest3()"<<endl;
    }
    virtual void FunTest4()
    {
        cout<<"B1::FunTest4()"<<endl;
    }
    int _b1;
};

class Derived:public A1,public B1
{
public:
    Derived()
        :_d(2)
    {}
    virtual void FunTest2()
    {
        cout<<"Derived::FunTest2()"<<endl;
    }
    virtual void FunTest3()
    {
        cout<<"Derived::FunTest3()"<<endl;
    }
    virtual void FunTest5()
    {
        cout<<"Derived::FunTest5()"<<endl;
    }
    int _d;
};

void FunTest1(A1* b)
{
    p* pt = (p*)(*(int*)b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
void FunTest2(B1* b)
{
    p* pt = (p*)(*(int*)b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}

int main()
{
    Derived d;
    cout<<sizeof(d)<<endl;
    FunTest1(&d);
    FunTest2(&d);
    return 0;
}

虚拟继承下的虚函数表：
这里写图片描述
在虚拟继承下，会生成对应的地址偏移量表，这个偏移量表会放在虚函数表的下面，因此偏移量表的前四个字节带面的偏移量是一个负数，因为他要指到存放虚函数表地址的空间处，这个空间地址才是整个对象的起始地址，在虚拟继承中，基类会被放到整个派生类对象内存的最后面，基类会保留他自己的虚函数表，如果派生类对其中的某些虚函数进行了重写，那么基类保留的那张虚函数表中的某些虚函数会被重写写改成是派生类的虚函数，而派生类自己新添加的虚函数，不会附在基类虚函数表的后面，而是在整个派生类对象的最前面生成一张新的虚函数表，这张虚函数表只存放派生类新添加的虚函数。
测试代码：

#include<iostream>
using namespace std;

typedef void (*p)();


class A
{
public:
    A()
        :_a(4)
    {}
    virtual void FunTest1()
    {
        cout<<"A::FunTest1()"<<endl;
    }
    virtual void FunTest2()
    {
        cout<<"A::FunTest2()"<<endl;
    }
    int _a;
};

class B:virtual public A
{
public:
    B()
        :_b(5)
    {}
    virtual void FunTest2()
    {
        cout<<"B::FunTest2()"<<endl;
    }
    virtual void FunTest3()
    {
        cout<<"B::FunTest3()"<<endl;
    }
    int _b;
};

void FunTest1(A& b)
{
    p* pt = (p*)(*(int*)&b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
void FunTest2(B& b)
{
    p* pt = (p*)(*(int*)&b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
int main()
{
    B b;
    FunTest1(b);
    FunTest2(b);
    return 0;
}

菱形虚拟继承下的虚函数表：
这里写图片描述
在菱形虚拟继承下，派生类新添加的虚函数表，并没有重新开辟空间存放，而是放在了派生类继承的第一个对象的虚函数表的后面。
测试代码：

#include<iostream>
using namespace std;

typedef void (*p)();


class A
{
public:
    A()
        :_a(4)
    {}
    virtual void FunTest1()
    {
        cout<<"A::FunTest1()"<<endl;
    }
    virtual void FunTest2()
    {
        cout<<"A::FunTest2()"<<endl;
    }
    virtual void FunTest3()
    {
        cout<<"A::FunTest3()"<<endl;
    }
    virtual void FunTest4()
    {
        cout<<"A::FunTest4()"<<endl;
    }   
    int _a;
};

class B1:virtual public A
{
public:
    B1()
        :_b1(5)
    {}
    virtual void FunTest2()
    {
        cout<<"B1::FunTest2()"<<endl;
    }
    virtual void FunTest5()
    {
        cout<<"B1::FunTest5()"<<endl;
    }
    virtual void FunTest6()
    {
        cout<<"B1::FunTest6()"<<endl;
    }
    int _b1;
};
class B2:virtual public A
{
public:
    B2()
        :_b2(5)
    {}
    virtual void FunTest3()
    {
        cout<<"B2::FunTest3()"<<endl;
    }
    virtual void FunTest7()
    {
        cout<<"B2::FunTest7()"<<endl;
    }
    virtual void FunTest8()
    {
        cout<<"B2::FunTest8()"<<endl;
    }
    int _b2;
};
class C:public B1,public B2
{
public:
    C()
        :_c(6)
    {}
    virtual void FunTest8()
    {
        cout<<"C::FunTest8()"<<endl;
    }
    virtual void FunTest6()
    {
        cout<<"C::FunTest6()"<<endl;
    }
    virtual void FunTest9()
    {
        cout<<"C::FunTest9()"<<endl;
    }
    int _c;
};

void FunTest1(A& b)
{
    p* pt = (p*)(*(int*)&b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
void FunTest2(B1& b)
{
    p* pt = (p*)(*(int*)&b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
void FunTest3(B2& b)
{
    p* pt = (p*)(*(int*)&b);
    while (*pt)
    {
        (*pt)();
        pt++;
    }
}
int main()
{
    C b;
    FunTest1(b);
    FunTest2(b);
    FunTest3(b);

    return 0;
}
shiyingkang___
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多态&多态对象模型&虚函数表
baidu_37964044的博客
02-05 237
所谓多态，就是指多种形态 C++中虚函数的主要作用就是实现多态，简单说，父类的指针/引用调用重写的虚函数，当父类指针/引用指向父类对象时，调用的是父类的虚函数，指向子类对象调用的是子类的虚函数。 虚函数表 虚函数表（虚表）是通过一块连续内存来存储虚函数的地址，这张表解决了继承，虚函数（重写）的问题。在有虚函数的对象实例中都存在一张虚函数表，虚函数表就像一张地图，指名了实际应该调用的虚函数地址
C++对象模型源码下载
02-14
C++对象模型是C++编程语言的核心组成部分，它定义了如何在内存中表示类和对象，以及它们之间的关系。理解C++对象模型对于深入学习C++、优化代码性能以及调试程序至关重要。在这个源码下载中，你可以探索这些概念的...
多态&多态对象模型
Sakuramyb马永博的博客
08-01 558
一、什么是多态1.定义：多态，顾名思义就是”多种形态”。 2.构成多态的两个条件： 1）.虚函数的重写。（子类可以不用写virtual，但父类必须写virtual，一般最好子类和父类都加virtual） 2）.父类的指针（或引用）调用虚函数。 3.虚函数的作用主要就是实现多态，简单的说父类的指针或引用调用重写的虚函数的时候，当父类指针或者引用指向父类对象时调用的是父类的虚函数，指向子类对象时
C++多态&多态模型
婉茹的博客
08-02 472
多态&多态模型 一、什么是多态？   多态顾名思义就是一个事物有多种形态，在C++程序设计中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数，即“一个接口，多种方法”。 多态分为两种：   （1）静态多态（重载函数、模板等）；（2）动态多态（虚函数等）。 构成多态的条件： （1）虚函数的重写。（子类可以不用写virtual，但父
浅谈C++多态&多态对象模型
Blessing_zf的博客
08-01 505
多态所谓多态，其实就是“多种形态”，C++的多态分为静态多态和动态多态。 1. 静态多态就是重载，因为是在编译期决议确定，所以称为静态多态。 2. 动态多态就是通过继承重写基类的虚函数实现的多态，因为是在运⾏时决议确定，所以称为动态多态。C++中虚函数的主要作⽤——就是实现多态。简单说⽗类的指针/引⽤调⽤重写的虚函数，当⽗类指针/引⽤指向⽗类对象时调⽤的是⽗类的虚函数，指向⼦类对象时调⽤的是⼦类
多态&多态的对象模型
bin_4545的博客
08-01 195
什么是多态？       多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形态。C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。 三个易混淆概念： 1.重载： (1)在同一个作用域下。 (2)函
C++ 多态&多态对象模型
Coder's Blog
08-01 358
1：什么多态？ 虚函数&多态 虚函数–类的成员函数前面加virtual关键字，则这个成员函数称为虚函数。 虚函数重写–当在子类的定义了一个与父类完全相同的虚函数时，则称子类的这个 函数重写(也称覆盖)了父类的这个虚函数。总结: 派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相 同。(协变除外) 基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。 只有类的成员函数才
多态 & 深入探索C++模型
JS_Evey的博客
08-03 422
多态 & 深入探索C++模型多态性 多态性 虚函数 单继承对象模型 多继承对象模型
多态的对象模型
Qiana_wq的博客
07-31 229
1：所谓多态就是多种形态，在两个类中，函数名相同的函数，通过不同对象的调用，产生不同的结果。多态和类型无关，只和对象有关。 构成多态的条件：(1)虚函数的重写：子类中和父类相同点的虚函数 (2)父类的指针/引用调用虚函数 当指向父类的指针或引用调用重写的虚函数时，当指向父类调用的就是父类的虚函数，当指向子类调用的就是子类的虚函数。 2：多态的对象模型 单继承class Base { pub
多态及多态的对象模型
ypt
07-26 374
1.什么多态？  所谓多态，其实就是“多种形态”。C++中虚函数的作用主要就是实现多态。简单说父类的指针或者引用调用重写的虚函数，当父类指针或者引用指向父类对象时调用的是父类的虚函数，指向子类对象调用的是子类的虚函数。 虚函数表是通过一块连续内存来储存虚函数的地址。这张表解决了继承、虚函数（重写）的问题。在有虚函数的对象实例中都存在一个指向虚函数表的指针，虚函数表就像一张地图，指明实际应该调用...
多态和多态对象模型
weixin_40417029的博客
05-09 212
一、虚函数&amp;amp;多态虚函数--在类的成员函数前面加上virtual关键字，这个函数就被称为虚函数。虚函数的重写--在子类中定义了一个与父类中虚函数完全相同的函数，则称子类的这个函数重写（覆盖）了这个函数。多态--当我们使用基类的指针或引用调用上面所说的虚函数时，调用的是基类中的虚函数；当使用子类的指针或引用时调用的是子类的虚函数。形成多态的条件--必须是父类的指针或引用；调用的函数必须是虚函数...
C++对象模型详解
02-20
对于各种支持的底层实现机制语言中直接支持面向对象程序设计的部分，如构造函数、析构函数、虚函数、继承（单继承、多继承、虚继承）、多态等等，这也是组里其他同学之前分享过的内容。第一部分这里我简单过一下，...
深度探索C++对象模型
12-07
再者，C++的对象模型中还包括了封装、继承和多态这三个面向对象编程的核心特性。封装确保数据的安全性，通过访问控制（public, protected, private）来限制对对象内部状态的直接访问。继承允许类间共享代码，创建...
C++对象模型探究(基础版)
03-12
在C++编程中，理解对象模型至关重要，因为它揭示了程序在内存中的布局方式。本文将基于对String类的重写，探讨C++的内存模型，包括不同类型的变量和函数的存储区域，以及对象的创建和生命周期。 首先，我们关注的是...
初始C++
最新发布
2302_81016149的博客
07-08 642
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
c++习题08-计算星期几
码到成龚的博客
07-03 589
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
关键路径——C语言（理论）
2302_80790488的博客
06-28 856
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 909
Android 开发中 C++ 和Java 日志调试方法小结
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 210
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
面向对象中多态是什么
07-28
在面向对象的语境下，多态是通过将数据模型封装为类对象，并且对象之间存在继承关系，一个基类可以有不同的派生类，不同的派生类有各自不同的行为。多态的实现需要满足两个前提条件：存在继承或者实现关系，并且方法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值