C++面向对象 - 继承、派生和多态

最新推荐文章于 2022-09-26 13:36:13 发布

念去去~

最新推荐文章于 2022-09-26 13:36:13 发布

阅读量5.5k

点赞数 15

分类专栏： C++程序设计题

C++程序设计题专栏收录该内容

7 篇文章 57 订阅

订阅专栏

公有继承 —— 学生信息类

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

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

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

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

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

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

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

公有继承：基类的 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 成员，因为是公有继承，所以没问题
}
编程要求
在右侧编辑器中的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;
}

usr.h

#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->SID = sid;
    ptr->Name = name;
    
    /********* End *********/
}

people.h

#ifndef PEO_H_
#define PEO_H_

#include<string>
#include<iostream>
using namespace std;

class People
{
	public:
		string Name;
		void PrintName();
};

void People::PrintName()
{
    cout << "姓名：" << Name << endl;
}
#endif

main.cpp

#include "usr.h"

int main()
{
	int id; 
	string name;
	cin >> id >> name ;
    Student st;
    Set(id,name,&st);
    st.PrintSID();
	st.PrintName();
}

保护继承 —— 学生信息类

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

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

保护继承
保护继承相对于公有继承，访问性有所降低，父类的公有成员在子类中变成了保护成员，也就无法在外部通过一个对象访问父类成员了，但是对于这个子类的子类仍然是可见的（因为可见性只是降到了 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
}
编程要求
在右侧编辑器中的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;
}
usr.h

#include "people.h"     // People 类定义在这里面
#include <string>
#include <iostream>
using namespace std;

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

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

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

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

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

people.h

#ifndef PEO_H_
#define PEO_H_

#include<string>
#include<iostream>
using namespace std;

class People
{
	public:
		string Name;
		void PrintName();
};

void People::PrintName()
{
    cout << "姓名：" << Name << endl;
}
#endif

run.cpp

#include "usr.h"

int main()
{
	int id; 
	string name;
	cin >> id >> name ;
    Student st;
    Set(id,name,&st);
    st.PrintSID();
	((People*)&st)->PrintName();
}

研究生信息类

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

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

私有继承
私有继承在保护继承的基础上更进一步，访问性进一步降低，父类中的公有成员和保护成员的访问性均降到了私有 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 的值
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，设计学生信息类（ Student ）和设计研究生信息类（ Graduate ），Graduate 类公有继承 Student 类，而 Student 类私有继承 People 类，并实现他们的成员函数以及一个普通函数，具体要求如下：

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

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

普通函数：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;
}

usr.h

#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 成员
    	friend void Set(string name,int sid,int rid,Graduate *ptr); 
		//添加一个 Set 函数来调用父类的 SetName 函数
    	void set(string name){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->set(name);
    ptr->SID=sid;
    ptr->ResearchID=rid;
    
    /********* End *********/
}

people.h

#ifndef PEO_H_
#define PEO_H_
#include<string>
#include<iostream>
using namespace std;

class People
{
	public:
		string Name;
		void PrintName();
};

void People::PrintName()
{
    cout << "姓名：" << Name << endl;
}
#endif

main.cpp

#include "usr.h"

int main()
{
	int i,j;
	string name;
	cin >> i >> j >> name;
    Graduate st;
    Set(name,i,j,&st);
    ((Student*)&st)->PrintSID();
	((People*)&st)->PrintName();
    st.PrintResearchID();
}

狼人类

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

相关知识
在前面的关卡中，我们学习的派生类都只有一个基类，称为单继承。除此之外，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 赋值
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，实现三个类的设计，其中成员变量和成员函数的访问性可自行设置，具体要求如下：

狼类（ Wolf ）

成员变量姓名：string Name

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

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

人类（ Human ）

成员变量姓名：string Name

成员变量智力：int Intell

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

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

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

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

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

usr.h

#include <string>
#include <iostream>

using namespace std;

/********* Begin *********/
class Wolf
{
	//狼类成员的声明
public:
	string Name;
	int Shape;

	void PrintState();
    
    
};
//狼类成员的定义

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


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

void Human::PrintState()
{
	cout<< "姓名："<<Name<<"，智力为："<<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)
{
	Shape=shape;
	Intell=intell;
}
void Werewolf::PrintAllState()
{
	
	Wolf::PrintState();
	Human::PrintState(); 
}

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

run.cpp

#include "usr.h"

int main()
{
	int i,j;
	string name;
	cin >> i >> j >> name;
    Werewolf ww;
    ww.SetName(name);
    ww.SetState(i,j);
    ww.PrintAllState();
}

人与复读机

任务描述
本关任务：设计人类、英语学生类和复读机类三个类。

相关知识
为了完成完成本关任务，你需要掌握虚函数的基本使用。

多态性
在面向对象的方法中，多态性是指向不同对象发送同一个消息，不同对象在接收时会产生不同的行为（方法）。

通俗点说就是可以不用像 C 语言中为了求多种图形的面积而针对不同的图形各设计一个独立名字的函数，在 C++ 中只要设计一个专门用于求面积的函数名即可。这个专门用于求面积的函数名可以作为各种求图形面积的函数名。

这么做的好处在于程序设计者可以省去设立多个函数名对应多个函数的麻烦，使用的时候统一用同一个函数名就可调用具有不同功能的函数。

多态在 C++ 中的实现可以是函数的重载、运算符的重载和虚函数，本实训我们介绍虚函数的使用。

虚函数
我们知道在同一个类中是不能定义两个名字相同、参数个数和类型完全相同的函数，否则就是重复定义。但是在类的继承层次结构中，在不同的层次中可以出现名字相同、参数个数和类型相同而功能不同的函数。这时系统会根据同名覆盖的原则决定调用的对象。

那么有没有一种方法，用同一种调用形式，既能调用派生类又能调用基类的同名函数？即不通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针调用它们，虚函数就是用来解决这个问题的。

虚函数是一种动态的重载方式。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并可以通过基类指针或引用来访问基类和派生类中同名函数。

C++ 中要声明一个成员函数为虚函数，只需要在函数的声明前加上一个关键字 virtual 即可，然后就像对待普通成员函数那样，给它加上定义。

例如：

class Base
{
public:
virtual void VFunc(); // 声明一个虚函数
};
void Base::VFunc()
{
cout << “虚函数” << endl;
}
重写父类虚函数
当一个类继承了一个含有虚函数的类，子类就可以选择是否要对父类的虚函数进行重写。所谓重写，就是覆盖父类中的定义，提供一个自己的定义。当然也可以选择不重写，那么就沿用父类的定义。

要重写一个虚函数，需要增加一条与要重写的函数相同（参数与返回值）的函数声明，然后在声明后面加上说明符 override。

例如：

/* Base类的声明同上 */
class D1 : public Base // 继承 Base 类
{
public:
void VFunc() override; // 重写 VFunc 函数
};
void D1::VFunc()
{
cout << “覆盖父类实现” <<endl;
}
int main()
{
D1 b;
b.VFunc();
}
输出结果为：覆盖父类实现

在子类中重写虚函数时是可以重新定义访问性的，即使父类中虚函数的访问性为 private，在子类中仍然可以重写为 public。如果子类想要访问被重写的父类的定义，同样使用作用域运算符（::）即可。

例如：

/* Base类的声明同上 */
class D1 : public Base // 继承 Base 类
{
public:
void VFunc() override; // 重写 VFunc 函数
};
void D1::VFunc()
{
Base::VFunc(); // 调用父类的定义
cout << “覆盖父类实现” <<endl;
}
int main()
{
D1 b;
b.VFunc();
}
输出结果为：

虚函数
覆盖父类实现
编程要求
在右侧编辑器中的Begin-End之间补充代码，设计人类、英语学生类和复读机类三个类，具体要求如下：

人类（ Chinese ）

它有一个虚函数 greet，函数输出中文问候，即你好。
英语学生类（ EnglishLearner ）

继承 Chinese 类，重写 greet 函数，访问性为 public，输出英文问候，即Hello。
复读机类（ Repeater ）

继承 Chinese 类，以 public 访问性重写 greet 函数，函数调用 Chinese 类的 greet 函数。

#include <iostream>
using namespace std;

/********* Begin *********/
class Chinese
{
	//人类的声明
public:
    virtual void greet();
    
    
};
//人类的定义
void Chinese::greet()
{
	cout<<"你好"<<endl; 
}



class EnglishLearner : public Chinese
{
	//英语学生类的声明
    
public:
    void greet() override;
    
};
//英语学生类的定义

void EnglishLearner::greet()
{
	cout<<"Hello"<<endl;
}



class Repeater : public Chinese
{
	//复读机类的声明
public:
    void greet() override;
    
};
//复读机类的定义

void Repeater::greet()
{
	Chinese::greet();
}

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

.cpp

#include "usr.h"

int main()
{
    Chinese ce;
    EnglishLearner le;
    Repeater re;
    ce.greet();
    le.greet();
    re.greet();
}

复读机的毁灭

任务描述
本关任务：设计三个复读机类并实现一个普通函数。

相关知识
为了完成本关任务，你需要掌握虚析构函数的使用。

多态性的体现
C++ 允许将一个对象的指针赋值给它的父类指针变量。而当通过父类指针调用一个虚函数时，则会调用子类中最后被重写的那个版本，这样对于同一段通过指针调用某个虚函数的代码，就会因为实际指向的对象不同，而调用不同函数，这就是所谓的多态性。

同理，通过引用调用一个虚函数，也会有这样的效果。

例如：

class Base
{
public:
virtual void Cal(int a,int b);
};
void Base::Cal(int a, int b)
{
cout << a * b << endl; // 默认是乘法
}
class Add : public Base
{
public:
void Cal(int a,int b) override;
};
void Add::Cal(int a,int b)
{
cout << a + b << endl; // 实现一个加法
}
class Sub : public Base
{
public:
void Cal(int a,int b) override;
};
void Sub::Cal(int a,int b)
{
cout << a - b << endl; //实现一个减法
}
//普通函数
void call(Base *ptr)
{
ptr->Cal(10,10); // 通过指针调用虚函数
}
int main()
{
Add ad;
call(&ad);
Sub sb;
call(&sb);
}
输出结果为：

20
0
可以看到，连续两次调用 call 函数，调用的效果有所不同。第一次调用的是对象是 Add，因此实现的是加法，即10+10=20；而第二次的调用对象是 Sub，实现的则是减法，即10-10=0。

虽然 C++ 也允许将子类对象直接赋值给父类变量，但是这样做会导致子类被切割成父类对象，丢失了子类的成分，这时调用虚函数，也就不会调用到被子类的重写的版本了。

例如：

/* 类的定义同上 */
void call(Base b) // 这里不使用指针
{
b.Cal(10,10);
}
int main()
{
Add ad;
call(ad); // Add 子类赋值给 Base 父类变量
Sub sb;
call(sb); // Sub 子类赋值给 Base 父类变量
}
输出结果为：

100
100
如果子类对象赋值给父类变量，则使用该变量时只能访问子类的父类部分（因为子类含有父类的部分，所以不会有问题）。因此无论哪个对象在调用 Call 函数时都是调用的父类的成员函数，所以输出结果都为100，即10*10=100。

虚析构函数
如果一个父类的析构函数没有声明成虚函数，那么使用 delete 运算符销毁一个父类指针所指的子类对象时，就只会调用父类的析构函数，子类的析构函数则不会被调用，这样就可能导致子类动态分配的资源无法及时回收，造成资源泄露。

例如：

class Base
{
public:
~Base(); // 析构函数不是虚函数
};
Base::~Base()
{
cout << “父类析构函数” << endl;
}
class D : public Base
{
public:
int *Ptr;
D();
~D();
};
D:😄():Ptr(new int){} // 动态分配一块 int 类型大小的空间
D::~D()
{
delete Ptr; // 回收 Ptr 所指空间
cout << “子类析构函数” << endl;
}
int main()
{
Base *ptr = new D();
delete ptr; // 由于只会调用 Base 类的析构函数，导致 D 类中 Ptr 所指的那块空间没有被释放，造成内存泄露。
}
输出结果为：父类析构函数

如果将析构函数声明为虚函数，调用它时除了调用子类重写的那个版本，还会沿着继承链向上（父类方向）依次调用父类的析构函数。

对于上面那个例子，如果将 Base 类的析构函数声明成虚函数，即virtual ~Base()，那么最后得到的输出结果就是：

子类析构函数
父类析构函数
即也就是依次调用了 D 类、Base 类的析构函数。所以，在一般情况下析构函数建议声明成虚函数。

编程要求
在右侧编辑器中的Begin-End之间补充代码，设计三个复读机类和一个普通函数，具体要求如下：

复读机类（ Repeater ）

它有一个成员函数 Play，在这里它什么也不做。它还有一个析构函数，它被调用时会输出一行砰！。
正向复读机类（ ForRepeater ）

继承 Repeater 类并重写 Play 函数，输出没想到你也是一个复读机且在析构函数中输出正·复读机炸了。
反向复读机类（ RevRepeater ）

继承 Repeater 类也重写 Play 函数，输出机读复个一是也你到想没且在析构函数中输出机读复·反炸了。
普通函数：Repeater* CreateRepeater(int type)，函数根据 type 的值，动态创建不同的复读机对象，并返回它的指针。其中当type = 0，创建 ForRepeater 对象；type = 1，创建 RevRepeater 对象；其他则返回 0。

#include <iostream>
using namespace std;

/********* Begin *********/
class Repeater
{
	//复读机基类的声明
public:
    virtual void Play(); 
    virtual ~Repeater();
    
    
};
//复读机基类的定义
void Repeater::Play()
{
}
Repeater::~Repeater()
{
	cout<<"砰！"<<endl;
}



class ForRepeater : public Repeater
{
	//正向复读机的声明
public:
    void Play() ;
    ~ForRepeater();
    
    
};
//正向复读机的定义
void ForRepeater::Play()
{
	cout<<"没想到你也是一个复读机"<<endl;
}
ForRepeater::~ForRepeater()
{
	cout<<"正·复读机 炸了"<<endl;
}



class RevRepeater : public Repeater
{
	//反向复读机的声明
public:
    void Play() ;
    ~RevRepeater();
    
    
};
//反向复读机的定义
void RevRepeater::Play()
{
	cout<<"机读复个一是也你到想没"<<endl;
}
RevRepeater::~RevRepeater()
{
	cout<<"机读复·反 炸了"<<endl;
}



//普通函数
Repeater* CreateRepeater(int type)
{
    //根据type创建指定的复读机
	Repeater *p;
   	if(type==0)
   	{
   		p=new ForRepeater;
    }
   	else 
   	{
   		p=new RevRepeater;
   	
   	}
}

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

.cpp

#include "usr.h"

int main()
{
	int i;
	cin >> i;
    Repeater *ptr = CreateRepeater(i);
    ptr->Play();
    delete ptr;
}

计算图像面积

任务描述
本关任务：设计一个矩形类、一个圆形类和一个图形基类，计算并输出相应图形面积。

相关知识
为了完成本关任务，你需要掌握纯虚函数和抽象类的使用。

纯虚函数
有时在类中将某一成员声明为虚函数，并不是因为基类本身的要求，而是因为派生类的需求，在基类中预留一个函数名，具体功能留给派生类区定义。这种情况下就可以将这个纯虚函数声明为纯虚函数。即纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类对它进行定义。

纯虚函数就是在声明虚函数时被初始化为0的函数，但它只有名字，不具备函数功能，不能被调用，其一般形式是：

virtual 函数类型函数名（参数列表） = 0
纯虚函数没有函数体。最后的“=0”只是一种形式，告诉编译系统，它是一个纯虚函数，留在派生类中定义，并没有实际意义。

纯虚函数只有在派生类中定义了之后才能被调用。如果在一个类中声明了纯虚函数，而在派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数。

例如：

class Base
{
public:
virtual void Func() = 0; // 声明一个纯虚函数
};
抽象类
含有纯虚函数的类就成为抽象类。抽象类只是一种基本的数据类型，用户需要在这个基础上根据自己的需要定义处各种功能的派生类。

抽象类的作用就是为一个类族提供一个公共接口。抽象类不能定义对象，但是可以定义指向抽象类的指针变量，通过这个指针变量可以实现多态。

例如：

class Base
{
public:
virtual void Func() = 0; // 声明一个纯虚函数
};
class D1 : public Base {} // 什么也不做
class D2 : public Base
{
public:
void Func() override; // 重写纯虚函数
};
void D2::Func() { /* …… */ }
int main()
{
Base b = Base(); // 错误，Base 类是抽象类，不能定义对象。
Base *ptr1 = new D1(); // 错误，D1 没有重写 Base 类的 Func 函数，所以也是抽象类。
Base *ptr2 = new D2(); //正确
}
编程要求
在右侧编辑器中的Begin-End之间补充代码，设计图像基类、矩形类和圆形类三个类，函数成员变量据情况自己拟定，其他要求如下：

图形类（ shape ）

纯虚函数：void PrintArea()，用于输出当前图形的面积。
矩形类（ Rectangle ）

继承 Shape 类，并且重写 PrintArea 函数，输出矩形的面积，输出格式为：矩形面积 = width*height。

带参构造函数：Rectangle(float w,float h)，这两个参数分别赋值给成员变量的宽、高。

圆形类（ Circle ）

继承 Shape 类，并且重写 PrintArea 函数，输出圆形的面积，输出格式为：圆形面积 = radio * radio * 3.14。

带参构造函数：Circle(float r)，参数 r 代表圆的半径。

#include <iostream>
using namespace std;

/********* Begin *********/
class Shape
{
	//基类的声明
public:
	virtual void PrintArea() = 0;
    
    
};

class Rectangle : public Shape
{
	//矩形类的声明
public:
	float H,W;
	void PrintArea();
	Rectangle(float w,float h);
    
    
};
//矩形类的定义
void Rectangle::PrintArea()
{
	cout<<"矩形面积 = "<<H*W<<endl;
}

Rectangle::Rectangle(float w,float h)
{
	W = w;
	H = h;
}



class Circle : public Shape
{
	//圆形类的声明
public:
	float R;
	void PrintArea();
	Circle(float r);
    
};

void Circle::PrintArea()
{
	cout<<"圆形面积 = "<<3.14*R*R<<endl;
}

Circle::Circle(float r)
{
	R=r;
}
//圆形类的定义



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

.cpp

#include "usr.h"

int main()
{
	int i,j;
	cin >> i >> j;
    Shape *ptr = new Rectangle(i,j);
    ptr->PrintArea();
    delete ptr;

    ptr = new Circle(i);
    ptr->PrintArea();
    delete ptr;
}

念去去~

关注

15
点赞
踩
47

收藏

觉得还不错? 一键收藏
3
评论
C++面向对象 - 继承、派生和多态

公有继承 —— 学生信息类任务描述本关任务：采用公有继承设计学生信息类。相关知识继承继承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。C++ 中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，基类是对派生类的抽象，派生类是对基类的具体化。它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。继承方式不同的继承方式决定了基类成
复制链接

扫一扫

专栏目录