面向对象程序设计|继承

题目一：OOP多边形周长计算（单继承）

题目描述：

给出下面的多边形基类框架：

class polygon

{ 

protected:

   int number;//边数，最多不超过100条边

private:

   int side_length[100];//边长数组

public:

   polygon();//构造函数根据需要重载

   int perimeter();//计算多边形边长

   void display();//输出多边形边数和周长

}

建立一个派生类rectangle(矩形)，增加以下数据成员：

  int height;

  int width;

增加以下成员函数：

 rectangle类的无参和参数化构造函数

 int perimeter();//计算矩形边长

 void display();//输出多边形边数和周长

建立一个派生类equal_polygon(等边多边形)，增加以下数据成员：

 int side_len;

增加以下成员函数：

// equal_polygon类的无参和参数化构造函数

 int perimeter();//计算等边多边形边长

 void display();//输出多边形边数和周长

生成上述类并编写主函数，根据输入的多边形信息，相应建立一个多边形类对象或矩形类对象或等边多边形类对象，计算每一个多边形的周长并且输出其边数和周长。

输入要求：

测试输入包含一个测试用例，该测试用例的第一行输入多边形的个数n，

接下来n行每一行给出一个多边形的基本信息，每行的第一个数字为当前多边形的类型：

类型0为一般多边形，后面跟随m个数字为m条边的边长，-1为一般多边形边长输入结束标志，

类型1为矩形，后面跟随两个数字，分别为height和width

类型2为等边多边形，后面跟随两个数字为等边多边形的边数和边长。

输出要求：

每行输出多边形的边数以及周长

输入样例：

3
0 32 54 76 88 24 -1
1 32 54
2 3 32

输出样例：

5 274
4 172
3 96

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

int array[100] = { 0 };

class polygon
{
protected:
	int number;
private:
	int side_length[100];
public:
	polygon() {}
	polygon(int arr[], int num) :number(num)
	{
		for (int i = 0; i < num; i++)
		{
			side_length[i] = arr[i];
		}
	}
	int perimeter()
	{
		int sumlenth = 0;
		for (int i = 0; i < number; i++)
		{
			sumlenth += side_length[i];
		}
		return sumlenth;
	}
	void display()
	{
		cout << number << " " << this->perimeter() << endl;
	}
};

class rectangle :public polygon
{
protected:
	int height;
	int width;
public:
	rectangle() {}
	rectangle(int xval, int yval, int array[]) :polygon(array, 4), height(xval), width(yval) {}
	int perimeter() { return 2 * (height + width); }
	void display()
	{
		cout << number << " " << this->perimeter() << endl;
	}
};

class equal_polygon :public polygon
{
protected:
	int side_len;
public:
	equal_polygon() {}
	equal_polygon(int num, int len, int array[]) :polygon(array, num), side_len(len) {}
	int perimeter()
	{ return number * side_len; }
	void display()
	{
		cout << number << " " << this->perimeter() << endl;
	}
};

int main()
{
	int array[100] = { 0 };//数组初始化为0的一种方式
	int t;
	cin >> t;
	while (t--)
	{
		int sign;
		cin >> sign;
		if (sign == 0)
		{
			int count = 0;
			int xlen[100];
			while (1)
			{
				cin >> xlen[count];
				if (xlen[count] != -1)
				{
					count++;
				}
				else
				{
					break;
				}
			}
			polygon p0(xlen, count);
			p0.display();
		}
		else if (sign == 1)
		{
			int x, y;
			cin >> x >> y;
			rectangle r(x, y, array);
			r.display();
		}
		else if (sign == 2)
		{
			int n, x;
			cin >> n >> x;
			equal_polygon e(n, x, array);
			e.display();
		}
	}
}

代码没啥技术含量，也不知道为啥放这儿

题目二：OOP书籍信息记录（单继承）

题目描述：

定义一个 Document 类, 其拥有数据成员 name (字符串类型), 并其拥有方法 Print 输出 name。

Document类的构造函数和析构函数都有相应输出，具体请看样例

从 Document 派生出 Book 类，增加数据成员 pageCount (int 类型), 其重载了方法 Print，输出name和页数

Book类的构造函数和析构函数都有相应输出，具体请看样例

主函数创建一个Book类对象，并调用方法Print输出。

注意：

凡是Creat*******的输出信息，均由构造函数自动输出，不能显式调用函数或者在主函数显式语句输出

凡是Delete******的输出信息，均由析构函数自动输出，不能显式调用函数或者在主函数显式语句输出

输入要求：

属于一行，一个字符串和一个整数， 分别表示书名和页数。

输出要求：

调用Print方法输出对象信息（其它构造与析构过程中的输出信息详见样例）

输入样例：

ABC 123

输出样例：

Create Document Class
Create Book Class
Document Name is ABC
PageCount is 123
Delete Book Class
Delete Document Class

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Document
{
public:
	Document()
	{
		cout << "Create Document Class" << endl;
	}
	Document(string name0) :name(name0) {}
	~Document()
	{
		cout << "Delete Document Class" << endl;
	}
	void print()
	{
		cout << "Document Name is " << name << endl;
	}
protected:
	string name;
};

class Book :public Document
{
public:
	Book()
	{
		cout << "Create Book Class" << endl;
	}
	Book(string na, int pc) :Document(na), pageCount(pc) {}
	~Book()
	{
		cout << "Delete Book Class" << endl;
	}
	void print()
	{
		cout << "Document Name is " << name << endl;
		cout << "PageCount is " << pageCount << endl;
	}
private:
	int pageCount;
};

int main()
{
	string bkname;
	int bkpage;
	cin >> bkname >> bkpage;
	Book* s = new Book;
	s = new Book(bkname, bkpage);//动态内存分配的构造方式
	s->print();
	delete s;
	return 0;
}

一个小知识点，注意一下！

题目三：班级学生平均成绩计算（继承）

题目描述：

定义Person类具有姓名、年龄等属性，具有输出基本信息的display函数。

选修《面向对象程序设计》课程的学生是在Person类的基础上，派生出的子类：学生类。子类继承父类成员，新增其他成员、改写display函数。

1.学生类具有平时成绩、考试成绩和总评成绩三个属性，

2.计算总评成绩的函数，总评成绩=平时成绩*40%+考试成绩*60%。

3.新的display函数

教授《面向对象程序设计》课程的老师是在Person类的基础上，派生出的子类：教师类。子类继承父类成员，新增其他成员、改写display函数。

1.增加选课学生数组、选课人数、班级平均分三个属性

2.在选课学生数组中增加一个学生的函数

3.计算班级学生平均分的函数

4.新的display函数

定义上述类并编写主函数，首先建立一个教师类对象，随后将n个学生类对象加入教师类对象的选课学生数组中。计算该教师教授班级学生的平均成绩，并输出。

输入要求：

教师类对象基本信息

选课人数n

随后每行输入学生类对象相关信息

输出要求：

教师类对象信息

所有选课学生信息

输入样例：

Cindy 18
2
Sandy 8 90 80
David 9 60 70

输出样例：

Cindy 18 2 75.00
Sandy 8 84.00
David 9 66.00

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Person
{
public:
	Person() {}
	Person(string na0, int age0) :name(na0), age(age0) {}
protected:
	string name;
	int age;
};

class Student :public Person
{
public:
	Student() {}
	Student(string na0, int age0, double sc1, double sc2) :Person(na0, age0), scoreusual(sc1), scoretest(sc2)
	{
		score = 0.4 * sc1 + 0.6 * sc2;
	}
	double getScore(){ return score; }
	void display()
	{
		cout << name << " " << age << " ";
		cout << fixed << setprecision(2) << score << endl;
	}
protected:
	double scoreusual, scoretest, score;
};

class Teacher :public Person
{
public:
	Teacher() {}
	Teacher(string na0, int age0) :Person(na0, age0) {}
	void display()
	{
		cout << name << " " << age << " " << total << " ";
		cout << fixed << setprecision(2) << average << endl;
		for (int i = 0; i < total; i++)
		{
			s[i].display();
		}
	}
	void setStudent(int n)
	{
		total = n;
		double sum = 0;
		string na;
		int agestu;
		double sc1, sc2;
		s = new Student[n];
		for (int i = 0; i < n; i++)
		{
			cin >> na >> agestu >> sc1 >> sc2;
			s[i] = Student(na, agestu, sc1, sc2);//动态内存分配方式
			sum += s[i].getScore();
		}
		average = sum / n;
	}
protected:
	int total;
	double average;
	Student* s;
};

int main()
{
	string tname;
	int tage;
	cin >> tname >> tage;
	Teacher t(tname, tage);
	int n;
	cin >> n;
	t.setStudent(n);
	t.display();
	return 0;
}

也是一个小知识点，记住！

题目四：OOP教师与干部（多重继承）

题目描述：

分别声明Teacher(教师)类和Cadre(干部)类，采用多重继承方式由这两个类派生出新类Teacher_Cadre(教师兼干部)类。要求： 

(1) 在两个基类中都包含姓名、年龄、性别、地址、电话等数据成员。

(2) 在Teacher类中还包含数据成员title(职称)，在Cadre类中还包含数据成员post(职务)。在Teacher_Cadre类中还包含数据成员wages(工资)。

(3) 对两个基类中的姓名、年龄、性别、地址、电话等数据成员用相同的名字，在引用这些数据成员时，指定作用域。

(4)  在类体中声明成员函数，在类外定义成员函数。

(5) 在派生类Teacher_Cadre的成员函数show中调用Teacher类中的display函数，输出姓名、年龄、性别、职称、地址、电话，然后再用cout语句输出职务与工资。

输入要求：

依次输入姓名、年龄、性别、职称、职务、地址、电话、工资

输出要求：

依次输出入姓名、年龄、性别、职称、职务、地址、电话、工资

输入样例：

Wang-li 50 f prof. president
135 Beijing Road,Shanghai
(021)61234567 1534.5

输出样例：

name:Wang-li
age:50
sex:f
title:prof.
address:135 Beijing Road,Shanghai
tel:(021)61234567
post:president
wages:1534.5

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Teacher
{
public:
	Teacher() {}
	Teacher(string nn, int ag0, string se0, string tt0, string ad0, string tel0);
	void display();
protected:
	string name, sex, adress, tel, title;
	int age;
};

class Cadre
{
public:
	Cadre() {}
	Cadre(string nn, int ag0, string se0, string po0, string ad0, string tel0);
	void display();
protected:
	string name, sex, adress, tel, post;
	int age;
};

class Teacher_Cadre :public Teacher, public Cadre
{
public:
	Teacher_Cadre() {}
	Teacher_Cadre(string nn, int ag0, string se0, string tt0, string po0, string ad0, string tel0, double wage0);
	void show();
protected:
	double wages;
};


Teacher::Teacher(string nn, int ag0, string se0, string tt0, string ad0, string tel0) :name(nn), age(ag0), sex(se0), title(tt0), adress(ad0), tel(tel0) {}

void Teacher::display()
{
	cout << "name:" << name << endl;
	cout << "age:" << age << endl;
	cout << "sex:" << sex << endl;
	cout << "title:" << title << endl;
	cout << "address:" << adress << endl;
	cout << "tel:" << tel << endl;
}

Cadre::Cadre(string nn, int ag0, string se0, string po0, string ad0, string tel0) :name(nn), age(ag0), sex(se0), post(po0), adress(ad0), tel(tel0) {}

void Cadre::display()
{
	cout << "post:" << post << endl;
}

Teacher_Cadre::Teacher_Cadre(string nn, int ag0, string se0, string tt0, string po0, string ad0, string tel0, double wage0) :Teacher(nn, ag0, se0, tt0, ad0, tel0), Cadre(nn, ag0, se0, po0, ad0, tel0), wages(wage0) {}

void Teacher_Cadre::show()
{
	Teacher::display();
	Cadre::display();
	cout << "wages:" << wages << endl;
}

int main()
{
	string na, se, tt, po, ad, tel;
	int ag;
	double wage;
	cin >> na >> ag >> se >> tt >> po;
	char ch = getchar();//清空缓存区
	getline(cin, ad);//string中可以输入空格“ ”
	cin >> tel >> wage;
	Teacher_Cadre tc(na, ag, se, tt, po, ad, tel, wage);
	tc.show();
	return 0;
}

注意如何在string类型的变量中输入空格，用getline(cin, 变量名)，注意如果前面有输入要清空缓存区的数据（一般是回车）。

题目五：日程安排（多继承+友元函数）

题目描述：

已有一个日期类Date，包括三个protected成员数据year，month，day;

另有一个时间类Time，包括三个protected成员数据hour，minute，second，12小时制;

现需根据输入的日程的日期时间，安排前后顺序，为此以Date类和Time类为基类，建立一个日程类Schedule，包括以下新增成员：

int ID；//日程的ID

定义友元函数bool before(const Schedule & s1，const Schedule & s2);//判断日程s1时间是否早于日程s2。

编写主函数，根据输入的各项日程信息，建立日程对象，找出需要最早安排的日程(日期和时间相等时，输出较早建立的日程），并输出该日程对象的信息。

输入要求：

测试输入包含若干日程，每个日程占一行（日程ID、日程日期、日程时间）。

当读入0时输入结束，相应的结果不要输出。

输出要求：

时间最靠前的日程

输入样例：

1 2019 6 27 8 0 1
2 2019 6 28 8 0 1
3 2020 1 1 8 0 0
0

输出样例：

The urgent schedule is No.1: 2019/06/27 08:00:01

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Date
{
public:
	Date() {}
	Date(int a, int b, int c) :year(a), month(b), day(c) {}
protected:
	int year, month, day;
};

class Time
{
public:
	Time() {}
	Time(int d, int e, int f) :hour(d), minute(e), second(f) {}
protected:
	int hour, minute, second;
};

class Schedule :public Date, public Time
{
public:
	Schedule() {}
	Schedule(int id, int a, int b, int c, int d, int e, int f) :Date(a, b, c), Time(d, e, f), ID(id) {}
	friend bool before(const Schedule& s1, const Schedule& s2);
	void display()
	{
		cout << "The urgent schedule is No." << ID << ": " << year << "/";
		cout << setw(2) << setfill('0') << month << "/";
		cout << setw(2) << setfill('0') << day << " ";
		cout << setw(2) << setfill('0') << hour << ":";
		cout << setw(2) << setfill('0') << minute << ":";
		cout << setw(2) << setfill('0') << second << endl;
	}
protected:
	int ID;
};

bool before(const Schedule& s1, const Schedule& s2)
{
	if (s1.year < s2.year)
	{
		return true;
	}
	else if (s1.year == s2.year)
	{
		if (s1.month < s2.month)
		{
			return true;
		}
		else if (s1.month == s2.month)
		{
			if (s1.day < s2.day)
			{
				return true;
			}
			else if (s1.day == s2.day)
			{
				if (s1.hour < s2.hour)
				{
					return true;
				}
				else if (s1.hour == s2.hour)
				{
					if (s1.minute < s2.minute)
					{
						return true;
					}
					else if (s1.minute == s2.minute)
					{
						if (s1.second < s2.second)
						{
							return true;
						}
						else
						{
							return false;
						}
					}
					else
					{
						return false;
					}
				}
				else
				{
					return false;
				}
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

int main()
{
	int n;
	Schedule u0(0, 9999, 12, 31, 23, 59, 59);
	while (1)
	{
		cin >> n;
		if (n == 0)
		{
			break;
		}
		else
		{
			int a, b, c, d, e, f;
			cin >> a >> b >> c >> d >> e >> f;
			Schedule s(n, a, b, c, d, e, f);
			if (before(s, u0))
			{
				u0 = s;
			}
		}
	}
	u0.display();
	return 0;
}

题目六：OOP 谁是名人堂球员（多重继承）

题目描述：

1. 建立如下的类继承结构：

• 一个球员类Player作为基类，具有name、height、weight等数据成员，display()等成员函数
• 从Player类派生出最有价值球员类MVP，添加属性：获奖年year
• 从Player类派生出最佳防守球员类DPOY，添加属性：获奖年year
• 从MVP和DPOY派生出名人堂类HallOfFame

2. 分别定义以上类的构造函数、输出函数display及其他函数（如需要）。

3. 在主函数中定义各种类的对象，并测试之，通过对象调用display函数产生输出。

输入要求：

第一行输入球员的名字，身高，体重

第二行输入MVP获奖年

第三行输入DPOY获奖年

输出要求：

构造四个类对象，并按照如下格式进行输出。

输入样例：

Michael 198 96
2010
2011

输出样例：

Player:
name:Michael
height:198
weight:96

MVP:
name:Michael
height:198
weight:96
reward:win the MVP reward in 2010

DPOY:
name:Michael
height:198
weight:96
reward:win the DPOY reward in 2011

Hall of fame:
name:Michael
height:198
weight:96
reward1:win the MVP reward in 2010
reward2:win the DPOY reward in 2011

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Player
{
protected:
	string name;
	int weight, height;
public:
	Player() {}
	Player(string nn, int hh, int ww) :name(nn), weight(ww), height(hh) {}
	void display()
	{
		cout << "Player:" << endl;
		cout << "name:" << name << endl;
		cout << "height:" << height << endl;
		cout << "weight:" << weight << endl;
	}
};


class MVP :virtual public Player
{
protected:
	int year;
public:
	MVP() {}
	MVP(string nn, int hh, int ww, int yy) :Player(nn, hh, ww), year(yy) {}
	void display()
	{
		cout << "MVP:" << endl;
		cout << "name:" << name << endl;
		cout << "height:" << height << endl;
		cout << "weight:" << weight << endl;
		cout << "reward:win the MVP reward in " << year << endl;
	}
};

class DPOY :virtual public Player
{
protected:
	int yeard;
public:
	DPOY() {}
	DPOY(string nn, int hh, int ww, int yd) :Player(nn, hh, ww), yeard(yd) {};
	void display()
	{
		cout << "DPOY:" << endl;
		cout << "name:" << name << endl;
		cout << "height:" << height << endl;
		cout << "weight:" << weight << endl;
		cout << "reward:win the DPOY reward in " << yeard << endl;
	}
};

class HallOfFame :public MVP, public DPOY
{
protected:
	bool state;
public:
	HallOfFame() {}
	HallOfFame(string nn, int hh, int ww, int yy, int yd) :Player(nn, hh, ww), MVP(nn, hh, ww, yy), DPOY(nn, hh, ww, yd) {}
	void display()
	{
		cout << "Hall of fame:" << endl;
		cout << "name:" << name << endl;
		cout << "height:" << height << endl;
		cout << "weight:" << weight << endl;
		cout << "reward1:win the MVP reward in " << year << endl;
		cout << "reward2:win the DPOY reward in " << yeard << endl;
	}
};

int main()
{
	string na;
	int ht, wt, ym, yd;
	cin >> na >> ht >> wt >> ym >> yd;
	Player p(na, ht, wt);
	p.display();
	cout << endl;
	MVP m(na, ht, wt, ym);
	m.display();
	cout << endl;
	DPOY d(na, ht, wt, yd);
	d.display();
	cout << endl;
	HallOfFame h(na, ht, wt, ym, yd);
	h.display();
	return 0;
}

代码没什么难度，按部就班来，写快点就好……