【面向对象程序设计】| 期末考试题（笔试） | 2021年下学期江苏大学计算机学院C++科目

考试对象：计算机专业19级学生 + 软件工程专业19级学生
考试时间：2021年6月22号 9:00~11:00
考试要求：请勿携带一切与考试无关资料书籍以及电子设备进入考场

一、选择题
1.以下关于类和对象叙述错误的是（ C ）。
A）对象是类的一个实例
B）任何一个对象都归属于一个具体的类
C）一个类只能有一个对象
D）类与对象的关系和数据类型与变量的关系相似
2.在下列函数中，是类MyClass的析构函数的是（ C ）。
A）~Myclass(); B）MyClass();
C）~MyClass(); D）~MyClass(int n);
3.关于this指针的说法错误的是（ D ）。
A）this指针不能被显示说明 B）对象调用的成员函数中，this指向该对象
C）普通成员函数一般都拥有this指针 D）静态成员函数拥有this指针
4.下面有关new运算符的描述，错误的是（ B ）。
A）使用new运算符创建对象时，会调用类的构造函数
B）使用new运算符创建数组时，必须定义初始值
C）使用new运算符创建的对象可以使用delete运算符删除
D）new运算符可以用来动态创建对象和对象数组
5.下面关于时间类Time定义的说法中，正确的是（ D ）。
Time time1,time[30];
Time pTime;
Time &time2=time1;
A）time是一个数组，它具有30个元素
B）pTime就是指向Time类对象的指针
C）time2是一个类对象引用，定义时必须进行初始化，使之成为对象time1的别名
D）以上答案都正确
6.当不同的类具有相同的间接基类时，具有的特点是（ D ）。
A）各派生类对象中不存在基类版本
B）派生类对象无法产生自己的基类版本
C）为了建立唯一的间接基类版本，应该改变继承方式
D）为了建立唯一的间接基类版本，应该声明虚基类
7.如果表达式x+yz中，“+”是作为成员函数重载的运算符，“”是作为友元函数重载的运算符，下列叙述正确的是（ C ）。
A）operator +有两个参数，operator有两个参数
B）operator +有两个参数，operator有一个参数
C）operator +有一个参数，operator有两个参数
D）operator +有一个参数，operator*有一个参数
8.运算符表达式obj1>obj2重载为类的成员函数，被C++编译器解释为（ D ）。
A）operator>(obj1,obj2) B）>(obj1,obj2)
C）obj2.operator>(obj1) D）obj1.operator>(obj2)
9.实现运行时的多态性要使用（ D ）。
A）重载函数 B）构造函数 C）析构函数 D）虚函数
10.在派生类中重新定义虚函数时，除了（ D ），其他都必须与基类中相应的虚函数保持一致。
A）参数个数 B）参数类型 C）函数名 D）函数体
11. 用来说明类的友元的是（ D ）。
A）private B）protected C）public D）friend
12. 下列有关重载函数的说法中正确的是（ C ）
A）重载函数必须具有不同的返回值类型
B）重载函数参数个数必须相同
C）重载函数必须有不同的形参列表
D）重载函数名可以不同
13. 所谓动态多态性是指 （ B ）
A）不同的对象调用不同名称的函数
B）不同的对象调用相同名称的函数
C）一个对象调用不同名称的函数
D）一个对象调用不同名称的对象
14. 实现两个相同类型数加法的函数模板的声明是（ D ）
A）template add(T x,T y) B）template T add(x,y)
C）template T add(T x,y) D）template T add(T x,T y)
15. 以下基类中的成员函数表示纯虚函数的是（ A ）
A）virtual void tt()=0 B）void tt(int)=0
C）virtual void tt(int) D）virtual void tt(int){}
16. 在C++中，使用流进行输入输出，其中用于屏幕输入（ A ）
A）cin B）cerr C）cout D）clog
17. 下列虚基类的声明中正确的是（ D ）。
A）class virtual B:public A B）virtual class B:public A
C）class B:public A virtual D）class B: virtual public A
18. 下列关于虚基类的描述中，（ D ）是错误的。
A）虚基类的关键字是virtual
B）使用虚基类可以解决公共基类的二义性问题
C）虚基类能够解决公共基类只被初始化一次数据成员的问题
D）带有虚基类的派生类构造函数与不带有虚基类的派生类的构造函数没有区别
19. 在文件操作中，代表以追加方式打开文件的模式是（ B ）。
A）iso::ate B）iso::app C）iso::out D）iso::trunc
20. 下列关于read()函数的描述中，（ D ）是正确的。
A）是用来从键盘输入中读取字符串的
B）所读取的字符串长度是不受限制的
C）只能用于文件操作中
D）只能按规定读取指定数目的字符

二、是非题。描述正确请在圆括号中写T、错误写F。
1.（ T ）设p为指向一个动态对象的指针变量，则执行delete p;语句时，将自动调用该类的析构函数。
2.（ T ）假设有一个Test类，则执行“Test a(5),b[2],*p;”语句时，自动调用该类构造函数的次数为3次。
3.（ F ）一个类中可以定义多个构造函数和析构函数。
4.（ T ）类的静态数据成员的初始化在类外进行。
5.（ T ）若外界函数想直接访问类的私有数据成员，则必须把该函数声明为类的友元函数。
6.（ F ）如果一个类有两个或两个以上直接基类，则这种继承称为重复继承。
7.（ F ）在C++语言中，设置虚基类的目的是实现代码复用，通过关键字virtual来标识虚基类。
8.（ T ）继承具有传递性，即当基类本身也是某一类的派生类时，底层的派生类也会自动继承间接基类的成员。
9.（ F ）运算符表达式obj1>obj2重载为类的成员函数，被C++编译器解释为operator>(obj1,obj2)
10.（ T ）包含一个或多个纯虚函数的类称为抽象类。（同13题）
11.（ F ）假设有一个Test类，则执行“Test a(5),b[2],*p;”语句时，自动调用该类构造函数的次数为4次。（与与选择题10重）
12.（ F ）C++中，编译时的多态性要通过函数重载来实现，运行时的多态性要通过虚基类实现。
13.（ F ）包含一个或多个纯虚函数的类称为虚基类。
14.（ T ）模板可以实现程序设计中的代码重用，体现了面向对象程序设计的可重用性。
15.（ F ）一个基类可以有多个派生类，一个派生类只能有一个基类。
16.（ T ）派生类析构函数的执行顺序与构造函数的执行顺序相反。
17.（ T ）C++中的文件按存储格式可以分为两类，分别是文本文件和二进制文件。
18.（ T ）C++的流库预定义了cin、cout、clog 和cerr四个流类对象。
19.（ T ）假如一个类的名称为MyClass，使用这个类的一个对象初始化该类的另一个对象时，可以调用静态成员函数来完成此功能。
20.（ F ）对赋值运算符进行重载时，应声明为友元函数。
21.（ T ）函数模板实例化后是模板函数；类模板实例化后是模板类。

三、写出下列程序的运行结果
1.

#include 
using namespace std; 
class goods 
{ 
public: 
	goods(int w) { weight=w; totalweight+=weight; } 
	goods(goods &gd) { weight=gd.weight; totalweight+=weight; } 
	~goods() { totalweight-=weight; } 
	static int gettotal() { return totalweight; } 
private: 
	static int totalweight; 
	int weight; 
}; 
int goods::totalweight=0; 
int main()
{ 
	goods g1(5); 
	cout< 
 
 
5 15
 
 
 
#include
#include 
#include 
using namespace std;
class student
{   
char name[8];
int deg;
char level[7];
friend class process; // 说明友元类
public:
student(char na[],int d)
{ strcpy(name,na);
deg=d;
}
};
class process
{ public:
void trans(student &s)
{  int i=s.deg/10;
switch(i){
case 9:strcpy(s.level, "优");break;
case 8:strcpy(s.level,"良");break;
case 7:strcpy(s.level,"中");break;
case 6:strcpy(s.level,"及格");break;
default:strcpy(s.level,"不及格");
} }
void show(student &s)
{ cout< 

 3.
 
#include
using namespace std;
class base
{
public: 
	void disp(float f){cout< 
 
 
15
 
 
 
#include
using namespace std;
class base
{private:
int Y;
public:
base(int y=0) {Y=y;cout<<"base("< 
base(10)
 Derived(10,20)
 10 20
 ~Derived()
 ~base()
 
 
#include
using namespace std;
class point
{
public: 
	point(int i,int j) {x=i;y=j;}
	void print() {cout<<'('< 
 
 
(1,2) (3,4) (4,6) (-1,-2)
 
 
 
#include
using namespace std;
class example
{int a;
public:
example(int b=5){a=b++;}
void print(){a=a+1;cout < 
 
 
61
 
 
 
#include 
#include
using namespace std;
class B1
{
	public:
   		B1(int i)
             {    b1=i;
                 cout<<"constructor B1."<< i < 
 
 
constructor B2.2
 constructor B1.1
 constructor B1.5
 constructor B3.3
 constructor A.4
 1
 2
 4,3
 
 
四、程序填空题
 
 
 
假定一个D盘文件stu.dat中存有学生的序号、姓名、学号、年龄、性别、总成绩等数据，输出指定序号的学生数据。
 
 
//程序代码：
#include
#include
using namespace std;
class student
{
private:	
	 struct stud  
	 {
		int number;
		char name[20];
		char xuehao[20];		
		int age;
		char sex[4];
		int score;
	}srec;
public:
	void createfile();
    void outNumStu();
};
void student::createfile()
{
	ofstream outfile("D:\stu.dat",ios::trunc);
	if(!outfile)
	{
		cerr<<"open error!"<>srec.number>>srec.name>>srec.xuehao>>srec.age>>srec.sex>>srec.score;
                  （1）            ;//用write函数将学生数据写入文件
	}
	outfile.close();
}
void student::outNumStu()
{
	cout<<"请输入要查找学生的序号"<>ch2;
	               （2）           ;//以不创建方式打开读文件stu.dat
	infile.seekg(0);   
	while (infile.good())
	{
		            （3）                ;//以read方式读取一条学生记录
		cout<<"Number:"< 
 
 
(1) outfile.write((char*)&srec,sizeof(stud)) 
 (2) ifstream infile("D: stu.dat ",ios::nocreate);
 (3) infile.read((char*)&srec,sizeof(stud)); 
 (4) infile.close()
 
 
2.定义时间类Time。重载运算符“<<”和“>>”实现时间的输出和输入；重载运算符“+”、前缀“++”、后缀“++”函数实现时间计算；
 
 
#include 
using namespace std;
#include 
#include 
using namespace std;
class Clock	//时钟类声明
{
public:	//外部接口
	Clock(int NewH=0, int NewM=0, int NewS=0);
	void ShowTime();
	 Clock operator ++();  //前置单++目运算符重载
	      （5）         ;//后置++单目运算符重载
     Clock operator +(const Clock&m);//+运算符重载
   friend istream & operator >>(istream & in,Clock & t);
	friend ostream & operator <<(ostream & out,Clock &t );
private:	//私有数据成员
	int Hour, Minute, Second;
};
Clock::Clock(int  NewH , int  NewM , int  NewS )
{
	Hour = NewH;
	Minute = NewM;
	Second = NewS;
}
Clock & Clock:: operator ++()
{
	if (this->Second < 59)
		this->Second++;
	else if(this->Minute<59)//秒过60仅为到分
	{
		this->Minute++;
		this->Second = 0;
	}
	else if (this->Hour < 23)
	{
		this->Hour++;
		this->Second = 0;
		this->Minute = 0;
	}
	else
	{
		this->Hour = 0;
		this->Second = 0;
		this->Minute = 0;
	}
	          （6）         ；
}
Clock Clock:: operator++(int) 
{
	Clock c(*this);
	if (this->Second < 59)
		this->Second++;
	else if (this->Minute < 59)//秒过60仅为到分
	{
		this->Minute++;
		this->Second = 0;
	}
	else if (this->Hour < 23)
	{
		this->Hour++;
		this->Second = 0;
		this->Minute = 0;
	}
	else
	{
		this->Hour = 0;
		this->Second = 0;
		this->Minute = 0;
	}
	return c;
}
Clock Clock::operator + (const Clock& m)
{
	Clock c;
	int t = Hour * 3600 + Minute * 60 + Second,h;
	t += m.Hour * 3600 + m.Minute * 60 + m.Second;
	h = t / 3600;
	while (h >=24)
	{
		h -= 24;
	}
	c.Hour = h;
	c.Minute = t % 3600 / 60;
	c.Second = t % 3600 % 60;
	return c;
}
istream & operator >>(istream & in,Clock & t)
{ in>>t.Hour>>t.Minute>>t.Second;
         （7）      ;
}
 ostream & operator <<(ostream & out,Clock &t )
{  
                      （8）                    ；
//输出小时、分钟和秒并分别设置域宽为5
   return out;
}
int main()
{
	Clock c1,c2,c3;
	cin>>c1;
	cout<>c2;
	c3=++c2;
	cout< 
 
 
(5) Clock operator ++(int) 
 (6) return *this
 (7) return in 
 (8) out< 
 
template 
class ArrayList
{
public:
	ArrayList(int n);
	//ArrayList(int a[], int n);
	~ArrayList();
	ArrayList(const ArrayList& t);
	void addNum(T t);
	void show();
	ArrayList &operator=(const ArrayList& t);
	T & operator [ ](int i);
private:
	T * mArr;
	int maxSize;
	int mLen;
};
template 
ArrayList::ArrayList(const ArrayList& t)
{
	this->maxSize = t.maxSize;
	this->mLen = t.mLen;
	this->mArr = new T[maxSize];
	for (int i = 0; i < this->mLen; i++)
	this->mArr[i] = t.mArr[i];
}
template 
T & ArrayList::operator[](int i)
{
	return this->mArr[i];
}
template 
ArrayList  ArrayList::operator=(const ArrayList& t)
{
 	this->maxSize = t.maxSize;
	this->mLen = t.mLen;
	this->mArr = new T[maxSize];
	for (int i = 0; i < this->mLen; i++)
     		this->mArr[i] = t.mArr[i];
	return *this;
}
template 
ArrayList  ArrayList::operator=(const ArrayList& t)
{
 	this->maxSize = t.maxSize;
	this->mLen = t.mLen;
	this->mArr = new T[maxSize];
	for (int i = 0; i < this->mLen; i++)
     		this->mArr[i] = t.mArr[i];
	return *this;
}
 
 
 
4.编写一段程序，从键盘任意输入10个浮点数并存入二进制文件binary.dat中，从此二进制文件中读取数据并计算其总和与平均值。
 
 
#include
#include
using namespace std;
int main()
{
	ofstream outfile("binary.dat",ios::binary);
	if(!outfile)
	{  
		cerr<<"open test.dat error!"<>c[i];
		     （9）    ; 
	}
	outfile.close();
	           （10）            ;//以二进制读方式打开文件
    if(!infile)
	{
		cerr<<"open error";
		exit(1);
	}
	for(i=0;i<10;i++)
	{
		    （11）     ;//读取数据
		sum+=a[i];
	}
	      （12）        ;
	cout<<"总和:"< 
 
 
(9) outfile.write((char*)(&c[i]),sizeof(double)); 
 (10) ifstream infile(“binary.dat”,ios::binary)
 (11)infile.read((char*)(&a[i]),sizeof(double)); 
 (12) ave=sum/10
 
 
五、编程题
 一、定义日期时间类DateTime及火车票类，前者包括年/月/日/时/分/秒等信息，后者包括购票人姓名、车票号、价格、起点、终点、出发时间和到站时间。
 
二、多态性编程。某学校有3类员工：教师、行政人员、教师兼行政人员，共有的信息包括编号、姓名、性别和职工类别。工资计算方法如下：
 教师：基本工资+课时数×课时补贴。
 行政人员：基本工资+行政补贴。
 教师兼行政人员：基本工资+课时数×课时补贴+行政补贴。
 分析以上信息，定义人员抽象类，派生不同类型的员工，并完成工资的计算。
 
三、某超市商品销售如下所示，请编写程序，模拟商品销售过程，计算超市一天的销售额，利润，并输出销售额，利润和商品库存信息。
 
编号
品名
原库存
进价
售价
销售数量
1001
白菜
500
0.5
0.6
300
1002
萝卜
200
1.2
1.5
100
1003
牛奶
300
50
55
200
1004
毛巾
30
12
15
200
四、定义矩形类，能够求面积和周长
 
 
 
注：编程题老师未给出答案，博主自己写了上述四题的程序，并且在测试中均正确通过。