C++面向对象-17-继承

不念不忘少年蓝@ 2023-07-03 06:06 10阅读 0赞

开始学习C++面向对象的第二个特性：继承，前面学习都是类和对象，也就是封装的特点。所有的面向对象的编程语言都有封装，继承和多态这三个基本特性。继承就要了解，父类和子类的概念。意思就是，父类的属性和行为，子类可以继承得到，同时子类可以写一些特有的特性。通常这样去概括：父类在上层，特点是更抽象，子类在底层，特点是更细分和具体。

**1.继承的语法**

在C++中继承的语法格式如下

class 子类名称 : 继承方式 父类名称
    {
    
    };

来一个具体的例子，动物类和狗类的继承例子

class Animal
    {
    public:
        string m_Name;
        int lets;
        
        void eat()
        {
            cout << "吃东西" << endl;
        }
    
    };
    
    class Dog : public Animal
    {
    
    };

继承中一些概念：

父类： 更上层，抽象的类，也有把父类叫 基类的
    子类： 更细分，具体的类，也有把子类叫 派生类

**2.继承的好处**

继承最大的好处就是减少重复代码。

**3.继承方式**

在上面语法格式，我们看到冒号后面跟着是继承方式，其中public就是继承方式的一种。其实，继承一共有以下三种方式：

1.  公共继承
2.  保护继承
3.  私有继承

看到这三种，其实就是和权限关键字public protected private一一对应关系。这三种继承方式有什么特点和区别，我们通过例子来说明和学习。

首先给出我们的基类 class A

class A
    {
    
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    };

接下来我们需要写一个子类B，分别通过三种继承方式来继承A，看看有什么特点。

3.1 公共继承

这里采用B类的构造函数，来测试访问基类中a b c。

#include <iostream>
    using namespace std;
    #include <string>
    
    class A
    {
    
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    };
    
    class B : public A
    {
    public:
        void func()
        {
            a = 10; // 父类中的公共权限成员，到了子类中依然是公共权限
            b = 10; // 父类中的保护权限成员，到了子类中依然是保护权限
            c = 10; // 父类中的私有权限成员，子类访问不到
        }
    };

这样写，c = 10这行代码就会报错：

![20200202224122280.png][]

上面22行，b = 10这怎么就判断是保护权限呢，我们通过下面代码可以证明b是保护权限，保护权限的特点是：类内可以访问，类外访问不到。

#include <iostream>
    using namespace std;
    #include <string>
    
    class A
    {
    
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    };
    
    class B : public A
    {
    public:
        void func()
        {
            a = 10; // 父类中的公共权限成员，到了子类中依然是公共权限
            b = 10; // 父类中的保护权限成员，到了子类中依然是保护权限
            //c = 10; // 父类中的私有权限成员，子类访问不到
        }
    };
    
    void test01()
    {
        B b;
        b.a = 20;
        b.b = 30; 
    
    }

当前B是public的继承方式，在test01函数中，B的实例对象b是访问不到b这个属性。说明，继承之后B中的属性b是保护权限，a依然是public权限。保护权限的特点是：类内部可以访问（在func()函数可以证明），类外部（test01()函数可以证明）不能访问。公共权限的特点：类内部和类外部都能访问。

3.2 保护继承

有了上面代码的理解，直接来看保护继承的代码。

#include <iostream>
    using namespace std;
    
    class A
    {
    
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    };
    
    class B : protected A
    {
    public:
        void func()
        {
            a = 10; // 父类中的公共权限成员，到了子类中变成保护权限
            b = 10; // 父类中的保护权限成员，到了子类中依然是保护权限
            //c = 10; // 父类中的私有权限成员，子类访问不到
        }
    };
    
    void test01()
    {
        B b;
        b.a = 20;
        b.b = 30; 
    
    }

以上代码证明两点：

1） 父类私有成员，子类继承之后依然无法访问，第22行注销的代码证明这个结论

2） 保护继承之后，父类的公共权限到了子类变成了保护权限，父类的保护权限成员到了子类依然是保护权限，这个通过test01()中的b.a 和b.b 访问报错来证明。（保护权限的特点：类内可以访问，类外不能访问）

3.3 私有继承

依然直接来看代码（相关报错，需要在vs这款IDE中看到）

#include <iostream>
    using namespace std;
    
    class A
    {
    
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    };
    
    class B : private A
    {
    public:
        void func()
        {
            a = 10; // 父类中的公共权限成员，到了子类中变成私有权限
            b = 10; // 父类中的保护权限成员，到了子类中变成私有权限
            c = 10; // 父类中的私有权限成员，子类访问不到
        }
    };
    
    void test01()
    {
        B b;
        b.a = 20;
        b.b = 30; 
    
    }

私有继承之后，父类的公共权限和保护权限的变量，到了子类都变成私有权限，父类的私有权限变量，子类不能访问。

上面代码依然没有有效证明a 和b 到了子类就变成私有权限，为了证明这个，我们在写一个类C，通过公共继承B，看看在C类内部能不能访问父类B的a b 成员。

#include <iostream>
    using namespace std;
    
    class A
    {
    
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    };
    
    class B : private A
    {
    public:
        void func()
        {
            a = 10; // 父类中的公共权限成员，到了子类中变成私有权限
            b = 10; // 父类中的保护权限成员，到了子类中变成私有权限
            //c = 10; // 父类中的私有权限成员，子类访问不到
        }
    };
    
    class C : public B
    {
    public:
        void func()
        {
            a = 100;
            b = 100; // 这里访问报错，说明父类B中成员变量a和b都是私有的
        }
    };
    
    int main()
    {
       
        system("pause");
        return 0;
    }

三种继承方式的总结：

公共继承

1. 父类私有的，子类访问不了

2. 父类公共的，子类继承之后依然是公共的

3. 父类保护的，子类继承之后依然是保护的

保护继承

1. 父类私有的，子类访问不了

2. 父类公共的，子类继承之后变成保护的

3. 父类保护的，子类继承之后依然是保护的

私有继承

1. 父类私有的，子类访问不了

2. 父类公共的，子类继承之后变成私有的