C++ 三种继承方式

喜欢ヅ旅行 2023-07-14 10:44 12阅读 0赞

C++继承的一般语法为：

class 派生类名:［继承方式］ 基类名{ 
        派生类新增加的成员
    };

继承方式限定了基类成员在派生类中的访问权限，包括 public（公有的）、private（私有的）和 protected（受保护的）。此项是可选项，如果不写，默认为 private（成员变量和成员函数默认也是 private）。

现在我们知道，public、protected、private 三个关键字除了可以修饰类的成员，还可以指定继承方式。  
public、protected、private 修饰类的成员  
类成员的访问权限由高到低依次为 public --> protected --> private，public 成员可以通过对象来访问，private 成员不能通过对象访问。

protected 成员和 private 成员类似，也不能通过对象访问。但是当存在继承关系时，protected 和 private 就不一样了：基类中的 protected 成员可以在派生类中使用，而基类中的 private 成员不能在派生类中使用。

### public、protected、private 指定继承方式 ###

不同的继承方式会影响基类成员在派生类中的访问权限。

**1 public继承方式**

基类中所有 public 成员在派生类中为 public 属性；
    	
    	基类中所有 protected 成员在派生类中为 protected 属性；
    	
    	基类中所有 private 成员在派生类中不能使用。

**2 protected继承方式**

基类中的所有 public 成员在派生类中为 protected 属性；
    	
    	基类中的所有 protected 成员在派生类中为 protected 属性；
    	
    	基类中的所有 private 成员在派生类中不能使用。

**3 private继承方式**

基类中的所有 public 成员在派生类中均为 private 属性；
    	
    	基类中的所有 protected 成员在派生类中均为 private 属性；
    	
    	基类中的所有 private 成员在派生类中不能使用。

通过上面的分析可以发现：  
1 基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。

也就是说，**继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。**

2 不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。

3 如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为 public 或 protected；只有那些不希望在派生类中使用的成员才声明为 private。

4 如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。

注意：我们这里说的是基类的 private 成员不能在派生类中使用，并没有说基类的 private 成员不能被继承。实际上，基类的 private 成员是能够被继承的，并且（成员变量）会占用派生类对象的内存，它只是在派生类中不可见，导致无法使用罢了。private 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。

下表展示了不同继承方式对不同属性的成员的影响结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc0Mzc5OQ_size_16_color_FFFFFF_t_70]

由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public。

类的继承关系。

#include<iostream>
    using namespace std;
    
    //基类People
    class People{ 
    public:
        void setname(char *name);
        void setage(int age);
        void sethobby(char *hobby);
        char *gethobby();
    protected:
        char *m_name;
        int m_age;
    private:
        char *m_hobby;
    };
    void People::setname(char *name){  m_name = name; }
    void People::setage(int age){  m_age = age; }
    void People::sethobby(char *hobby){  m_hobby = hobby; }
    char *People::gethobby(){  return m_hobby; }
    
    //派生类Student
    class Student: public People{ 
    public:
        void setscore(float score);
    protected:
        float m_score;
    };
    void Student::setscore(float score){  m_score = score; }
    
    //派生类Pupil
    class Pupil: public Student{ 
    public:
        void setranking(int ranking);
        void display();
    private:
        int m_ranking;
    };
    void Pupil::setranking(int ranking){  m_ranking = ranking; }
    void Pupil::display(){ 
        cout<<m_name<<"的年龄是"<<m_age<<"，考试成绩为"<<m_score<<"分，班级排名第"<<m_ranking<<"，TA喜欢"<<gethobby()<<"。"<<endl;
    }
    
    int main(){ 
        Pupil pup;
        pup.setname("小明");
        pup.setage(15);
        pup.setscore(92.5f);
        pup.setranking(4);
        pup.sethobby("乒乓球");
        pup.display();
    
        return 0;
    }

运行结果：

小明的年龄是15，考试成绩为92.5分，班级排名第4，TA喜欢乒乓球。

这是一个多级继承的例子，Student 继承自 People，Pupil 又继承自 Student，它们的继承关系为 People --> Student --> Pupil。Pupil 是最终的派生类，它拥有基类的 m\_name、m\_age、m\_score、m\_hobby 成员变量以及 setname()、setage()、sethobby()、gethobby()、setscore() 成员函数。

在派生类 Pupil 的成员函数 display() 中，我们借助基类的 public 成员函数 gethobby() 来访问基类的 private 成员变量 m\_bobby，因为 m\_hobby 是 private 属性的，在派生类中不可见，所以只能借助基类的 public 成员函数 sethobby()、gethobby() 来访问。

在派生类中访问基类 private 成员的唯一方法就是借助基类的非 private 成员函数，如果基类没有非 private 成员函数，那么该成员在派生类中将无法访问。

### 改变访问权限 ###

使用 using 关键字可以改变基类成员在派生类中的访问权限，例如将 public 改为 private、将 protected 改为 public。

注意：using 只能改变基类中 public 和 protected 成员的访问权限，不能改变 private 成员的访问权限，因为基类中 private 成员在派生类中是不可见的，根本不能使用，所以基类中的 private 成员在派生类中无论如何都不能访问。

using 关键字使用示例：

#include<iostream>
    using namespace std;
    
    //基类People
    class People { 
    public:
        void show();
    protected:
        char *m_name;
        int m_age;
    };
    void People::show() { 
        cout << m_name << "的年龄是" << m_age << endl;
    }
    
    //派生类Student
    class Student : public People { 
    public:
        void learning();
    public:
        using People::m_name;  //将protected改为public
        using People::m_age;  //将protected改为public
        float m_score;
    private:
        using People::show;  //将public改为private
    };
    void Student::learning() { 
        cout << "我是" << m_name << "，今年" << m_age << "岁，这次考了" << m_score << "分！" << endl;
    }
    
    int main() { 
        Student stu;
        stu.m_name = "小明";
        stu.m_age = 16;
        stu.m_score = 99.5f;
        stu.show();  //compile error
        stu.learning();
    
        return 0;
    }

代码中首先定义了基类 People，它包含两个 protected 属性的成员变量和一个 public 属性的成员函数。定义 Student 类时采用 public 继承方式，People 类中的成员在 Student 类中的访问权限默认是不变的。

不过，我们使用 using 改变了它们的默认访问权限，如代码第 21~25 行所示，将 show() 函数修改为 private 属性的，是降低访问权限，将 name、age 变量修改为 public 属性的，是提高访问权限。

因为 show() 函数是 private 属性的，所以代码第 36 行会报错。把该行注释掉，程序输出结果为：

我是小明，今年16岁，这次考了99.5分！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc0Mzc5OQ_size_16_color_FFFFFF_t_70]: /images/20230529/505a1796717149d8a9ec68a1ccd9059b.png