（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite

原创

喜欢打篮球的普通人 2023-03-09 09:23:37 博主文章分类：C++ and mysql ©著作权

文章标签 c++ c语言 mfc 派生类虚函数 文章分类 Html/CSS 前端开发

©著作权归作者所有：来自51CTO博客作者喜欢打篮球的普通人的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

1.多态
2.静态绑定与动态绑定
3.虚函数
4.虚表指针
5.object slicing与虚函数
6.overload、override、overwrite
7.通过引用实现多态

1.多态

多态性是面向对象程序设计的重要特征之一
多态性是指发出同样的消息被不同类型的对象接收时，有可能导致完全不同的行为
（1）调用同名的函数导致不同的行为
（2）以一致的观点来看待，从同一个基类派生下来的所有派生类对象，减轻了我们分别设计的负担
多态的实现：
（1）函数重载：调用同名的函数，静态绑定
（2）运算符重载，静态绑定
（3）模板，静态绑定
（4）虚函数：虚函数是动态绑定的

2.静态绑定与动态绑定

静态绑定
绑定过程出现在编译阶段，在编译期就已经确定要调用的函数；
动态绑定
绑定过程工作在程序运行时执行，在程序运行时才确定将要调用的函数；
动态绑定是通过虚函数来实现的；

3.虚函数

虚函数的概念：在基类中冠以关键字virtual的成员函数
虚函数的定义：
如果一个函数在基类中被声明为虚函数，则他在所有派生类中都是虚函数

virtual 函数类型 函数名称(参数列表)

只有通过基类指针或者引用调用虚函数才能引发动态绑定
虚函数不能声明为静态的，也不能是友元函数，只能是成员函数
因为静态函数没有this指针，因为静态函数是类共享的，就不是对象的一部分，就没有办法逐对象的头4个字节vptr虚表指针，进而也没办法找到虚表，所以静态函数不能声明为虚的
eg：P34\01.cpp

//演示动态绑定的语法的eg
#include <iostream>
using namespace std;

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

    virtual void Fun2()
    {
        cout<<"Base::Fun2 ..."<<endl;
    }
    void Fun3()
    {
        cout<<"Base::Fun3 ..."<<endl;
    }
};

class Derived : public Base
{
public:
    //void Fun1()没有virtual关键字，Fun1也是虚函数，Fun2类似
    virtual void Fun1()
    {
        cout<<"Derived::Fun1 ..."<<endl;
    }
    virtual void Fun2()
    {
        cout<<"Derived::Fun2 ..."<<endl;
    }
    void Fun3()
    {
        cout<<"Derived::Fun3 ..."<<endl;
    }
};

int main(void)
{
    //基类指针指向派生类对象
    Base* p;
    Derived d;

    p = &d;
    //调用的是基类的Fun1还是派生类的Fun1是在运行期时决定的
    p->Fun1();//Fun1是虚函数，基类的指针指向派生类对象，调用的是派生类对象的虚函数
    p->Fun2();
    p->Fun3();//Fun3是非虚函数，根据p指针实际类型来调用相应类的成员函数

    return 0;
}

测试：
基类指针指向派生类对象，调用的是虚函数时，调用实际所指向的虚函数；
如果是普通的函数，会依据指针类型来确定调用的函数；

（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite_虚函数

eg：P34\02.cpp

#include <iostream>
using namespace std;

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

    virtual void Fun2()
    {
        cout<<"Base::Fun2 ..."<<endl;
    }
    void Fun3()
    {
        cout<<"Base::Fun3 ..."<<endl;
    }

    Base()
    {
        cout<<"Base ..."<<endl;
    }

    ~Base()
    {
        cout<<"~Base ..."<<endl;
    }
};

class Derived : public Base
{
public:
    //void Fun1()没有virtual关键字，Fun1也是虚函数，Fun2类似
    /*virtual*/ void Fun1()
    {
        cout<<"Derived::Fun1 ..."<<endl;
    }
    /*virtual*/ void Fun2()
    {
        cout<<"Derived::Fun2 ..."<<endl;
    }
    void Fun3()
    {
        cout<<"Derived::Fun3 ..."<<endl;
    }
    Derived()
    {
        cout<<"Derived ..."<<endl;
    }
    ~Derived()
    {
        cout<<"~Derived ..."<<endl;
    }
};

int main(void)
{
    //基类指针指向派生类对象
    Base* p;
    p = new Derived;//先构造基类，再构造派生类

    p->Fun1();

    //这里派生类的析构函数不会调用，是因为它认为释放的类型是Base*类型，所以只会调用基类的析构函数，因为析构函数不是虚的；
    //若析构函数是虚的，它认为p所指向的类型是派生类，也就是说p是一个派生类的对象，派生类的释放会先调用基类的析构函数，再调用派生类的析构函数；
    delete p;


    return 0;
}

测试：
析构函数也可以虚的eg
这里派生类的析构函数不会调用，是因为它认为释放的类型是Base*类型，所以只会调用基类的析构函数，因为析构函数不是虚的；
若析构函数是虚的，它认为p所指向的类型是派生类，也就是说p是一个派生类的对象，派生类的释放会先调用基类的析构函数，再调用派生类的析构函数；

（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite_c++_02

何时需要虚析构函数？
当你可能通过基类指针删除派生类对象时，如果没有将基类的析构函数定义为虚析构函数，那么它只会调用基类的析构函数，而不会调用派生类的析构函数，这样就有可能存在内存泄漏的风险
如果你打算允许其他人通过基类指针调用对象的析构函数（通过delete这样做是正常的），并且被析构的对象是有重要的析构函数的派生类的对象，就需要让基类的析构函数作为虚函数。
P34\02.cpp

#include <iostream>
using namespace std;

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

    virtual void Fun2()
    {
        cout<<"Base::Fun2 ..."<<endl;
    }
    void Fun3()
    {
        cout<<"Base::Fun3 ..."<<endl;
    }

    Base()
    {
        cout<<"Base ..."<<endl;
    }

    //什么时候用到虚析构函数？
    //如果一个类要做为多态基类，要将析构函数定义为虚函数，防止内存泄漏
    virtual ~Base()
    {
        cout<<"~Base ..."<<endl;
    }
};

class Derived : public Base
{
public:
    //void Fun1()没有virtual关键字，Fun1也是虚函数，Fun2类似
    /*virtual*/ void Fun1()
    {
        cout<<"Derived::Fun1 ..."<<endl;
    }
    /*virtual*/ void Fun2()
    {
        cout<<"Derived::Fun2 ..."<<endl;
    }
    void Fun3()
    {
        cout<<"Derived::Fun3 ..."<<endl;
    }
    Derived()
    {
        cout<<"Derived ..."<<endl;
    }
    //基类的析构函数是虚函数，派生类的自然也变成虚的
    ~Derived()
    {
        cout<<"~Derived ..."<<endl;
    }
};

int main(void)
{
    //基类指针指向派生类对象
    Base* p;
    p = new Derived;//先构造基类，再构造派生类

    p->Fun1();
    delete p;

    return 0;
}

测试：

4.虚表指针

虚函数的动态绑定是通过虚表来实现的
包含虚函数的类的头4个字节存放指向虚表的指针，即：虚表指针指向虚表
eg：P34\03.cpp

#include <iostream>
using namespace std;

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

    virtual void Fun2()
    {
        cout<<"Base::Fun2 ..."<<endl;
    }

    int data1_;
};

//派生类有3个虚函数
class Derived : public Base
{
    //会覆盖基类的虚函数Fun2()
    void Fun2()
    {
        cout<<"Derived::Fun2 ..."<<endl;
    }
    virtual void Fun3()
    {
        cout<<"Derived::Fun3 ..."<<endl;
    }
    int data2_;
};

//使用typedef来定义一个类型
typedef void (*FUNC)();
int main(void)
{
    cout<<sizeof(Base)<<endl;
    cout<<sizeof(Derived)<<endl;
    Base b;
    long** p = (long**)&b;//p[0][0]指向基类的虚函数Base::Func1
    FUNC fun = (FUNC)p[0][0];//将p[0][0]指针强制转换为func，强制转换为函数指针类型
    fun();//会调用到基类的虚函数

    Derived d;
    p = (long**)&d;
    fun = (FUNC)p[0][0];
    fun();
    fun = (FUNC)p[0][1];
    fun();
    fun = (FUNC)p[0][2];
    fun();

    //只有通过基类指针或者基类引用，才有动态绑定
    //基类指针pp指向派生类对象，会取出对象d的头4个字节，指向虚表，然后从虚表中找到对应的Func2，实施动态绑定
    //调用Func2进行偏移，偏移到Derived::Fun2,而不是Base::Fun2,结合派生类内存图去看
    //pp虽然是基类指针类型，但是调用的是派生类的虚函数
    Base* pp = &d;
    pp->Fun2();//Func2是虚函数，运行时期才会去确定Func2的入口地址

    //虚函数可以直接使用，但不是动态绑定，入口地址在编译期就决定了
    //直接调用是静态绑定
    d.fun2();

    return 0;
}

分析
（1）虚表与虚基类表不一样，虚基类表再虚继承的时候会产生
基类与派生类的内存模型
（2）基类大小为什么是8？因为头四个字节存放的是虚表指针(指向虚表的指针)，4个字节，所以4（基类只有一个数据成员）+4=8
（3）基类的内存模型，如下：
Base类中第一个位置存放的是指针，所以地址是指针的指针，存放的是指针，该指针指向了一张表格；
虚表vtbl中存放的是函数指针；
虚表里面有2个虚函数

（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite_c++_03

（4）派生类的内存模型，如下：
虚表里面有3个虚函数

（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite_派生类_04

测试，验证如下：

（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite_派生类_05

5.object slicing与虚函数

object slicing，对象切割，在向上转型的过程中存在对象切割的问题，即派生类特有的成员消失了
eg：P34\04.cpp

#include <iostream>
using namespace std;

class CObject
{
public:
    virtual void Serialize()
    {
        cout<<"CObject::Serialize ..."<<endl;
    }
};

class CDocument : public CObject
{
public:
    int data1_;
    void func()
    {
        cout<<"CDocument::func ..."<<endl;
        Serialize();
    }
    //覆盖基类的虚函数
    virtual void Serialize()
    {
        cout<<"CDocument::Serialize ..."<<endl;
    }

    //因为要调用派生类CMyDoc的默认构造函数，也要调用基类CDocument的默认构造函数，所以这里需要定义下
    //因为CMyDoc类中构造函数初始化列表中并没有给出构造函数，也就没有给出基类的构造，所以需要定义基类的默认构造函数
    CDocument()
    {
        cout<<"CDocument"<<endl;
    }

    CDocument(const CDocument& other)
    {
        cout<<"CDocument(const CDocument& other)"<<endl;
    }
};

//继承func，覆盖CDocument类的Serialize
class CMyDoc : public CDocument
{
public:
    int data2_;
    //派生类对象覆盖了上面的基类虚函数
    virtual void Serialize()
    {
        cout<<"CMyDoc::Serialize ..."<<endl;
    }
};

int main()
{
    //都是最底层的派生类对象
    CMyDoc mydoc;
    CMyDoc* pmydoc = new CmyDoc;//定义一个对象，指向派生类对象

    cout<<"#1 testing"<<endl;
    mydoc.func();//从实际对象的虚表去查找，找到派生类对应的虚函数

    cout<<"#2 testing"<<endl;
    ((CDocument*)(&mydoc))->func();//((CDocument*)(&mydoc))相当于基类指针指向派生类对象
                                //由于CMyDoc没有重定义func，所以会调用CDocument中的func
                                //实际指向的对象是mydoc，所以会调用CMyDoc中的Serialize

    cout<<"#3 testing"<<endl;
    pmydoc->func();

    cout<<"#4 testing"<<endl;
    ((CDocument)mydoc).func();//mydoc对象强制转化为CDocument对象，向上转型
                            //完完全全将派生类对象转化为基类对象，包括虚表都已经发生了改变，都是CDocument虚表了
                            //向上转型会调用构造函数，这里调用拷贝构造函数，将派生类mydoc对象拷贝构造为CDocument类对象，若没写，所以会
                            //调用默认的拷贝构造函数

    return 0;
}

该eg源自MFC框架

（P34）虚函数与多态：多态，静态绑定与动态绑定，虚函数，虚表指针，object slicing与虚函数，overload，override，overwrite_c++_06

测试：

6.overload、override、overwrite

成员函数被重载overload的特征
（1）相同的范围（在同一个类中）
（2）函数名字相同
（3）参数不同
（4）virtual关键字可有可无
override覆盖是指派生类函数覆盖基类函数，特征是
（1）不同的范围（分别位于派生类与基类）
（2）函数名字相同
（3）参数相同，返回值相同，完全相同
（4）基类函数必须有virtual关键字
overwrite重定义(派生类与基类)
（1）不同的范围（分别位于派生类与基类）
（2）函数名与参数都相同，无virtual关键字
（3）函数名相同，参数不同，virtual可有可无

7.通过引用实现多态

eg：

#include <iostream>

#include <cstdio>

class Object {

    std::string type_name;

protected:

    explicit Object(std::string const& type_name) : type_name(type_name) {};

public:

    Object() : type_name("Object") {};

    Object(Object const& other) : type_name(other.type_name) {};

    virtual void print() { std::cout << type_name; };

    virtual ~Object() {};

};

class Door : public Object {

    std::string handle;

public:

    Door() : Object("Door"), handle("normal") {}

    explicit Door(std::string const& handle) : Object("Door"), handle(handle) {}

    Door(Door const& other) : Object(other.handle), handle(other.handle) {}

    virtual void print() { Object::print(); std::cout << " " << handle << std::endl; }

    virtual ~Door() {}

};



class Book : public Object {

    std::string title;

    std::string author;

public:

    Book() : Object("Book"), title(), author() {}

    Book(std::string author, std::string title) : Object("Book"), author(author), title(title) {}

    Book(Book const& other) : Object(other.title), title(other.title), author(other.author) {}

    virtual void print() { Object::print(); std::cout << " " << title << " by " << author << std::endl; }

    virtual ~Book() {}

};



void print(Object& object) {

    object.print();

}



int main(int argc, const char* argv[])

{

    Object object;

    Door door("simple");

    Book book("program", "C++");

    print(object);

    std::cout << std::endl;

    print(door);

    print(book);

    system("pause");

}

测试：

说明：

int & r = i;
在背后的实现可能为

底层引用其实是根据指针const 来塑模
int * const ptr = &i;

参考：通过引用实现C++多态

上一篇：（P38）类与类之间的5种关系：UML ，继承（泛化），关联，聚合，组合，依赖，总结

下一篇：（P25）运算符重载：类型转换运算符，-＞运算符，operator new、operator delete，new运算符的3种用法

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯