【c++】 继承与多态

🏆 个人主页：🎈 @太阳哥哥 🎈

🎁 本文收录专栏：🎈C++学习之路 🎈

🛒 其他专栏：🎈 ARM学习之路 🎈

📝 学习格言：路漫漫其修远兮，吾将上下而求索

💡 欢迎点赞、关注、收藏( •̀ ω •́ )✧   一起努力，一起学习！

目录

继承与多态

1、继承

2、继承权限

3、多继承

4、多态

4.1、虚函数

4.2、 静态绑定

4.3、动态绑定

---

继承与多态

1、继承

        一个类的对象共享了另一个类或其他多个类的成员变量和成员方法，例如：儿子继承父亲（儿子具备父亲的特征和行为），该类和另一个类或其他类的关系，称之为“继承”，C++继承又分为单继承和多继承。

• 单继承：  一个类的对象共享了另一个类的成员变量和成员方法

• 多继承： ​ 一个类的对象共享了其他多个类的成员变量和成员方法

        单继承的格式：

//class  新的类名（子类）  ：  继承的权限   已经存在的类（父类）
    {
        //类体
    }；

        新的类我们称之为子类（派生类），已经存在的类我们称之为父类（基类） ​ 继承的权限：public、private、protected

        示例程序：

#include<iostream>
using namespace std;

class Father
{
public:
    int a = 50;
    void function()
    {
        cout << "这是父类的成员函数" << endl;
    }
};
class  Son : public Father //表示Son类继承自Father
{
public:
    void son_func()
    {
        cout << "a=" << a << endl;
    }
};
int main()
{
    Son zhangsan;
    zhangsan.son_func();
    zhangsan.function();
    return 0;
}

        父类和子类的构造和析构函数的调用时机，先调用父类的构造函数，再调用子类的构造函数，析构时，先调用子类的析构函数，再调用父类的析构函数。

#include <iostream>
#include <string>
using namespace std;
​
class Father 
{
public:
    Father() 
    {
        cout << "Father" << endl;
    }
};
​
class Son :public Father 
{
public:
    Son() 
    {
        cout << "Son" << endl;
    }
};
​
int main()
{
    int a;
    cout << "请输入循环多少次：" << endl;
    cin >> a;
​
    for (int i = 0; i < a; i++) 
    {
        Father father;
        Son son;
    }
​
}

执行程序的结果：   Father

                                Father

                                Son

                                Father

                                Father

                                Son

2、继承权限

子类继承父类属性：

• 子类调用父类成员时，可以在类外调用父类public内成员。子类public、protected、private继承父类public成员属性。
• 子类protected、private继承父类protected内成员属性。
• 子类没有继承父类的private内成员属性。

        注：继承方式一般选用public继承。

3、多继承

        多继承：一个派生类有两个或多个基类。

        声明格式：

//class 派生类（子类） ：继承权限 父类1，继承权限 父类2
{
    //代码块
}
​

        示例程序：

#include<iostream>
using namespace std;
​
class father1
{
public:
    int a = 10;
};
class father2
{
public:
    int b = 20;
};
class son :public father1, public father2
{
public:
    void show()
    {
        cout << a << endl;
        cout << b << endl;
    }
};
int main()
{
    son son1;
    son1.show();
}

​

4、多态

        多态：一种接口（一般指父类接口），多种方法（一般指子类中多种相同方法）。

构成多态性:

• 两个类具有继承关系
• 子类中必须重写父类的方法（子类方法中的内容与父类中的方法可以不一样)
• 父类中的方法必须是虚函数

4.1、虚函数

        虚函数相当于是一个普通的成员函数，只不过在该函数前加了一个关键字“vitual”，那就表明该函数是一个虚函数。

        声明格式: virtual 返回值类型 函数名 (参数列表) ；

        定义格式: virtual 返回值类型  函数名 (参数列表）；

        {

                /函数体

        }

    virtual void func()//虚函数，关键字 virtual
    {
        cout << "father" << endl;
    }

多态性的调用时机

        当父类的指针或者是引用指向子类时，具有继承关系的两个类，是支持父类和子类相关联(父类的指针或者是引用指向子类)。

4.2、 静态绑定

        函数的定义和调用在编译阶段就确定了，称之为静态绑定。

        静态绑定的时候是根据类的指针对象或者是引用的类型来确定函数的调用，而不是通过类的指针或者是引用指向的对象的类型来确定。

        程序示例：

#include <iostream>
#include <string>
using namespace std;
​
class father 
{
public:
    
    void func()
    {
        cout << "father" << endl;
    }
};
​
class son :public father
{
public:
    void func()
    {
        cout << "son" << endl;
    }
};
​
int main()
{
    father* father1;
    son son1;
    father1 = &son1;
    father1->func();//此时调用的是父类的 func()函数
​
    return 0;
}

        执行程序结果：father

4.3、动态绑定

        函数的定义和调用在运行阶段才确定，称之为动态绑定。

        加上关键字 virtual构成虚函数，此时调用的是子类的 fanc()函数。

#include <iostream>
#include <string>
using namespace std;
​
class father 
{
public:
    
    virtual void func()//虚函数，关键字 virtual
    {
        cout << "father" << endl;
    }
};
​
class son :public father
{
public:
    virtual void func()//虚函数，关键字 virtual
    {
        cout << "son" << endl;
    }
};
​
int main()
{
    father* father1;
    son son1;
    father1 = &son1;
    father1->func();//此时调用的是子类的 func()函数
​
    return 0;
}

        执行程序结果：son