【C++】：C++中的继承权限和继承方式

这个很简单，就是Private都只能通过父类的函数去访问，其他的都跟随继承方式掉级就可以了，用的最多的还是public继承

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

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

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

1) public继承方式

• 基类中所有public成员在派生类中为public属性；
• 基类中所有protected成员在派生类中为protected属性；
• 基类中所有private成员在派生类中不可访问。

2) protected继承方式

• 基类中的所有public成员在派生类中为protected属性；
• 基类中的所有protected成员在派生类中为protected属性；
• 基类中的所有private成员在派生类中仍然不可访问。

3) private继承方式

• 基类中的所有public成员在派生类中均为private属性；
• 基类中的所有protected成员在派生类中均为private属性；
• 基类中的所有private成员在派生类中均不可访问。

由此可见：

• 基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。
• 基类中的 private 成员在派生类中始终是不可访问的。

private 继承限制太多，实际开发中很少使用，一般使用 public。

一个完整的例子：

    
    
#include<iostream>
using namespace std;
//基类--Pelple
class People{
private:
    char *name;
    int age;
public:
    void setName(char*);
    void setAge(int);
    void display();
};
void People::setName(char *name){ this->name = name; }
void People::setAge(int age){ this->age = age; }
void People::display(){ cout<<name<<"的年龄是 "<<age; }
//派生类--Student
class Student:  public People{
private:
    float score;
public:
    Student(char*, int, float);
    void display1();
};
Student::Student(char *name, int age, float score){
    this->setName(name);
    this->setAge(age);
    this->score = score;
}
void Student::display1(){
    this->display();
    cout<<"，成绩是 "<<score<<endl;
}
int main(){
    Student stu("小明", 15, 90.5);
    stu.display1();
    return 0;
}

运行结果：
小明的年龄是 15，成绩是 90.5

读者要注意 Student 类的构造函数和 display1() 函数。在构造函数中，我们要设置 name、age、score 变量的值，但 name、age 在基类中被声明为 private，所以在 Student 中不可直接访问，只能借助基类中的成员函数 setName()、setAge() 来间接访问。

在 display1() 函数中，同样不能访问 People 类中 private 属性的成员变量，只能借助 People 类的成员函数来间接访问。

改变访问属性

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

using 关键字使用示例：

    
    
#include<iostream>
using namespace std;
class People{
protected:
    char *name;
    int age;
public:
    void say();
};
void People::say(){
    cout<<"你好，欢迎来到C语言中文网！"<<endl;
}
class Student: public People{
private:
    using People::say;  //改变访问属性
public:
    using People::name;  //改变访问属性
    using People::age;
    float score;
    void learning();
};
void Student::learning(){
    cout<<"我是"<<name<<"，今年"<<age<<"岁，我学习非常努力，这次考了"<<score<<"分！"<<endl;
}
int main(){
    Student stu;
    stu.name = "小明";
    stu.age = 16;
    stu.score = 99.5f;
    stu.say();  //compile error
    stu.learning();
    return 0;
}

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

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

因为 say() 函数是 private 属性的，所以代码第33行会报错。把该行注释掉，程序输出结果为：
我是小明，今年16岁，我学习非常努力，这次考了99.5分！

多级继承

实际开发中，经常会有多级继承的情况。例如，类A为基类，类B继承自类A，类C又继承自类B，那么类C也是类A的派生类，它们构成了多级继承的关系。如下图所示：


多级继承的规则与上面相同，这里仅举例说明。

    
    
class A{  //基类
public:
    int i;
protected:
    void f2( );
    int j;
private:
    int k;
};
class B: public A{  //public继承
public:
    void f3( );
protected:
    void f4( );
private:
    int m;
};
class C: protected B{  //protected方式
public:
    void f5( );
private:
    int n;
};

各成员在不同类中的访问属性如下：

	i	f2	j	k	f3	f4	m	f5	n
基类A	共有	保护	保护	私有
共有派生类B	共有	保护	保护	不可访问	共有	保护	私有
保护派生类C	保护	保护	保护	不可访问	保护	保护	不可访问	共有	私有