面向对象程序设计(打印)

1、一、填空题1. 面向对象系统的四个特性分别是抽象性继承性、封装性和多态性。2. 如果一个类至少有一个纯虚函数 , 那么该类被称为抽象类。3. 对于含有对象成员的派生类 , 其构造函数的执行顺序为：先执行基类构造函数、再执行子对象构造函数 , 最后执行派生类构造函数。4. 纯虚函数的声明格式为： virtual 函数类型函数名 ( 参数列表 )=0 。5. 运算符重载仍然保持原来的结合性、优先级和语法结构。6. 类型转换函数的作用是将一个类的对象转换成另一类型的数据。7. 静态联编支持的多态性称为编译时的多态性 , 也称静态多态性。8. 类中成员的三种访问权限分别是public 、private

2、和 protected 。9. 定义派生类时 , 系统默认的继承方式是 private 。10.C+允许在相同的作用域内以相同的名字定义几个不同实现的函数 , 称这种同一个函数名多种含义的现象为函数重载。11. 在 C+中 , 运行时的多态性主要通过虚函数和继承实现。12. 在一个函数的定义或声明前加上关键字 inline 时, 该函数就声明为内置函数。13. 派生类的成员包括从基类继承来的成员和自己增加的成员两大部分。14.cin称为 C+标准输入流。63.在 C+语言中 ,cout被称为 标准输出流。15. 在 C+语言中 , 用运算符 new动态建立对象 , 用运算符 delete 撤消

3、对象。16. 基类的构造函数和析构函数不能被派生类继承。17. 名称为 temp 的类的复制构造函数的原型声明语句为 temp(consttemp&s) 。18. 设置友元函数的目的是为了能够访问该类的私有成员和保护成员。19. 在 C+程序中 , 静态成员函数主要用来访问静态数据成员。20. 类模板是类的抽象 , 类是类模板的实例。21. 拷贝构造函数的形参必须是当前类对象的引用类型。22. 进行函数重载时 , 被重载的同名函数如果都没有用 const 修饰 , 则它们的形参个数不同或类型不同或个数和类型都不同。23. 在类中必须声明成员函数的原型 , 成员函数的实现部分可以写在类外

4、。24. 多态性是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。25. 在已有类的基础上新增自己的特性而产生新类的过程称为派生。26. 当用类的一个对象去初始化该类的另一个对象时系统自动调用复制构造函数实现赋值。27. 友元函数是在类声明中由关键字 friend 修饰说明的非成员函数 , 在它的函数体中能够通过对象名访问 private和 protected成员。28. 如果需要在某个类的声明之前 , 引用该类 , 则应进行前向引用声明。29. 对象是将数据及对数据的操作方法封装在一起 , 作为一个相互依存、不可分离的整体。30.C+中输出数据时 , 在标准输出流对象cout

5、 之后使用的运算符“ <<”称为流插入。31. 从系统实现角度看 , 多态性分为静态多态性和动态多态性。32. 基类的私有成员在派生类中是不可访问的。33. 对象空间的起始地址就是对象的指针。34. 对象与对象之间通过消息进行通讯。35.C+中用于定义模板的关键字是template 。36. 在 C+的类中包含两种成员 , 分别是数据成员和成员函数。37. 所谓函数模版 , 实际上是建立一个通用函数 , 其函数类型和形参类型不具体指定 , 用一个虚拟的类型来代表。38.C+为提高函数调用的效率 , 允许在编译时将所调用函数的代码嵌入到主函数中 , 这种嵌入到主函数的函数称为内置函数

6、。39. 类中有两种特殊的成员函数 , 分别是构造函数和析构函数。1/2740. 若要定义指向 Time 类对象 t1 的常指针 ptr, 其定义语句为： Time* const ptr=&t1。41. 如果函数的形参为类的对象 , 在调用函数时需要将实参对象完整地传递给形参对象 , 此时系统要调用复制构造函数来实现。42. 如果需要在同类的多个对象之间实现数据共享 , 但不用全局变量 , 可以用静态成员变量。43. 在 C+中 , 要访问类中的私有成员 , 可以使用成员函数和友元函数。44.C+中, 有四个运算符必须重载为类的成员函数 , 而不能重载为友元函数 , 这四个运算符分别是

7、： =,(),-> 。45. 若要实现两个复数类对象相加运算 , 并且满足交换律 , 要将“ +”重载为类的友元函数。46. 面向对象技术强调软件的可重用性 ,C+语言提供了类的继承机制 , 解决了软件重用问题。47.C+中允许一个派生类同时继承多个基类 , 这种行为称为多重继承。48. 声明虚基类命令的的一般形式为class派生类名 :virtual继承方式基类名。49. 只有公用继承才是基类真正的子类型。50. 动态多态性是在程序运行过程中才动态地确定操作所针对的对象 , 又称为运行时的多态性。51. 虚函数一定是类的成员函数。52. 静态成员函数没有 this 指针。53. 类中成

8、员默认的访问属性是 private 。54. 用关键字 inline 声明的函数称为内置函数。55. 若将两个复数相加运算符“ +”重载为类 complex 的成员函数 , 且函数的返回值为当前类的对象 , 其函数的原型声明语句为complex operator+(complex &)。56. 若用 op 代表 C+中任意一个允许重载的运算符 , 其重载函数名为 operator op 。57.C+中的模板分为类模板和函数模板。58. 具有封装性、继承性和多态性特点的程序设计称为面向对象的程序设计。59. 用已有对象复制一个新对象时要调用复制构造函数。60. 在基类中将show（无参数

9、）声明为返回整型数据的纯虚函数的语句格式为：virtualint show()=0。61. 在派生类中 , 对基类的继承方式可以有 public 、 private 和 protected 。62. 将双目运算符重载为某类的成员函数时 , 该成员函数的左操作数为当前对象（或 *this ） , 右操作数为函数参数。64. 若要访问类中的私有成员 , 除了可以利用成员函数外 , 还可以采用的友元函数的方式。65. 定义静态成员函数的目的是为了访问类中的静态数据成员。66. 要实现运行时的多态性要使用虚函数和继承。67. 派生类的成员来自两个途径 , 一种是派生类中定义的成员 , 另一种从基类继承

10、来的成员。68. 构造函数是一种特殊的成员函数 , 其作用是对类的数据成员进行初始化并执行对象的其他内部管理操作。69. 在类中定义和实现的函数称为成员函数。70.const成员函数只能引用本类中的数据成员, 而不以修改数据成员。71. 如果一个类中至少有一个纯虚函数 , 那么该类被称为抽象类。72.C+中用 static 声明的对象称为静态对象。73. 若有类名为 sample, 则其复制构造函数的原型声明语句为sample(const sample&)。二、选择题1设 int × =10, × +=3+× %(-3), 则× =_C_。A.1

11、5B. 11C. 14D.122下列运算符, 不能重载为友元函数的是_D_。A.<、 >、<=、 >=B.+ 、- 、+、-C. += 、 -=、*=、/=D. = 、（）、 、->2/273在 C+中 , 要实现动态联编, 必须使用 _B_调用虚函数A. 派生类指针B. 基类指针C.对象名D. 类名4若运算符“ >”被重载为类的成员函数 , 则表达式 obj1>obj2被 C+编译器解释为 _A_。A.obj1.operator>(obj2)B.obj2.operator>(obj1)C.operator>()D.>(obj1

12、,obj2)5对于语句 cout<< × <<endl 。中的各个组成部分, 下列叙述中错误的是 _B_。A. “ cout ”是一个输出流对象B. “ <<”称作流提取运算符C. “×”是一个变量D. “ endl ”的作用是输出回车换行6在下列函数原型中, 可以作为类 AA 构造函数的是 _B_。A. int AA （）。 B. AA （ int ）。 C.AA（ int） const 。 D.void AA （ int ）。7函数调用语句fun （ a+b,3,ma ×（ n-1,b）。中 , 实参的个数为 _D_A. 4

13、B.6C.5D. 38有关虚函数的说法不正确的是_B_。A.构造函数不能是虚函数B. 静态成员函数可以是虚函数C. 只有类的成员函数才能说明为虚函数D.析构函数可以是虚函数9逗号表达式 a=4,b=6,a-,b-,a+b的值为 _B_。A. 9B.8C.10D.610对于类中定义的成员 , 其隐含访问权限为 _B_A. publicB. privateC. staticD. protected11. 设置虚基类的目的是_C_。A. 简化程序B. 提高运行效率C. 消除二义性D. 减少目标代码12. 定义函数模板使用的关键字是_A_。A. templateB.inlineC. classD.op

14、erator13. 在 int b3=1,3,2,4,5,6,0。中 b22 的值是 _C_。A.0B.5C.6D.214. 友元的作用之一是 _B_。A. 增加成员函数的种类B. 提高程序的运行效率C. 实现数据的隐藏性D. 加强类的封装性15. 下列表示引用的方法中 ,_C_ 是正确的。已知： int m=10 。A. int &z。B.int &y=10。 C. int &×=m。D. float &t=&m。16. 通过指向对象的指针变量取成员的运算符是_C_。A.>>B.·C.->D.<<17.

15、 已知类 A 中一个成员函数说明如下：Void set(A &a)。其中 ,A &a 的含义是 _C_。A. 指向类 A的指针为aB. 将 a 的地址值赋给变量setC. a 是类 A 的对象引用 , 用来作为函数set （）的形参D. 变量 A 与 a 按位相与作为函数set （）的参数18. 带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数, 这样将对虚基类的子对象初始化次数_B_。A. 与虚基类下面的派生类个数有关B. 一次C. 二次D. 多次19. 下列函数中 ,_D_ 不能重载。A. 成员函数B.非成员函数C.构造函数D. 析构函数20. 关于

16、动态联编的下列描述中,_A_ 是错误的。A. 动态联编是在编译时确定操作函数的B. 动态联编是以虚函数为基础的3/27C. 动态联编是在运行时确定所调用的函数代码的D. 动态联编调用函数操作是用指向对象的指针或对象引用21. 下列运算符中 ,_D_ 运算符不能重载。A. &&B. newC. D. :22. 关于虚函数的描述中 ,_A_ 是正确的。A. 函数基类中说明了虚函数后, 派生类中将其对应的函数可不必说明为虚函数B. 虚函数是一个非成员函数C. 虚函数是一个 static 类型的成员D. 派生类的虚函数与基类的虚函数具有不同的参数个数和类型23. 下面关于对象的描述中

17、, 错误的是 _D_。A. 对象之间的信息传递是通过消息进行的B. 对象是类的实例C. 一个类可以定义多个对象D.对象是类的别名24. 下述静态数据成员的特性中 ,_C_ 是错误的。A. 说明静态数据成员时前边要加修饰符staticB. 引用静态数据成员时, 要在静态数据成员名前加<类名 >和作用域运算符C. 静态数据成员不是所有对象所共用的D. 静态数据成员要在类体外进行初始化25. 有关类的说法中 , 不正确的是 _D_。A. 类是一种用户定义的数据类型B. 类中的成员函数能够存取类中的私有数据C. 在类中 , 如果不作特别说明 , 所有的成员函数均为私有类型D. 在类中 ,

18、如果不作特别说明 , 所有的数据成员均为公有类型26.当一个派生类私有继承一个基类时, 基类中的所有公有成员和保护成员成为派生类的_C_。A. public 成员B. protected成员C. private成员D. 友元27.有如下类声明： class sample public:int mem。 。则 sample 类的成员 mem是 _B_A公有成员函数B公有数据成员C私有数据成员D私有成员函数28. 在 C+中 , 关于设置参数的默认值的描述中, 正确的是 _A_。A. 设置参数默认值时, 应该是先设置右边的再设置左边的B. 设置参数默认值只能在定义函数时设置C. 设置参数默认值时

19、, 应该全部参数都设置D. 不允许设置参数的默认值29. 函数模板的使用 , 实际上是将函数模板实例化成一个具体的_B_。A. 类B. 函数C.对象D. 模板类30. 在多重继承中, 公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则_A_。A. 完全相同B. 完全不同C.部分相同 , 部分不同 D. 以上都不对31. 下面关于对象概念的描述中,_C_ 是错误的。A. 对象是一个状态和操作( 或方法 ) 的封装体B. 对象代表着正在创建的系统中的一个实体C. 对象就是 C 语言中的结构体变量D. 对象之间的信息传递是通过消息进行的32. 继承机制的作用是_A_A定义新类B数据封装

20、C数据抽象D信息隐藏33. 有关析构函数的说法不正确的是_A_A. 析构函数不能是虚函数B. 析构函数无任何函数类型C. 析构函数没有形参D. 析构函数有且只有一个4/2734. 友元的作用之一是_C_A. 加强类的封装性B. 实现数据的隐藏性C. 提高程序的运行效率D.增加成员函数的种类35. 通常拷贝构造函数的参数是_B_。A. 本类对象名B. 本类对象的引用名C. 本类对象的成员名D.本类对象的指针名36. 如果在基类中将 show 声明为不带返回值的纯虚函数 , 正确的写法是 _C_。A.virtual show()=0。B.virtual void show()。C.virtual

21、void show()=0。D.void show=0 virtual。37. 下面关于友元的描述中 , 错误的是 _A_。A. 类与类之间的友元关系可以继承B. 一个类的友元类中的成员函数都是这个类的友元函数C. 友元函数可以访问该类的私有数据成员D. 友元可以提高程序的运行效率38.在 C+中 ,_B_ 运算符不能重载。A. +B. sizeofC.-D.<=39.下列关于运算符重载的描述中,_A_ 是正确的。A. 运算符重载不可以改变语法结构B. 运算符重载可以改变结合性C. 运算符重载可以改变优先级D.运算符重载可以改变操作数的个数40.当一个派生类保护继承一个基类时, 基类中的

22、所有公有成员和保护成员成为派生类的_B_。A.private 成员B. protected成员C. public 成员D. 友元41. 在声明类时 , 下面的说法正确的是 _B_。A. 可以在类的声明中给数据成员赋初值B.private,public,protected可以按任意顺序出现C. 数据成员的数据类型可以是registerD. 没有用 private,public,protected定义的数据成员是公有成员42. 有如下类声明：class Foo int bar。 。则 Foo 类的成员bar 是 _A_A私有数据成员B私有成员函数C公有数据成员D公有成员函数43. 设置虚基类的目的

23、是 _B_。A. 简化程序B. 消除二义性C.减少目标代码D. 提高运行效率44. 对虚函数的调用 _A_。A. 不一定使用动态联编B. 必须使用动态联编C. 一定使用动态联编D.一定使用静态联编45. 关于成员函数特征的下述描述中,_B_ 是错误的。A. 成员函数可以是静态的B. 成员函数一定是内置函数C. 成员函数可以设置参数的默认值D.成员函数可以重载46类的成员函数不包括 _C_。A构造函数B. 析构函数C.友元函数D. 拷贝构造函数47. 继承具有 _A_, 即当基类本身也是某一个类的派生类时 , 底层的派生类也会自动继承间接基类的成员。A. 传递性B. 规律性C.重复性D. 多样性

24、48若运算符“ >”被重载为类的友元函数, 则表达式 obj1>obj2被 C+编译器解释为 _C_。A.>(obj1,obj2)B.obj1.operator>(obj2)C.operator>(obj1,obj2)D.operator>()49下面关于友元的描述中, 错误的是 _C_。A. 友元函数可以访问该类的私有数据成员5/27B. 友元可以提高程序的运行效率C. 类与类之间的友元关系可以继承D. 一个类的友元类中的成员函数都是这个类的友元函数50有关构造函数的说法不正确的是_C_。A. 构造函数名字和类的名字一样B. 构造函数无任何函数类型C. 构

25、造函数有且只有一个D.构造函数在说明类的某个对象时自动执行51设 n=8,i=4,则赋值运算 n%=i+1执行后 ,n 的值是 _C_。A. 0B. 1C. 3D. 252在下列选项中 ,_B_ 不能作为判定函数重载的依据。A. 参数个数B. 函数的类型C. 参数的类型D. 函数名称53有关虚函数的说法不正确的是_A_。A. 静态成员函数可以是虚函数B. 只有类的成员函数才能说明为虚函数C. 构造函数不能是虚函数D.析构函数可以是虚函数54. 派生类的对象对它的基类 _D_是可以访问的。A. 公有继承的私有成员B. 私有继承的公有成员C. 公有继承的保护成员D.公有继承的公有成员55. 下列关

26、于 switch 语句的描述中 ,_A_ 是正确的。A. switch语句中 default子句可以没有 , 也可有一个B. switch语句中每个语句序列中必须有break 语句C. switch语句中 default子句只能放在最后D. switch语句中 case 子句后面的表达式只能是整型表达式56能用友元函数重载的运算符是_D_。A. ->B. =C. D. +三、读程序写结果1.#include <iostream.h>using namespace std 。class pointpublic:point(int i,int j)x=i。y=j 。void pr

27、int()cout<<( <<x<< , <<y<< ) <<endl 。 void operator+=(pointp)x+=p.x。y+=p.y 。 void operator-=(pointp)x-=p.x。y-=p.y 。 private:int x,y。 。void main()pointp1(2,3),p2(1,4)。p1.print()p2.print()。p1+=p2。p1.print()。p2-=p1。p2.print()。6/27运行结果 :(2,3)(1,4)(3,7)(-2,-3)2.#includ

28、e<iostream.h>using namespace stdclass timerpublic:。timer() seconds=0。 timer(int t) seconds=t。timer(int min,int sec) seconds=min*60+secint gettime() return seconds。private:int seconds。 。void main()timer a,b(20),c(3,12)。cout<<"seconds1="<<a.gettime()<<endlcout<<

29、"seconds2="<<b.gettime()<<endlcout<<"seconds3="<<c.gettime()<<endl。运行结果 :seconds1=0seconds1=20seconds1=1923#include <iostream>using namespace std。class Apublic:A(int i,int j)a=i。 b=j 。 void move(int x,int y)a+=x。b+=y。void show()cout<< 

30、9;('<<a<< ','<<b<<')'<<endlprivate:int a,b。 。class B:public Apublic:B(int i,int j,int k,int l):A(i,j),x(k),y(l)void show()cout<<x<<","<<y<<endlvoid fun()move(3,5)。void f1()A:show()。 。 7/27int x,y。 。int main()A e(4,6)

31、。e.show() 。B d(1,3,2,5)。d.fun()。d.A:show()d.B:show()。d.f1()。system("pause")。return 0。运行结果 :(4,6)(4,8)2,5(4,8)4.#include <iostream>using namespace std。class Apublic:A(int i=0)m=i。cout<<"constructor called."<<m<<endlvoid set(int i) m=i。void print() const cou

32、t<<m<< endl。A(const A &s)m=s.m 。cout<<"copy"<<endl 。A()cout<<"destructor called."<<m<<endl。private:int m 。 。int main()const int N=7A my。my=N。my.print()。return 0。运行结果 :constructor called.0constructor called.7desstructor called.778/27de

33、sstructor called.75.#include<iostream>using namespace std 。class Mpublic:M(int a=0,int b=0) x=aint getx() return xint gety() return yprivate:int x,y。y=b。 。int main() M op1(8,6)。int i,j。i=op1.getx()。j=op1.gety()。cout<<"i="<<i<<",j="<<j<<endl。sys

34、tem("pause")。return 0。运行结果 :i=8,j=66. #include <iostream>using namespace std 。template<class type1,class type2>void myfunc(type1 x,type2 y)cout<<x<<','<<y<<endl。 int main()myfunc(27,"program")。myfunc(12.23,32u)。return 0。运行结果 :27, "

35、program"12.23,327.#include<iostream>#include<iomanip>using namespace std 。class Bookint num,price。public:Book(int a=0,int b=0)num=a。price=b 。void showMoney()cout<<setw(4)<<num*price<<endl。 。9/27Book b=Book(3,9),Book(2,8),Book(4,7)。Book *p 。int i。p=b。for(i=0。i<3

36、。i+,p+)p->showMoney()。system("pause")。return 0。 运行结果 :27( 前面有俩空格 )16( 前面有俩空格 )28(前面有俩空格 )8.#include<iostream>using namespace std 。class Point public:Point() X=Y=0。 cout<<"FIRST:Default Constructor called.n"Point(int xx,int yy)X=xx。 Y=yy 。 cout<< "SECOND:

37、Constructor called.n"Point() cout<<"THIRD:Destructor called.n"。int GetX() return X。 int GetY() return Y。 void Move(int x,int y) X=x 。 Y=y 。private:int X,Y。 。int main()cout<<"Step One:"<<endlPoint *Ptr1=new Pointdelete Ptr1。cout<<"Step Two:"&

38、lt;<endlPtr1=new Point(5,6)delete Ptr1。return 0。运行结果 :Step One:FIRST:Default Constructor called.THIRD:Destructor called.Step Two:SECOND:Constructor called.THIRD:Destructor called.9#include <iostream.h>class Point public:10/27Point()。int GetX() return Xint GetY() return Yprivate:int X,Y。 。 。

39、Point:Point(int xx,int yy)X=xx。 Y=yy 。cout<< "Constructor called."<<endlPoint :Point()cout<<"Destructor called."<<endl。 int main() Point A(1,4)。Point *ptr。ptr=&A 。int x。x=ptr->GetX()。cout<<x<<endl。return 0。运行结果 :Constructor called.1Destr

40、uctor called.10.#include<iostream>using namespace std 。class Teststatic int count。public:Test()+count。cout<<" 对象数量 ="<<count<<endl 。Test()-count。 cout<<" 对象数量 ="<<count<<endl。 。int Test:count=0。int main()Test t4。运行结果 :对象数量 =1对象数量 =2对象数量 =

41、3对象数量 =4对象数量 =3对象数量 =2对象数量 =1对象数量 =011/2711.#include <iostream>using namespace std 。int main() int num=2345。 long p=1 。dop*=num%10。num/=10。 while(num) 。cout<<"p="<<p<<endl 。return 0。运行结果 :p=12012.#include<iostream>using namespace std 。int a=1,2,3,4,5。int &

42、 fun(int i)return aiint main()int i。 fun(2)=10 。for(i=0。i<5 。i+)cout<<ai<<“”。 / “”中间空 2 个格cout<<endl 。system("pause")。return 0。 运行结果 :121045(中间两个空格)13.#include <iostream>using namespace std 。int n=0 。int &f(int m)n+=m。return n。 int main()f(3)+=21 。cout<<

43、;"n="<<n<<endl 。return 0。运行结果 :n=2414#include <iostream>#include <iomanip>using namespace std 。class myclass12/27public:myclass()cout<<setw(4)<<1。myclass(char c)cout<<setw(4)<<2 myclass()cout<<setw(4)<<3<<endl 。int main()myc

44、lass a,p1,*p2。p2=new myclass('X')。delete p2。system("pause")。return 0。 运行结果 :1123(33每个数字前面3个空格)( 每个数字前面( 每个数字前面3个空格)3个空格)15. #include <iostream> using namespace std 。int &f1(int n,int s)int &m=sn。return m 。int main()int s=1,2,3,4,5,6f1(2,s)=10。cout<<f1(2,s)<&l

45、t;endl。return 0。运行结果 :1016.#include <iostream>using namespace std 。class B 。class Apublic:A(int i)a=i。 friend int F(A &f1,B &f2)private:int a。 。class Bpublic:B(int i)b=i。 friend int F(A &f1,B &f2)private:。int b。 。13/27int F(A &f1,B &f2)return (f1.a+f2.b)*(f1.a-f2.b)。 in

46、t main()A n1(8) 。B n2(6) 。cout<<F(n1,n2)<<endl。return 0。运行结果 :28四、程序填空1. 下面的程序中定义抽象类 Base1, 利用基类指针作函数形参调用虚函数 , 以实现动态联编。#include <iostream>using namespace std 。class Base1/(1)基类 Base1 定义public:virtual void display() const=0。 /(2)纯虚函数（常成员函数）的定义 。class Base2:public Base1/(3)基类 Base1 的

47、公有派生类 Base2 定义public:void display() const。 。void Base2:display() constcout << "Base2:display()" << endl。class Derived:public Base2/(4)派生类 Derived 公有继承 Base2public:void display() const。 。void Derived:display() constcout << "Derived:display()" << endl。void fun(Base1 *ptr)/(5)形参为基类指针的没有返回值的普通函数fun 的函数首部ptr->display()。 /(6)用基类指针 ptr 调用虚函数 display()int main