C++ 面向对象 - 类的继承与派生

最新推荐文章于 2024-04-25 17:28:46 发布
最新推荐文章于 2024-04-25 17:28:46 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： C++ 面向对象 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HkSwaggyD/article/details/132429492
版权

继承

继承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。

C++ 中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，基类是对派生类的抽象，派生类是对基类的具体化。它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。

继承方式

不同的继承方式决定了基类成员在派生类中的访问属性，主要体现在：

  1. 派生类成员对基类成员的访问权限；

  2. 通过派生类对象对基类成员的访问权限。

对于派生类的成员或者派生类对象访问自己类的成员不讨论，跟一般类一样，下面只讨论对基类的成员的访问。

  • 公有继承：基类的 public 和 protected 成员访问属性在派生类中保持不变；基类的 private 成员不可直接访问。

  • 保护继承：基类的 public 和 protected 成员都以 protected 身份出现在派生类中；基类的 private 成员不可直接访问。

  • 私有继承：基类的 public 和 protected 成员，都以 private 身份出现在派生类中；基类的 private 成员不可直接访问。

可以看出无论采用何种继承方式得到的派生类，派生类成员及其友元都不能访问基类的私有成员。且一般情况，保护继承与私有继承在实际编程中极少使用，它们只在技术理论上有意义。

公有继承

公有继承是访问性最高的一种继承，在子类中能完整延续父类成员的访问性，而且对外可见。如果要公有继承一个类，只需继承时在类名前面加上 public 关键字即可。

在公有继承中，派生类成员可以访问继承的基类的 public 部分与 protected 部分，但是不能访问 private 部分，只有基类成员以及基类的友元可以访问 private 部分。

例如：

class Base
{
public:
    int A;
};

class D1 : public Base // 公有继承 Base 类
{
    /* …… */
};

int main()
{
    D1 d;
    d.A = 10; // 访问 D1 的基类 Base 中的 A 成员，因为是公有继承，所以没问题
}
保护继承

保护继承相对于公有继承，访问性有所降低，父类的公有成员在子类中变成了保护成员，也就无法在外部通过一个对象访问父类成员了，但是对于这个子类的子类仍然是可见的（因为可见性只是降到了 protected ）。

如果要保护继承一个类，只需继承时在类名前面加上 protected 关键字即可。

例如：

class Base
{
public:
    int A;
};

class D1 : protected Base // 保护继承 Base 类
{
    /* …… */
};

int main()
{
    D1 d;
    d.A = 10; // 尝试访问 D1 的基类 Base 中的 A 成员，但是由于是保护继承，所以这样做是错误的。
}

在保护继承中如果想通过子类访问父类的成员，那就只能在子类中增加一些 get 、set 函数来实现了。

例如：

/* Base类的定义同上 */
class D1 : protected Base
{
public:
    void SetA(int a); // 设置 Base 类中 A 的值
    int GetA(); // 获取 Base 类中 A 的值
};

void D1::SetA(int a)
{
    A = a;
}
int D1::GetA()
{
    return A;
}

int main()
{
    Student st;
    st.SetA(10); // 将 Base 类的 A 成员设置为 10
}
私有继承

私有继承在保护继承的基础上更进一步，访问性进一步降低，父类中的公有成员和保护成员的访问性均降到了私有 private，不仅对外不可见，对这个类的子类也不可见了。

要私有继承一个类，只需继承时在类名前面加上 private 关键字即可。

例如：

/* 继承关系：Base->D1->D2 */
class Base
{
public:
    int A;
};

class D1 : private Base // 私有继承 Base 类
{
public:
    F1();
};
void D1::F1()
{
    A = 10; // 父类的成员 A 可以看做 D1 类的私有成员，在 D1 类中访问 A 是可行的
}

class D2 : public D1 // 公有继承 D1
{
public:
    F2();
};
void D2::F2()
{
    A = 10; // 这里就不行了，因为 D1 类私有继承了 Base 类，所以 Base 类的 A 成员对 D2 类就是不可见的。
}

同样，如果想在某个类的外部或者它的子类中访问它私有继承的基类的成员，那也只能在这个类中增加 get、set 方法了。

例如：

/* Base类的定义同上 */
/* 继承关系：Base->D1->D2 */
class D1 : private Base
{
public:
    void SetA(int a); // 设置 Base 类中 A 的值
    int GetA(); // 获取 Base 类中 A 的值
};
void D1::SetA(int a)
{
    A = a;
}
int D1::GetA()
{
    return A;
}

class D2 : public D1 // 公有继承 D1 类
{
public:
    void F2();
}
void D2::F2()
{
    SetA(10); // 调用 D1 类的 SetA 公有方法设置 Base 类 A 的值
}
多继承

在前面的学习中，我们学习的派生类都只有一个基类，称为单继承。除此之外，C++ 也是支持多继承的，即一个派生类可以有两个或多个基类。下面我们就一起来学习多继承的使用。

C++ 语言支持一个子类同时继承多个父类，就像单继承时一样，继承多个父类也就相当于同时有了多个父类的公有成员和保护成员，而且可以单独为每一个父类指定继承的方式。

因此多继承的优点说可以使一个类实现多个接口，而缺点使容易造成混淆。

如果要继承多个类，只需将父类的类名依次写在子类类名的冒号（:）后面，基类名之间用逗号（,）隔开，每一个基类名前面带上它的访问性关键字。即多继承声明语法如下：

class 派生类名 : 访问控制 基类名1, 访问控制 基类名2, ...
{
    成员变量和成员函数的声明
};

例如：

/* 继承关系：BaseA->D，BaseB->D */
class BaseA
{
public:
    int A;
};
class BaseB
{
public:
    int B;
};

class D : public BaseA , public BaseB // 公有继承 BaseA 和 BaseB
{
/* 其他成员 */
};

int main()
{
    D d;
    d.A = 10; // 给来自 BaseA 类的成员 A 赋值
    d.B = 10; // 给来自 BaseB 类的成员 B 赋值
}
多继承访问基类成员

多继承访问基类成员大体与单继承一致，但当继承的多个父类中有同名的成员时，要访问其中一个成员就不能简单的只写成员名了，必须使用作用域运算符（::）来指定是哪一个类的成员。

例如：

/* 继承关系：BaseA->D，BaseB->D */
class BaseA
{
public:
    int A;
};
class BaseB
{
public:
    int A; // 与 BaseA 的 A 成员同名了
};

class D : public BaseA , public BaseB / /公有继承 BaseA 和 BaseB
{
/* 其他成员 */
};

int main()
{
    D d;
    d.BaseA::A = 10; // 使用作用域运算符，给来自 BaseA 类的成员 A 赋值
    d.BaseB::A = 10; // 使用作用域运算符，给来自 BaseB 类的成员 A 赋值
}

例题

第1关：公有继承 —— 学生信息类

任务描述

本关任务：采用公有继承设计学生信息类。

编程要求

在右侧编辑器中的Begin-End之间补充代码，设计 Student 类，并实现 Set 和 PrintSID 函数，具体要求如下：

  • Student 类公有成员函数：void PrintSID()，函数输出成员变量 SID 的值，输出格式为：学号：SID。

  • 普通函数：Set(int sid,string name,Student *ptr)，它用前两个参数设置 ptr 对象的 SID 和 Name（继承 People 拥有的属性）属性值。

现在已有一个基类 People，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值）。

class People
{
public:
    string Name;
    void PrintName();
};
void People::PrintName()
{
    cout << "姓名：" << Name << endl;
}
测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：1 厉宏富

预期输出：

  1. 学号：1
  2. 姓名：厉宏富
代码解析
#include "people.h"     // People 类定义在这里面
#include <string>
#include <iostream>

using namespace std;

/**********  Begin **********/
//公有继承 People
class Student : public People
{
public:
    int SID;
    void PrintSID();
};
/*******  End **********/

void Student::PrintSID()
{
    /********* Begin *********/
    //输出 SID
    cout << "学号：" << SID << endl;
    
    
    /********* End *********/
}

void Set(int sid,string name,Student *ptr)
{
    /********* Begin *********/
    //给 ptr 对象的两个属性赋值
    ptr->Name = name;
    ptr->SID = sid;
    
    
    /********* End *********/
}

第2关：保护继承 —— 学生信息类

任务描述

本关任务：采用保护继承设计学生信息类。

相关知识

为了完成本关任务，你需要掌握保护继承的使用。

编程要求

在右侧编辑器中的Begin-End之间补充代码，采用保护继承设计学生信息类，并实现 Set 和 PrintSID 函数，具体要求如下：

  • Student 类公有成员函数：void PrintSID()，函数输出成员变量 SID 的值，输出格式为：学号：SID。

  • 普通函数：Set(int sid,string name,Student *ptr)，它用前两个参数设置 ptr 对象的 SID 和 Name（继承 People 拥有的属性）属性值。

现在已有一个基类 People，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值）。

class People
{
public:
    string Name;
    void PrintName();
};
void People::PrintName()
{
    cout << "姓名：" << Name << endl;
}
测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：1 严宏富

预期输出：

  1. 学号：1
  2. 姓名：严宏富
代码解析
#include "people.h"     // People 类定义在这里面
#include <string>
#include <iostream>
using namespace std;

/**********  Begin **********/
//保护继承 People
class Student : protected People
{
public:
	int SID;
	void PrintSID();
    //添加一个 Set 函数来设置父类的 Name 成员
    void set(string name);
};

/********* End *********/

void Student::PrintSID()
{
    /********* Begin *********/
    //输出学号 SID
    cout << "学号：" << SID << endl;
    
    
    /********* End *********/
}

void Student::set(string name){
    Name = name;
}

void Set(int sid,string name,Student *ptr)
{
    /********* Begin *********/
    //给 ptr 对象的两个属性赋值
    ptr->SID = sid;
    ptr->set(name);
    
    
    /********* End *********/
}

第3关：研究生信息类

任务描述

本关任务：采用私有继承完成学生信息类和研究生信息类的设计。

相关知识

为了完成本关任务，你需要掌握私有继承的使用。

编程要求

在右侧编辑器中的Begin-End之间补充代码，设计学生信息类（ Student ）和设计研究生信息类（ Graduate ），Graduate 类公有继承 Student 类，而 Student 类私有继承 People 类，并实现他们的成员函数以及一个普通函数，具体要求如下：

  1. Graduate 类

增加一个成员变量研究方向：int ResearchID，以及一个成员函数：void PrintResearchID()，函数用来输出 ResearchID 的值，输出格式为：研究方向：ResearchID。

  1. Student 类

补充有成员函数：void PrintSID()，函数输出成员变量 SID 的值，输出格式为：学号：SID。

  1. 普通函数：Set(int sid,int rid,string name,Graduate *ptr)函数，它用前三个参数设置 ptr 所指对象的三个成员。

People 基类，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值），代码如下：

/* 继承关系：People->Student->Graduate */
class People
{
public:
    string Name;
    void PrintName();
};
void People::PrintName()
{
    cout << Name << endl;
}
测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：1 304 厉宏富

预期输出：

  1. 学号：1
  2. 姓名：厉宏富
  3. 研究方向：304
代码解析
#include "people.h" //People类定义在这里面
#include <string>
#include <iostream>
using namespace std;

/********* Begin *********/
//私有继承 People 类
class Student : private People
{
public:
	int SID;
	void PrintSID();
	//添加一个 Set 函数来设置父类的 Name 成员
	void SetName(string name) 
    {
    Name = name;
    }
};

/********* End *********/

void Student::PrintSID()
{
    /********* Begin *********/
    //输出学号 SID
    cout << "学号：" << SID << endl;
    
    
    /********* End *********/
}

/********* Begin *********/
// 公有继承 Student 类
class Graduate : public Student
{
public:
	int ResearchID;
	void PrintResearchID();
	//添加一个 Set 函数来设置父类的 SID 成员
    void SetSID(int sid) 
    {
        SID = sid;
    }
	//添加一个 Set 函数来调用父类的 SetName 函数
    void SetName(string name) {
        Student::SetName(name);
    }
};

/********* End *********/

void Graduate::PrintResearchID()
{
    /********* Begin *********/
    //输出研究方向 ResearchID
    cout << "研究方向：" << ResearchID << endl; 

    
    /********* End *********/
}

void Set(string name,int sid,int rid,Graduate *ptr)
{
    /********* Begin *********/
    //设置 ptr 所指对象的三个成员
    ptr->SetName(name);
    ptr->SetSID(sid);
    ptr->ResearchID = rid;
    
    
    /********* End *********/
}

第4关：狼人类

任务描述

本关任务：采用多继承设计一个狼人类。

编程要求

在右侧编辑器中的Begin-End之间补充代码，实现三个类的设计，其中成员变量和成员函数的访问性可自行设置，具体要求如下：

  1. 狼类（ Wolf ）

    • 成员变量姓名：string Name

    • 成员变量爪子锋利度：int Shape

    • 成员函数：void PrintState()，按照姓名 爪子锋利度格式输出两个成员变量的值。

  2. 人类（ Human ）

    • 成员变量姓名：string Name

    • 成员变量智力：int Intell

    • 成员函数：void PrintState()，按照姓名 智力格式输出两个成员变量的值。

  3. 狼人类（ Werewolf ），它继承狼类和人类

    • 成员函数：void SetName(string name)，函数用来设置两个基类的成员变量姓名。

    • 成员函数：void SetState(int shape,int intell)，函数用 shape 、intell 两个参数分别设置狼类的爪子锋利度和人类的智力。

    • 成员函数：void PrintAllState()，函数按照狼类，人类的顺序调用两个基类的 PrintState 函数，输出他们的成员变量值。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：10 0 狠人

预期输出：

  1. 姓名：狠人，爪子锋利度为：10
  2. 姓名：狠人，智力为：0
代码解析
#include <string>
#include <iostream>

using namespace std;

/********* Begin *********/
class Wolf
{
//狼类成员的声明
public:
    string Name;
    int Shape;
    void PrintState();
    
    
};
//狼类成员的定义

void Wolf::PrintState()
{
    cout << "姓名：" << Name << endl;
    cout << "爪子锋利度为：" << Shape << endl;
}


class Human
{
	//人类成员的声明
    public:
        string Name;
        int Intell;
        void PrintState();
    
    
};
//人类成员的定义

void Human::PrintState()
{
    cout << "姓名：" << Name << endl;
    cout << "智力为：" << Intell << endl;
}

// 记得在这里写上要继承的类
class Werewolf : public Wolf, public Human
{
//狼人类成员的声明
public:
    void SetName(string name);
    void SetState(int shape, int intell);
    void PrintAllState();
    
    
};
//狼人类成员的定义

void Werewolf::SetName(string name)
{
    Wolf::Name = name;
    Human::Name = name;
}

void Werewolf::SetState(int shape, int intell)
{
    Wolf::Shape = shape;
    Human::Intell = intell;
}

void Werewolf::PrintAllState()
{
    cout << "姓名：" << Wolf::Name << "，爪子锋利度为：" << Wolf::Shape << endl;
    cout << "姓名：" << Human::Name << "，智力为：" << Human::Intell << endl;
}

/********* End *********/

HkSwaggyD
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 面向对象程序设计 继承与派生
12-08
C++，多继承，虚继承，聚合类，举例，中学生类派生出大学生类和研究生类，大学生类的属性还包括班级、专业、系；研究生类的属性还包括研究方向、导师姓名。定义构造函数（初始化所有属性）和析构函数以及数据成员的设置和输出。
C++面向对象程序设计 - 继承与派生进一步讨论
最新发布
觉醒法师的专栏
05-06 712
C++中所谓“继承”就是在一个已存在的类的基础上建立一个新类，从已有的类那里获得已有特性，叫做类的继承。从另一角度说，从已有的类（父类）产生一个新的子类，称为类的派生。一个派生类只从一个基类派生，这称为单继承；一个派生类有两个或多个基类，称为多继承。派生类是基类的具体化，而基类则是派生类的抽象。
C++面向对象程序设计 - 继承与派生
觉醒法师的专栏
04-25 813
C++中所谓“继承”就是在一个已存在的类的基础上建立一个新类，从已有的类那里获得已有特性，叫做类的继承。从另一角度说，从已有的类（父类）产生一个新的子类，称为类的派生。一个派生类只从一个基类派生，这称为单继承；一个派生类有两个或多个基类，称为多继承。派生类是基类的具体化，而基类则是派生类的抽象。面向对象技术强调软件的可重用性（software reusability），C++语言提供了类的继承机制，解决了软件重用问题。
【Educoder作业】C++ 面向对象 - 类的继承与派生
JZYshuraK的博客
01-02 967
关于继承，更多的是关注它的意义。在代码量很少的时候用处不大，大不了再写一个。但是当完成一些工作量比较大的工程时，继承就会避免我们重复的写很多东西。
对象数组 —— 学生信息表
ssbviv的博客
10-26 8736
任务描述 本关任务：编写一个能管理多条学生信息的程序。 相关知识 为了完成本关任务，你需要掌握构造函数与析构函数的调用和对象数组的使用。 构造函数与析构函数的调用 构造函数不能直接调用，只能通过声明一个对象或者使用new 运算符动态创建对象时由系统自动调用。 例如： class Test { public: int A; Test(); Test(int a); }; /* 此处省略定义构造函数部分 */ int main() { Test t; // 调用无参构造函数 Test t2(10);
构造函数 —— 学生信息类
Shiwuwaige的博客
03-23 2726
在右侧编辑器中的Begin-End之间补充代码，编写一个学生类 Student，类中含有两个成员变量、两个构造函数和一个析构函数（访问性都为公有的），平台会调用你编写的函数来创建学生对象，具体要求如下： 学号：int SID 姓名：string Name 无参的构造函数：Student()，在函数中将学号初始化为0，姓名初始化为王小明。 带两个参数的构造函数：Student(int sid,string name);，在函数中分别用这两个参数设置内部的两个成员。
类的多态性与虚函数
Sunblogy的博客
11-02 3863
加粗样式 第1关：人与复读机 任务描述 本关任务：设计人类、英语学生类和复读机类三个类。 相关知识 为了完成完成本关任务，你需要掌握虚函数的基本使用。 多态性 在面向对象的方法中，多态性是指向不同对象发送同一个消息，不同对象在接收时会产生不同的行为（方法）。 通俗点说就是可以不用像 C 语言中为了求多种图形的面积而针对不同的图形各设计一个独立名字的函数，在 C++ 中只要设计一个专门用于求面积的函数名即可。这个专门用于求面积的函数名可以作为各种求图形面积的函数名。 这么做的好处在于程序设计者可以省去设立多个
SQL语句---增删改
Skillfully的博客
07-30 1779
1、数据插入 编程要求 全右侧代码片段中 第一题 下 Begin-End 区间的代码，实现功能：MA系新来一名学生，学号07002，姓名 lucy， 性别 F，年龄21，请用insert语句将该学生信息加入student。 补全右侧代码片段中 第二题下 Begin-End 区间的代码，实现功能：新来一名学生，学号07003，姓名 Andy ，性别 F, 但尚未知道年龄， 也未确定分配到哪个系， 请插入已知信息到student。 补全右侧代码片段中 第三题 下 Begin-End 区间的代码，实现
C++面向对象程序设计习题继承与派生.pdf
09-30
"C++面向对象程序设计习题继承与派生.pdf" 继承是面向对象程序设计中的一种重要机制，它允许一个类继承另一个类的属性和行为特征。通过继承，新类可以从现有类中获得特征，从而达到代码复用的目的。在C++中，继承...
C++实验报告--继承和派生.pdf
08-15
继承是面向对象程序设计中的一个基本概念，通过继承机制，可以创建新的类，使其继承父类的所有成员变量和成员函数。继承的优点是可以提高代码的重用性和可维护性。在C++语言中，继承可以通过使用public、private、...
C++ 类的继承与派生实例详解
01-01
继承性是面向对象程序设计最重要的特性之一，使软件有了可重用性，C++提供的类的继承机制。 继承与派生的概念 一个新类从已有的类那里获得已有的特性，这种现象称为类的继承。同样也可以说成已有的类派生出来了新的...
C++ PPT第5章 继承与派生.ppt
05-30
继承是面向对象程序设计中重要的特性，主要是指在已有类的基础上创建新类的过程，这个新类就是派生类。派生类自动包含了基类的成员，包括所有的数据和操作，而且它还可以增加自身新的成员。 继承机制除了支持软件...
C++派生类与继承
qq_42174306的博客
02-17 3605
继承和派生其实都是一回事，只是说法不同罢了。 如：子类继承了父类，父类派生了子类。 那么什么是继承呢 首先，如上图所示是一个动物种类区分图。猫和狗都属于动物这一种类，而猫又可以细分为加菲猫、布偶猫等种类。我们发现这些细分出来的单体在拥有上一级别的共性之外，还有各自的共性。比如加菲猫和布偶猫体型、毛发品质不同，但他们都属于猫类。 在编写代码的时候类与类之间也一样，子类拥有上一级类的共性，又拥有自己的特性！这个时候就可以利用继承的特性减少代...
C++面向对象（二）继承、派生
锅锅的博客
12-11 289
公有继承（public）：基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。保护继承（protected）： 基类的公有和保护成员将成为派生类的保护成员。私有继承（private）：基类的公有和保护成员将成为派生类的私有成员。继承：就是将之前做好的类功能复制过来，不用重复再去实现。派生：把继承类，然后添加新的功能生成的新类过程称为派生。六、继承的析构、构造、和重载。基类：被继承的类为基类。
头哥c++面向对象(类和对象)
weixin_54375830的博客
01-05 2412
第一关： 任务描述 本关任务：声明并定义一个学生信息类。 相关知识 为了完成本关任务，你需要掌握类的声明和定义。 类 在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象，可以利用这些对象的相同特征为它们建立一个集合，而这个集合就称为类。 C++ 中类是把各种不同类型的数据（称为数据成员）和对数据的操作（成员函数）组织在一起而形成的用户自定义的数据类型。它提供了可重用性的好处。 类定义包括声明和实现两大部分。声
C&C++基本输入输出（国防科大）
热门推荐
m0_70469414的博客
10-18 1万+
基础练习，了解流操作数，域宽，getchar与putchar的用法
类的继承与派生
weixin_44941317的博客
04-13 189
1. 吸收基类成员：继承基类中除构造函数和析构函数外的所有非静态成员。2. 改造基类成员：如果声明了一个和某基类成员同名的新成员（如果是成员函数，则参数表也要相同），派生的新成员就隐藏了外层同名成员。3. 添加新的成员。
《代码阅读方法》---笔记（第八章）
weixin_44012721的博客
05-11 804
第八章：文档 1.常见的开发源代码文档格式 文档两种类型： 二进制文件：他们的生成和阅读都要使用专利产品，如：Microsoft Word或Adobe FrameMaker; 文本文件：其中包含标记语言(markup language)形式的结构和格式化命令。 2.文档种类 系统的规格说明文档(system specification document)： 详细描述系统的目标、系统的功能需求、管理和技术上的限制、以及成本和日程等要素，了解所阅读代码的运行环境. 软件需求规格说明(software re
第2关：保护继承 —— 学生信息类
05-04
保护继承是指子类继承父类的成员，但是只有类内和友元可以访问这些成员，对于类外部的其他代码是不可见的。这样可以保护父类的实现细节，同时也可以在子类中使用这些成员。 下面以学生信息类为例，演示如何使用保护继承。 ```c++ #include <iostream> #include <string> using namespace std; // 父类：人类 class Person { public: Person(string name, int age) : m_name(name), m_age(age) {} void showInfo() { cout << "姓名：" << m_name << endl; cout << "年龄：" << m_age << endl; } protected: // 保护成员 string m_name; // 姓名 int m_age; // 年龄 }; // 子类：学生类 class Student : protected Person { public: Student(string name, int age, int score) : Person(name, age), m_score(score) {} void showInfo() { Person::showInfo(); // 调用父类的 showInfo 函数 cout << "成绩：" << m_score << endl; } private: int m_score; // 成绩 }; int main() { Student s("小明", 18, 90); s.showInfo(); // 调用子类的 showInfo 函数 return 0; } ``` 在上面的例子中，父类 `Person` 中的成员 `m_name` 和 `m_age` 被声明为保护成员，子类 `Student` 继承了这两个成员。在子类中，我们使用 `protected` 访问修饰符将父类的成员变量和成员函数设置为保护成员，这样子类就可以访问这些成员了。 在子类中，我们重写了 `showInfo` 函数，并在其中调用了父类的 `showInfo` 函数，然后输出了子类新增的成员 `m_score`。最后在 `main` 函数中，我们创建了一个 `Student` 对象，并调用了 `showInfo` 函数，输出了学生的信息。 在这个例子中，我们使用保护继承来访问父类的成员，这样可以保护父类的实现细节，同时也可以在子类中使用这些成员。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值