C++11

C++继承的概念及语法

继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。

继承（Inheritance）可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类B继承于类A，那么B就拥有A的成员变量和成员函数。被继承的类称为父类或基类，继承的类称为子类或派生类。

派生类除了拥有基类的成员，还可以定义自己的新成员，以增强类的功能。

以下是两种典型的使用继承的场景：

1) 当你创建的新类与现有的类相似，只是多出若干成员变量或成员函数时，可以使用继承，这样不但会减少代码量，而且新类会拥有基类的所有功能。

2) 当你需要创建多个类，它们拥有很多相似的成员变量或成员函数时，也可以使用继承。可以将这些类的共同成员提取出来，定义为基类，然后从基类继承，既可以节省代码，也方便后续修改成员。

下面我们定义一个基类 People，然后由此派生出 Student 类：

#include<iostream>

using namespace std;

//基类--Pelple

class People{

private:

    char *name;

    int age;

public:

    void setName(char*);

    void setAge(int);

    char *getName();

    int getAge();

};

void People::setName(char *name){ this->name = name; }

void People::setAge(int age){ this->age = age; }

char* People::getName(){ return this->name; }

int People::getAge(){ return this->age;}

//派生类--Student

class Student: public People{

private:

    float score;

public:

    void setScore(float);

    float getScore();

};

void Student::setScore(float score){ this->score = score; }

float Student::getScore(){ return score; }

int main(){

    Student stu;

    stu.setName("小明");

    stu.setAge(16);

    stu.setScore(95.5f);

    cout<<stu.getName()<<"的年龄是 "<<stu.getAge()<<"，成绩是 "<<stu.getScore()<<endl;

    return 0;

}

运行结果：

小明的年龄是 16，成绩是 95.5

本例中，People 是基类，Student 是派生类。Student 类继承了 People 类的成员，同时还新增了自己的成员变量 score 和成员函数 setScore、getScore。

请认真观察代码第21行：

class Student: public People

这就是声明派生类的语法。在 class 后面的”Student“是新建的派生类，冒号后面的”People“是已经存在的基类。在”People“之前有一关键宇 public，用来表示是公有继承。

由此总结出继承的一般语法为：

class 派生类名:［继承方式］ 基类名{

    派生类新增加的成员

};

继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。我们将在下节详细讲解。

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

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 保护
保护 保护 不可访问
保护 保护
不可访问 共有
私有