【C++】继承

放牛的守护神_

已于 2024-05-17 22:48:02 修改

阅读量795

点赞数 21

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-05-17 21:51:56 首次发布

本文链接：https://blog.csdn.net/Atcxr/article/details/139010993

版权

C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

继承：基于一个已有的类创建新类，使新类与已有的类具有同样的功能，即新类具有已有类相同的数据成员和成员函数。

继承是代码重用的基本工具。

已有类称为基类（父类 / 超类），新类称为派生类（子类）

注意：

基类的构造函数和析构函数不能继承

基类的友元函数不能继承

静态数据成员和静态成员函数不能继承

1.继承方式

C++的继承可以分为公有继承、保护继承和私有继承。

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

语法格式：

class 派生类名：继承方式 基类名{
派生类成员声明与定义
}；

从基类成员权限的角度看这个表，总结的是内部和子类以及外部和友元是否能访问这些成员

从外部访问派生类的角度看派生类继承下来的成员的权限

上面两张表解释了成员限定符的权限和继承以后根据成员限定符外部访问派生类的权限

基类的成员权限和派生类的继承方式共同决定了派生类的基类成员权限

不管是什么继承，继承过来的private，派生类中得使用基类的方法访问。

1.1公有继承

使用公有继承，基类的公有成员将成为派生类（子类）的公有成员；基类的私有部分将成为派生类的一部分，但只能通过基类的公有和保护方法访问。在这种继承中，基类成员的访问权限在派生类中保持不变。

总结：公有继承，在派生类中，各成员对外部开放的访问权限不变，维持基类的权限。

公有继承下：

在基类中是public的，在派生类中能够去访问（根据基类成员权限角度判断），子类中依然为public（从外部访问派生类的角度看），并且外部也能够访问子类；

在基类中protected的，在派生类中能够去访问（根据基类成员权限角度判断），子类中依然为protected（从外部访问派生类的角度看），外部不能去访问；

在基类中private的，在派生类中不能够去访问，子类中依然为private，外部更访问不到，得使用基类成员函数；

#include <iostream>
using namespace std;
class Base{
private:
    int m_a;
protected:
    int m_b;
public:
    int m_c;
    Base(int a=1, int b=2, int c=3){
        m_a = a;
        m_b = b;
        m_c = c;
    }
    int geta(){
        return m_a;
       }
};

class Derived: public Base{//公有继承
public:
    void print(){
//基类的private派生类访问的话，需要使用基类的成员方法进行访问
      //cout << m_a << endl;// error
        cout << geta() << endl;
        cout << m_b << endl;//protected 可以在派生类中访问
        cout << m_c << endl;public 可以在派生类中访问
    }
};
int main(void){
    Derived test;
    //连派生类访问都需要用基类的成员方法，外部更访问不到了
    //cout << test.m_a << endl; // error private
    //公有继承这里在派生类中也成为protect了，只能在子类和内部访问
    //cout << test.m_b << endl; // error protected
    cout << test.m_c << endl;
    return 0;
}

1.2保护继承

总结：保护继承，在派生类中，public降为protected，protect和private维持基类的权限。

保护继承下：

在基类中是public的，在派生类中能够去访问（根据基类成员权限角度判断），但是，派生类中变为protected（从外部访问派生类的角度看），外部不能去访问；

在基类中protected的，在派生类中能够去访问（根据基类成员权限角度判断），派生类中依然为protected（从外部访问派生类的角度看），外部不能去访问；

在基类中private的，在派生类中不能够去访问，派生类中依然为private，外部更访问不到，得使用基类成员函数；

#include <iostream>
using namespace std;
class Base{
private:
    int m_a;
protected:
    int m_b;
public:
    int m_c;
    Base(int a=1, int b=2, int c=3){
        m_a = a;
        m_b = b;
        m_c = c;
       }
    int geta(){
        return m_a;
    }
};
class Derived: protected Base{
public:
    void print(){
//基类的private派生类访问的话，需要使用基类的成员方法进行访问
        //cout << m_a << endl; //error
        cout << geta() << endl;
        cout << m_b << endl;
        cout << m_c << endl;
}
};
int main(void){
    Derived test;
    //cout << test.m_a << endl; // error private
    //cout << test.m_b << endl; // error protected
    cout << test.m_c << endl; //error protected继承 子类中该变量为protected
    return 0;
}

1.3私有继承

总结：私有继承，在派生类中，public和protected都降为private，这个private是子类的private，意思是使用派生类的成员函数可以访问，但是基类是private的派生类的函数还是访问不到，必须得使用基类的函数；

保护继承下：

在基类中是public的，在派生类中能够去访问（根据基类成员权限角度判断），但是，派生类中变为private（从外部访问派生类的角度看），外部不能去访问；

在基类中protected的，在派生类中能够去访问（根据基类成员权限角度判断），但是，派生类中变为private（从外部访问派生类的角度看），外部不能去访问；

在基类中private的，在派生类中不能够去访问，派生类中依然为private，外部更访问不到，得使用基类成员函数；

#include <iostream>
using namespace std;
class Base{
private:
    int m_a;
protected:
    int m_b;
public:
    int m_c;
    Base(int a=1, int b=2, int c=3){
        m_a = a;
        m_b = b;
        m_c = c;
    }
    int geta(){
        return m_a;
    }
};
class Derived: private Base{
public:
    void print(){
//基类的private派生类访问的话，需要使用基类的成员方法进行访问
        //cout << m_a << endl; //error 
        cout << geta() << endl;
        cout << m_b << endl;//降为派生类自己的private 自己的成员函数可以访问，外部不能
        cout << m_c << endl;//降为派生类自己的private 自己的成员函数可以访问，外部不能
    }
};
int main(void){
    Derived test;
    //cout << test.m_a << endl; // error private
    //cout << test.m_b << endl; //error private继承 派生类中该变量为private
    //cout << test.m_c << endl; //error private继承 派生类中该变量为private
    return 0;
}

2.总结

注意：无论哪种继承，派生类中是不可以访问基类的private的，只能使用基类的成员方法对其进行访问；

继承的权限取决于继承方式的不同，主要有三种继承方式：

公有继承（public inheritance）：

从外部访问派生类的角度看

基类的公有成员在派生类中仍然是公有的；
基类的保护成员在派生类中仍然是保护的；
基类的私有成员在派生类中不可访问。

保护继承（protected inheritance）：

从外部访问派生类的角度看

基类的公有成员在派生类中被视为保护成员；
基类的保护成员在派生类中仍然是保护的；
基类的私有成员在派生类中不可访问。

私有继承（private inheritance）：

从外部访问派生类的角度看

基类的公有成员在派生类中被视为私有成员；
基类的保护成员在派生类中被视为私有成员；
基类的私有成员在派生类中不可访问。

#include <iostream>

class Base {
public:
    int publicMember;
protected:
    int protectedMember;
private:
    int privateMember;
};

// 公有继承
class PublicDerived : public Base {
    // publicMember 在 PublicDerived 中仍然是公有的
    // protectedMember 在 PublicDerived 中仍然是保护的
    // privateMember 在 PublicDerived 中不可访问
};

// 保护继承
class ProtectedDerived : protected Base {
    // publicMember 在 ProtectedDerived 中被视为保护的
    // protectedMember 在 ProtectedDerived 中仍然是保护的
    // privateMember 在 ProtectedDerived 中不可访问
};

// 私有继承
class PrivateDerived : private Base {
    // publicMember 在 PrivateDerived 中被视为私有的
    // protectedMember 在 PrivateDerived 中被视为私有的
    // privateMember 在 PrivateDerived 中不可访问
};

int main() {
    PublicDerived pubDerived;
    pubDerived.publicMember = 10;  // 合法
    // pubDerived.protectedMember = 20;  // 非法
    // pubDerived.privateMember = 30;  // 非法

    ProtectedDerived protDerived;
    // protDerived.publicMember = 10;  // 非法
    // protDerived.protectedMember = 20;  // 非法
    // protDerived.privateMember = 30;  // 非法

    PrivateDerived privDerived;
    // privDerived.publicMember = 10;  // 非法
    // privDerived.protectedMember = 20;  // 非法
    // privDerived.privateMember = 30;  // 非法

    return 0;
}