C++继承权限和继承方式

C++继承的一般语法为：
继承方式限定了基类成员在派生类中的访问权限，包括public（公有的）、private（私有的）和protected（受保护的）。

此项是可选项，如果不写，默认为private（成员变量和成员函数默认也是private）。

现在我们知道，public、protected、private 三个关键字除了可以修饰类的成员，还可以指定继承方式。

public、protected、private 修饰类的成员
类成员的访问权限由高到低依次为public --> protected --> private，我们在《C++类成员的访问权限》一节中讲解了public 和private：public 成员可以通过对象来访问，private 成员不能通过对象访问。

现在再来补充一下protected。

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 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。

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

【示例】演示类的继承关系。

1.#include<iostream>
ing namespace std;
3.
4.//基类People
5.class People{
6.public:
7.void setname(char*name);
8.void setage(int age);
9.void sethobby(char*hobby);
10.char*gethobby();
11.protected:
12.char*m_name;
13.int m_age;
14.private:
15.char*m_hobby;
16.};
17.void People::setname(char*name){ m_name = name;}
18.void People::setage(int age){ m_age = age;}
19.void People::sethobby(char*hobby){ m_hobby = hobby;}
20.char*People::gethobby(){return m_hobby;}
21.
22.//派生类Student
23.class Student:public People{
24.public:
25.void setscore(float score);
26.protected:
27.float m_score;
28.};
29.void Student::setscore(float score){ m_score = score;}
30.
31.//派生类Pupil
32.class Pupil:public Student{
33.public:
34.void setranking(int ranking);
35.void display();
36.private:
37.int m_ranking;
38.};
39.void Pupil::setranking(int ranking){ m_ranking = ranking;}
40.void Pupil::display(){
41.cout<<m_name<<"的年龄是"<<m_age<<"，考试成绩为"<<m_score<<"分，班级排
名第"<<m_ranking<<"，TA喜欢"<<gethobby()<<"。

"<<endl;
42.}
43.
44.int main(){
45.Pupil pup;
46.pup.setname("小明");
47.pup.setage(15);
48.pup.setscore(92.5f);
49.pup.setranking(4);
50.pup.sethobby("乒乓球");
51.pup.display();
52.
53.return0;
54.}
运行结果：
小明的年龄是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 关键字使用示例：
1.#include<iostream>
ing namespace std;
3.
4.//基类People
5.class People{
6.public:
7.void show();
8.protected:
9.char*m_name;
10.int m_age;
11.};
12.void People::show(){
13.cout<<m_name<<"的年龄是"<<m_age<<endl;
14.}
15.
16.//派生类Student
17.class Student:public People{
18.public:
19.void learning();
20.public:
ing People::m_name;//将private改为public
ing People::m_age;//将private改为public
23.float m_score;
24.private:
ing People::show;//将public改为private
26.};
27.void Student::learning(){
28.cout<<"我是"<<m_name<<"，今年"<<m_age<<"岁，这次考了"<<m_score<<"分！
"<<endl;
29.}
30.
31.int main(){
32.Student stu;
33.stu.m_name ="小明";
34.stu.m_age =16;
35.stu.m_score =99.5f;
36.stu.show();//compile error
37.stu.learning();
38.
39.return0;
40.}
代码中首先定义了基类People，它包含两个protected 属性的成员变量和一个public 属性的成员函数。

定义Student 类时采用public 继承方式，People 类中的成员在
Student 类中的访问权限默认是不变的。

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

因为say() 函数是private 属性的，所以代码第33行会报错。

把该行注释掉，程序输出结果为：
我是小明，今年16岁，这次考了99.5分！。