c++的继承方式

上面我讲了c++继承的概念以及语法，c++继承的语法一般为：
C++继承的一般语法为：
class 派生类名:［继承方式］ 基类名{
派生类新增加的成员
};

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

public，protocol，private修饰类的成员、

类成员的访问权限由高到低依次为public->protectd->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 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性

include<iostream>
using namespace std;
//基类People
class People{
public:
void setname(char *name);
void setage(int age);
void sethobby(char *hobby);
char *gethobby();
protected:
char *m_name;
int m_age;
private:
char *m_hobby;
};
void People::setname(char *name){ m_name = name; }
void People::setage(int age){ m_age = age; }
void People::sethobby(char *hobby){ m_hobby = hobby; }
char *People::gethobby(){ return m_hobby; }
//派生类Student
class Student: public People{
public:
void setscore(float score);
protected:
float m_score;
};
void Student::setscore(float score){ m_score = score; }
//派生类Pupil
class Pupil: public Student{
public:
void setranking(int ranking);
void display();
private:
int m_ranking;
};
void Pupil::setranking(int ranking){ m_ranking = ranking; }
void Pupil::display(){
cout<<m_name<<"的年龄是"<<m_age<<"，考试成绩为"<<m_score<<"分，班级排名第"<<m_ranking<<"，TA喜欢"<<gethobby()<<"。"<<endl;
}
int main(){
Pupil pup;
pup.setname("小明");
pup.setage(15);
pup.setscore(92.5f);
pup.setranking(4);
pup.sethobby("乒乓球");
pup.display();
return 0;
}

运行结果：
小明的年龄是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 关键字）。

#include<iostream>
using namespace std;
//基类 Pelple
class People{
public:
void setname(char *name);
void setage(int age);
char *getname();
int getage();
private:
char *m_name;
int m_age;
};
void People::setname(char *name){ m_name = name; }
void People::setage(int age){ m_age = age; }
char* People::getname(){ return m_name; }
int People::getage(){ return m_age;}
//派生类 Student
class Student: public People{
public:
void setscore(float score);
float getscore();
private:
float m_score;
};
void Student::setscore(float score){ m_score = score; }
float Student::getscore(){ return m_score; }
int main(){
Student stu;
stu.setname("小明");
stu.setage(16);
stu.setscore(95.5f);
cout<<stu.getname()<<"的年龄是 "<<stu.getage()<<"，成绩是 "<<stu.getscore()<<endl;
return 0;
}

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

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

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