继承与多态

C++ 多态与虚函数详解

最新推荐文章于 2022-08-30 15:40:28 发布

原创最新推荐文章于 2022-08-30 15:40:28 发布 · 316 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#继承 #多态

c++ 专栏收录该内容

23 篇文章

订阅专栏

本文详细介绍了 C++ 中的多态性概念，包括虚函数的使用方法、虚函数表的工作原理以及如何通过虚函数实现多态。同时探讨了继承中的访问控制、派生类列表的定义，以及虚函数在单继承和多继承中的表现。

访问限定符

*继承访问控制的作用是将继承下来的成员在派生类域内的属性改变而和原本基类的成员访问控制符关。

所有的基类private成员在派生类里是不可见，但它确确实实被继承下来了。

基类的protected成员只对继承它的派生类可见，在类外不可使用

派生类列表

在定义派生类的时候我们必须写出派生类列表，但在声明处不可写。

1.虚函数的使用（多态的实现）

#include<iostream>
using namespace std;
class Base
{
private:
     int _base ;
public:
     Base()
            :_base (0)
     {}
     virtual void show()
     {
            cout << "Base::show()" << endl ;
     }
     //....
};
class D :public Base
{
public:
     D()
            :_d (1)
     {}
     void show()
     {
            cout << "D::show()" << endl ;
     }
 
private:
     int _d ;
};
void Print (Base *pb)
{
     pb-> show();
}
int main ()
{
     Base b;
     D d;
     Print(& b);
     Print(& d);
     getchar();
     return 0;
}

*通过传参的不同使得show函数的输出结果不同，实现的原理是：虚函数表（动态绑定）

*动态绑定：函数的运行版本由实参决定，在函数运行时才进行选择，又称运行时绑定

*规则：基类通常都需要定义一个虚析构函数，无论是否在后面用到

*成员函数如果没有被声明为虚函数并且不是静态函数，那它的解析过程发生在编译阶段而不是运行阶段

*每个类控制自己的成员初始化，不要使用派生类直接初始化基类成员

*派生类必须对它内部重新定义的虚函数进行声明

*任何除了构造函数以外的非静态函数都可以是虚函数

2.虚函数表

a.单继承

如上例中代码示，单继承时Base的对象模型如下

D的对象模型如下

b.多继承

#include<iostream>
using namespace std;
typedef void (*PTR)();
class Base
{
private:
     int _base ;
public:
     Base()
            :_base (0)
     {}
     virtual void show()
     {
            cout << "Base::show()" << endl ;
     }
     //...
};
class Base2
{
private:
     int _base2 ;
public:
     Base2()
            :_base2 (2)
     {}
     virtual void show()
     {
            cout << "Base2::show()" << endl ;
     }
     virtual void fun2()
     {
            cout << "Base2::fun2()" << endl ;
     }
     //...
};
class D :public Base,public Base2
{
public:
     D()
            :_d (1)
     {}
     void show()
     {
            cout << "D::show()" << endl ;
     }
     void fun2()
     {
            cout << "D::fun2()" << endl ;
     }
     virtual void fun3()
     {
            cout << "D::fun3()" << endl ;
     }
     virtual void fun4()
     {
            cout << "D::fun4()" << endl ;
     }
private:
     int _d ;
};
void PrintVT (int p )
     //实参是每个类存储虚函数指针的地址，解引用之后代表该类的虚函数指针
{
     PTR ptr = NULL;
     //现在让pi能访问类的虚函数指针
     int *pi = (int *)p;
     int i = 0;
     while (pi [i ])
     {
            ptr = (PTR)pi[i];
            ptr();
            i++;
     }
}
int main ()
{
     //Base b;
     //Base2 b2;
     D d;
     //PrintVT(*(int *)&b);
     //cout << "--------------------" << endl;
     //PrintVT(*(int *)&b2);
     //cout << "--------------------" << endl;
     PrintVT(*( int *)&d );
     cout << "--------------------" << endl ;
     getchar();
     return 0;
 }

如上述代码，我们发现多继承的虚函数表和单继承由很大的不同之处

在此不再赘述两个基类的虚表，我们来看派生类的对象模型