三种继承、多态-虚函数

最新推荐文章于 2024-07-26 22:51:51 发布

吕白_

最新推荐文章于 2024-07-26 22:51:51 发布

阅读量749

点赞数

分类专栏： c++

本文链接：https://blog.csdn.net/weixin_36888577/article/details/78575530

版权

c++ 专栏收录该内容

27 篇文章 32 订阅

订阅专栏

总结一下最近学到的类继承的知识，包括三种继承方式、多态的实现、动态联编和静态联编。
欢迎各位指正其中的错误。
以后的理解更加深刻了回来更新和修改。

三种继承

从一个类，派生出另一个类时，原始类称为基类（父类），继承类称为派生类（子类）

派生类对象存储了基类的数据成员，且可以使用基类的方法，但不能直接访问基类的私有成员，必须使用基类的公有方法进行访问。可以根据需要添加额外的成员

因为构造函数不能继承，那么派生类在创建对象时先使用基类的构造函数初始化继承的基类的数据成员，再使用自己的构造函数（类的构造函数可以为空，但必须存在 ）

例如：

#include<iostream>
using namespace std;
class A
{
    int x;
    public:
    A( int xx )
    {
        x = xx;
    }
    void show()
    {
         cout << " A : " << x << endl;
    }
};
class B:public A
{
    int y;
    public:
    B( int yy,int xx) : A( xx ) //成员初始化列表机制
    {
        y = yy;
    }
    void show()
    {
        A::show();
        cout << " B : " << y << endl; 
    }
};
int main()
{
    B b( 3,2 );
    b.show();
    return 0;
}

输出结果为
A : 2 B : 3
这里我在父类A里定义的构造函数只有一个有参类型，所以调用时要显示调用。即如果父类有显示声明了构造函数，那么子类最低限度实现父类的一个构造函数，如果子类没有定义构造函数，则调用父类无参数的构造方法

派生类构造函数的要点：
1.首先创建基类对象
2.派生类构造函数应通过成员初始化列表将信息传递给基类构造函数
3.派生类构造函数应初始化派生类新增的数据成员

公有继承方式

(1) 基类成员对派生类的可见性：
公有成员和保护成员可见，而私有成员不可见。这里保护成员同于公有成员。

(2) 基类成员对派生类对象的可见性：
公有成员可见，其他成员不可见。

所以，在公有继承时，派生类的对象可以访问基类中的公有成员；派生类的成员函数可以访问基类中的公有成员和保护成员。这里，一定要区分清楚派生类的对象和派生类中的成员函数对基类的访问是不同的。

私有继承方式

(1) 基类成员对派生类的可见性：
公有成员和保护成员是可见的，而私有成员是不可见的。

(2) 基类成员对派生类对象的可见性：
所有成员都是不可见的。

所以，在私有继承时，基类的成员只能由直接派生类访问，而无法再往下继承。

保护继承方式

这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言，对基类成员有不同的可见性。
上述所说的可见性也就是可访问性。

关于可访问性还有另的一种说法。这种规则中，称派生类的对象对基类访问为水平访问，称派生类的派生类对基类的访问为垂直访问。

综上所述：

公有继承：
对派生类成员共有和保护成员可访问，对对象只有公有成员可访问

私有继承：
对派生类成员公有和保护成员可访问，对对象所有成员都不可访问

保护继承：
保护继承时基类中各成员属性均变为protected，并且基类中private成员被隐藏。派生类成员只能访问基类的公有和保护成员，对派生类对象所有成员均不可访问

多态的实现

多态，接口的多种不同的实现方式即为多态

多态存在的三个条件：
1.必须存在继承关系；
2.继承关系中必须有同名的虚函数，并且它们是覆盖关系（重载不行）。
3.存在基类的指针，通过该指针调用虚函数。

多态通过虚函数实现，引入新关键字virtual
在函数声明前加入virtual，即将其变为虚函数

#include<iostream>
using namespace std;
class A
{
    int x;
    public:
    A( int xx )
    {
        x = xx;
    }
    virtual void show()
    {
         cout << " A : " << x << endl;
    }
};
class B:public A
{
    int y;
    public:
    B( int yy,int xx) : A( xx )
    {
        y = yy;
    }
    void show()
    {
        cout << " B : " << y << endl; 
    }
};
int main()
{
    A *b = new B( 3,2 );
    b->show();
    return 0;
}

这里将上述例子里的show函数声明为虚函数，输出结果为B ：3

这里如果show不是虚函数，那么b->show()将执行父类的函数，因为b是一个A类型的指针

也就是说，多态也就是通过父类指针来指向子类对象实现不同的操作，父类就像ATM机，插入不同的卡（子类）要取钱时，ATM机不需要为每一张卡写不同的函数，只需要用ATM机（父类）指针指向卡（子类）去完成相对应的操作

方法在父类中被声明为虚的后，在子类中自动成为虚方法

-LZJ：父类指针为什么能指向子类指针？
这两个不是类型不一样么，为什么父类指针还能指向子类呢。（子类指针不能指向父类）
其实，不止是指针，C++允许基类引用指任何从该基类派生而来的任何类型
类型一致其实不是说一定要类型完全一样，类型是一种约束，帮助你验证程序的正确性，类的继承就是表示一种 “继承类是基类中更具体的东西”，子类和父类的关系并不是两个独立的类型，但无法使用不存在于基类只存在于派生类的元素（所以我们需要虚函数、纯虚函数）

例如

#include<iostream>
using namespace std;
class A
{
    int x;
    public:
    A( int xx )
    {
        x = xx;
    }
    void q()
    {

    }
};
class B:public A
{
    int y;
    public:
    B( int yy,int xx) : A( xx )
    {
        y = yy;
    }
    void w()
    {

    }
};
int main()
{
    A *b = new B( 3,2 );
    b->show();
    b->q();   //ok
    b->w();   //error
    return 0;
}

动态联编、静态联编

程序调用函数时，将使用哪个可执行代码块呢？编译器负责回答你。将源代码中的函数调用解释为执行特定的函数代码块称为函数名联编。
在编译过程中完成这种联编被称为静态联编，又称为早期联编，那虚函数的出现让编译器无法在编译过程确定使用哪一个函数，所以编译器可以在执行过程中选择正确的虚方法的代码，这被称为动态联编，也被称为晚期联编。