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

开始学习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这行代码就会报错：

上面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. 父类公共的，子类继承之后变成私有的

3. 父类保护的，子类继承之后变成私有的