面向对象作业试题——2018-12-04与12-11

1	(3分)B类只有一个整型数成员，它同时是B1类和B2类的虚基类，B1、B2类均派生出一个新的整型数成员，C类公有继承B1、B2类，同时派生出一个新的整型数成员。D类公有继承B类、C类，无新派生成员。那么，一个D类对象的内存空间大小是多少字节？（一个整形数变量在内存中占32位）
‍	24
‍	20
‍	16
‍	12

2	(3分)含有子对象的派生类对象，构造时函数执行的正确顺序是：
‍	基类构造函数、派生类构造函数、子对象构造函数
‍	基类构造函数、子对象构造函数、派生类构造函数
‍	子对象构造函数、派生类构造函数、基类构造函数
‍	派生类构造函数、子类构造函数、基类构造函数

3	(3分)关于基类成员在派生类中的访问权限，下列描述不正确的是：
‍	在公有继承方式下，基类中保护成员在派生类中仍为保护成员。
‍	在保护继承方式下，基类中保护成员在派生类中转为公有成员。
‍	基类中的私有成员无论哪种继承方式在派生类中都是不能直接访问的。
‍	在私有继承方式下，基类中保护成员在派生类中转为私有成员。

4	(3分)使用成员函数重载运算符的限制是：
‍	左操作数必须是当前类的对象
‍	右操作数必须是当前类的对象
‍	左右操作数都必须是当前类的对象
‍	对操作数没有限制

5	(3分)下列关于虚函数及联编的说法中，正确的是：
‍	静态联编比动态联编更加灵活
‍	通过基类指针无法获得运行时多态
‍	静态联编比动态联编执行效率更高
‍	只有通过派生类对象指针才能获得运行时多态

6	(3分)下列函数声明中，无法实现主调函数中变量值交换的是
‍	int Swap(int *, int *);
‍	int Swap(int &, int &);
‍	int Swap(int *, int &);
‍	int Swap(int , int );

7	(3分)下列哪一项具有对当前类私有成员的访问权限
‍	当前类的对象
‍	派生类对象引用
‍	当前类的成员函数
‍	基类指针

8	(3分)C++语言实现的多态性包括编译时多态和运行时多态，以下选项中，实现多态性方式与其他选项不同的是：
‍	函数重载
‍	模板
‍	虚函数
‍	运算符重载

9	(3分)以下情形中，不会出现二义性问题的是：
‍	多个函数具有相同函数名，但返回值类型不同
‍	多个函数具有相同函数名，但形参类型不同
‍	继承多个基类，不同基类中具有相同成员名
‍	继承多个基类，而基类中有多个基类由同一个类派生而来

10	(3分)C++中，运算符重载具有成员函数重载和全局友元函数重载两种方式，通常情况下，大部分运算符两种方式重载均可以，但在某些特殊情况下只能采用其中的某一种方式重载，下列运算符中不属于上述特殊情况的是：
‍	下标运算符
‍	逻辑运算符
‍	赋值运算符
‍	输入/输出运算符

 

1、典型运算符重载之集合类填空

试题描述

   定义集合Gather类，编写必要的构造函数，且重载加法运算符函数（实现集合并运算）、减法运算符函数（实现集合差运算）、输出运算符友元函数。请仔细阅读下面的代码，并填写空白。
   ①    //必要的头文件等，可能为多条语句
   ②    //定义类Gather
{
   protected:
      int m_data[100]; //数据成员
      int m_count; //集合元素个数

      ③   
         ④    //定义默认构造函数，函数体中调用Clear()函数

         ⑤    //清空集合函数Clear()，函数体中设置m_count为0

         ⑥    //定义返回集合元素个数函数int GetCount()，函数体中返回m_count

         ⑦    //定义集合元素位置函数int Find()，函数只有一个参数，即要查找的元素值。元素位置从0开始，找不到则返回-1。

         ⑧    //定义加入集合元素函数Add()，函数只有一个参数，即要加入集合的元素值。如果该元素在集合中已经存在，则返回false；否则加入该元素，并返回true。

         ⑨    //定义移出集合元素函数Remove()，函数只有一个参数，即要移出集合的元素值。如果该元素在集合中不存在，则返回false；否则移出该元素，并返回true。

         ⑩    //重载加号运算符，代表集合并运算，函数只有一个参数，即Gather类型集合g2对象的常引用。

         ⑪    //重载减法运算符，代表集合差运算，函数只有一个参数，即Gather类型集合g2对象的常引用。

         ⑫    //输出运算符<<重载友元函数，函数有两个参数，即ostream类型dout的引用、Gather类型集合g对象的常引用。
};
int main()
{
      ⑬    //创建Gather对象g1和g2
   int x, y, a, b;
      ⑭    //输入整数x和y，然后将[x, y]之间的所有整数放入集合g1中

      ⑮    //调用默认赋值运算符重载函数，将g1赋给g2
   cout << "集合g2内容如下：" << g2 << endl; //调用输出运算符重载函数

      ⑯    //调用默认拷贝构造函数，将g1赋给g3

   cin >> x >> y >> a >> b;
      ⑰    //从g3中移走集合元素函数x，y
      ⑱    //加入a和b到集合g3中

   cout << "集合g3内容如下：" << g3 << endl;
   cout << "集合g2与g3的差：" << g2 - g3 << endl;
   cout << "集合g2与g3的合：" << g2 + g3 << endl;
   return 0;
}
   注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

输入

   输入六个整数，相邻两项之间用一个空格隔开。

输出

   依据题意输出若干行。

输入示例

   1 5 2 4 6 7

输出示例

   集合g2内容如下：(1,2,3,4,5)
   集合g3内容如下：(1,3,5,6,7)
   集合g2与g3的差：(2,4)
   集合g2与g3的合：(1,2,3,4,5,6,7)

数据范围

   输入为int范围的整数

#include<iostream>
#include<iomanip>
#include<string>
#include<cmath>
using namespace std;   
class Gather{ 
   protected: 
      int m_data[100]; //数据成员 
      int m_count; //集合元素个数 
	public:
		Gather(){
			Clear();
		}
//         ④    //定义默认构造函数，函数体中调用Clear()函数 
		void Clear(){
			m_count=0;
		}
//         ⑤    //清空集合函数Clear()，函数体中设置m_count为0 
		int GetCount()const{
			return m_count;
		}
//         ⑥    //定义返回集合元素个数函数int GetCount()，函数体中返回m_count 
		int Find(int e){
			for(int i=0;i<m_count;i++){
				if(m_data[i]==e){
					return i;
				}
			}
			return -1;
		}
//         ⑦    //定义集合元素位置函数int Find()，函数只有一个参数，即要查找的元素值。元素位置从0开始，找不到则返回-1。 
		bool Add(int e){
			int pos=Find(e);
			if(pos!=-1){
				return false;
			}
			m_data[m_count++]=e;
			return true;
		}
//         ⑧    //定义加入集合元素函数Add()，函数只有一个参数，即要加入集合的元素值。如果该元素在集合中已经存在，则返回false；否则加入该元素，并返回true。 
		bool Remove(int e){
			int pos=Find(e);
			if(pos==-1)
				return false;
			for(int i=pos+1;i<m_count;i++){
				m_data[i-1]=m_data[i];
			}
			m_count--;
			return true;	
		}
//         ⑨    //定义移出集合元素函数Remove()，函数只有一个参数，即要移出集合的元素值。如果该元素在集合中不存在，则返回false；否则移出该元素，并返回true。 
		Gather operator+(const Gather &g2){
			Gather tmp=*this;
			int len=g2.GetCount();
			for(int i=0;i<len;i++){
				tmp.Add(g2.m_data[i]);
			}			
			return tmp;
		}
//         ⑩    //重载加号运算符，代表集合并运算，函数只有一个参数，即Gather类型集合g2对象的常引用。 
		Gather operator-(const Gather &g2){
			Gather tmp=*this;
			int len=g2.GetCount();
			for(int i=0;i<len;i++){
				tmp.Remove(g2.m_data[i]);
			}
			return tmp;
		}
//         ?    //重载减法运算符，代表集合差运算，函数只有一个参数，即Gather类型集合g2对象的常引用。 
		friend ostream& operator<<(ostream &dout,const Gather &g){
			dout<<"(";
			int len=g.GetCount();
			for(int i=0;i<len;i++){
				if(i==0){
					dout<<g.m_data[i];
				}
				else{
					dout<<","<<g.m_data[i];
				}
			}
			dout<<")";
			return dout; 
		}
//         ?    //输出运算符<<重载友元函数，函数有两个参数，即ostream类型dout的引用、Gather类型集合g对象的常引用。 
}; 
int main() 
{
	Gather g1,g2;
//      ?    //创建Gather对象g1和g2 
   int x, y, a, b; 
   cin>>x>>y;
   for(int i=x;i<=y;i++){
   		g1.Add(i);
   }
//      ?    //输入整数x和y，然后将[x, y]之间的所有整数放入集合g1中 
	g2=g1;
//      ?    //调用默认赋值运算符重载函数，将g1赋给g2 
   cout << "集合g2内容如下：" << g2 << endl; //调用输出运算符重载函数 
	Gather g3=g1;
//      ?    //调用默认拷贝构造函数，将g1赋给g3 

   cin >> x >> y >> a >> b; 
//      ?    //从g3中移走集合元素函数x，y 
//      ?    //加入a和b到集合g3中 
	g3.Remove(x);
	g3.Remove(y);
	g3.Add(a);
	g3.Add(b);
   cout << "集合g3内容如下：" << g3 << endl; 
   cout << "集合g2与g3的差：" << g2 - g3 << endl; 
   cout << "集合g2与g3的合：" << g2 + g3 << endl; 
   return 0; 
}