面向对象程序设计

一、填空题1.面向对象系统的四个特性分别是抽象性封装性、继承性和多态性。

2.如果一个类至少有一个纯虚函数，那么该类被称为抽象类。

3.对于含有对象成员的派生类，其构造函数的执行顺序为：先执行基类的构造函数、再执行对象成员所在的构造函数，最后执行派生类的构造函数。

4.纯虚函数的声明格式为：virtual函数类型函数名（参数列表）=0；。

5.运算符重载仍然保持原来的优先级、结合性和语法结构。

6.类型转换函数的作用是将一个类的对象转换成另一类型的数据。

7.静态联编支持的多态性称为编译时的多态性，也称静态多态性。

8.类中成员的三种访问权限分别是public、private和protected。

9.定义派生类时，系统默认的继承方式是private。

10.C++允许在相同的作用域内以相同的名字定义几个不同实现的函数，称这种同一个函数名多种含义的现象为函数重载。

11.在C++中，运行时的多态性主要通过继承和虚函数实现。

12.在一个函数的定义或声明前加上关键字inline时，该函数就声明为内置函数。

13.派生类的成员包括从基类继承来的成员和自己增加的成员两大部分。

14.cin称为C++的标准输入流对象。

15.在C++语言中，用运算符new动态建立对象，用运算符delete撤消对象。

16.基类的构造函数和析构函数不能被派生类继承。

17.名称为temp的类的复制构造函数的原型声明语句为temp（const temp &）；。

18.设置友元函数的目的是为了能够访问该类的私有成员。

19.在C++程序中，静态成员函数主要用来访问静态数据成员。

20.类模板是类的抽象，类是类模板的实例。

21.拷贝构造函数的形参必须是本类对象的引用。

22.进行函数重载时，被重载的同名函数如果都没有用const修饰，则它们的形参个数不同或数据类型不同或个数的和类型不同。

23.在类中必须声明成员函数的原型，成员函数的实现部分可以写在类外。

24.多态性是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。

25.在已有类的基础上新增自己的特性而产生新类的过程称为派生。

26.当用类的一个对象去初始化该类的另一个对象时系统自动调用复制构造函数实现赋值。

27.友元函数是在类声明中由关键字friend修饰说明的非成员函数，在它的函数体中能够通过对象名访问private 和protected成员。

28.如果需要在某个类的声明之前，引用该类，则应进行前向声明。

29.对象是将数据及对数据的操作方法封装在一起，作为一个相互依存、不可分离的整体。

30.C++中输出数据时，在标准输出流对象cout之后使用的运算符“<<”称为流插入运算符。

31.从系统实现角度看，多态性分为静态多态性和动态多态性。

32.基类的私有成员在派生类中是不可访问的。

33.对象空间的起始地址就是对象指针。

34.对象与对象之间通过消息传递进行通讯。

35.C++中用于定义模板的关键字是template。

36.包含纯虚函数的类称为抽象类。

37.基类中的构造函数和析构函数是不能被派生类继承的。

38.在C++的类中包含两种成员，分别是数据成员和成员函数。

39.C++允许在同一作用域中用同一函数名定义多个函数，这些函数的参数个数和参数类型不相同，这些同名的函数用来实现不同的功能，称为函数重载。

40.所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。

41.C++为提高函数调用的效率，允许在编译时将所调用函数的代码嵌入到主函数中，这种嵌入到主函数的函数称为内置函数。

42.类中有两种特殊的成员函数，分别是构造函数和析构函数。

43.若要定义指向Time类对象t1的常指针ptr，其定义语句为：const Time *ptr=&t1；。

44.如果函数的形参为类的对象，在调用函数时需要将实参对象完整地传递给形参对象，此时系统要调用复制构造函数来实现。

45.如果需要在同类的多个对象之间实现数据共享，但不用全局变量，可以用静态数据成员。

46.在C++中，要访问类中的私有成员，可以使用成员函数和友元函数。

47.C++中，有四个运算符必须重载为类的成员函数，而不能重载为友元函数，这四个运算符分别是：=，（），[]，->。

48.若要实现两个复数类对象相加运算，并且满足交换律，要将“+”重载为类的友元函数。

49.面向对象技术强调软件的可重用性，C++语言提供了类的继承机制，解决了软件重用问题。

50.继承方式包括三种，分别是：public、private和protected。

51.C++中允许一个派生类同时继承多个基类，这种行为称为多重继承。

52.声明虚基类命令的的一般形式为class 派生类名：virtual 继承方式基类名。

53.只有公用派生类才是基类真正的子类型。

54.动态多态性是在程序运行过程中才动态地确定操作所针对的对象，又称为运行时的多态性。

55.虚函数一定是类的成员函数。

56.定义纯虚函数的一般形式是：virtual 函数类型函数名（参数列表）=0；。

57.静态成员函数没有this指针。

58.类中成员默认的访问属性是private。

59.用关键字inline声明的函数称为内置函数。

60.若将两个复数相加运算符“+”重载为类complex的成员函数，且函数的返回值为当前类的对象，其函数的原型声明语句为complex operator+（complex &）；。

61.若用op代表C++中任意一个允许重载的运算符，其重载函数名为operatorop。

62.C++中的模板分为类模板和函数模板。

63.具有继承性、封装性和多态性特点的程序设计称为面向对象的程序设计。

64.对于含有对象成员的派生类，其析构函数的执行顺序为：先执行派生类的析构函数、再执行对象成员所在类的析构函数，最后执行基类的析构函数。

65.用已有对象复制一个新对象时要调用复制构造函数。

66.在基类中将show（无参数）声明为返回整型数据的纯虚函数的语句格式为：virtual int show（）=0；。

67.动态联编支持的多态性称为运行时的多态性，也称为动态多性性。

68.在派生类中，对基类的继承方式可以有public、private和protected。

69.将双目运算符重载为某类的成员函数时，该成员函数的左操作数为当前对象（或*this），右操作数为函数的参数。

70.在C++语言中，cout被称为标准输出流对象。

71.若要访问类中的私有成员，除了可以利用成员函数外，还可以采用友元函数的方式。

72.定义静态成员函数的目的是为了访问类中的静态数据成员。

73.要实现运行时的多态性要使用继承和虚函数。

74.派生类的成员来自两个途径，一种是派生类中定义的成员，另一种从基类继承来的成员。

75.构造函数是一种特殊的成员函数，其作用是对类的数据成员进行初始化并执行对象的其他内部管理操作。

76.在类中定义和实现的函数称为成员函数。

77.常成员函数只能引用本类中的数据成员，而不可以修改数据成员。

78.如果一个类中至少有一个纯虚函数，那么该类被称为抽象类。

79.C++中用关键字static声明的对象称为静态对象。

80.若有类名为sample，则其复制构造函数的原型声明语句为sample（const sample &）；。

三、读程序写结果1.#include <iostream.h>using namespace std;class point{public:point(int i,int j){x=i;y=j;}void print(){cout<< ‘(’<<x<< ‘,’<<y<<‘)’<<endl;} void operator+=(point p){x+=p.x;y+=p.y;}void operator-=(point p){x-=p.x;y-=p.y;}private:int x,y;};void main(){point p1(2,3),p2(1,4);p1.print();p2.print();p1+=p2;p1.print();p2-=p1;p2.print();}运行结果：（2,3）（1,3）（3,7）（-2，-3）2.#include<iostream.h>using namespace std;class timer{public:timer() {seconds=0;}timer(int t) {seconds=t;}timer(int min,int sec) {seconds=min*60+sec;}int gettime() {return seconds;}private:int seconds;};void main(){timer a,b(20),c(3,12);cout<<"seconds1="<<a.gettime()<<endl;cout<<"seconds2="<<b.gettime()<<endl;cout<<"seconds3="<<c.gettime()<<endl;}运行结果: second1=0second2=20second3=1923.#include <iostream>using namespace std；class A{public:A(int i，int j){a=i；b=j；}void move(int x，int y){a+=x；b+=y；}void show(){cout<< '('<<a<< '，'<<b<<')'<<endl；} private:int a，b；}；class B:public A{public:B(int i，int j，int k，int l):A(i，j)，x(k)，y(l){}void show(){cout<<x<<"，"<<y<<endl；}void fun(){move(3，5)；}void f1(){A::show()；}private:int x，y；}；int main(){A e(4，6)；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 A{public:A(int i=0){m=i；cout<<"constructor called."<<m<<endl；} void set(int i) {m=i；}void print() const {cout<<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=7；A my；my=N；my.print()；return 0；}运行结果：constructor called.0constructor call.7destructor called.77destructor called.7 5.#include<iostream>using namespace std;class M{public:M(int a=0,int b=0) {x=a;y=b;}int getx() {return x;}int gety() {return y;} private:int x,y;};int main(){ M op1(8,6);int i,j;i=op1.getx();j=op1.gety();cout<<"i="<<i<<",j="<<j<<endl;system("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，program12.23,327.#include <iostream>#include <iomanip>using namespace std;class Book{int num,price;public:Book(int a=0,int b=0){num=a;price=b;}void showMoney(){cout<<setw(4)<<num*price<<endl;}};int main(){ Book b[]={Book(3,9),Book(2,8),Book(4,7)};Book *p;int i;p=b;for(i=0;i<3;i++,p++)p->showMoney();system("pause");return 0;}运行结果： 271628 （数据的左边有两个空格）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: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:"<<endl;Point *Ptr1=new Point;delete Ptr1;cout<<"Step Two:"<<endl;Ptr1=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:Point(int xx,int yy);~Point();int GetX() {return X;}int GetY() {return Y;}private:int X,Y;};Point::Point(int xx,int yy){ X=xx; Y=yy;cout<< "Constructor called."<<endl;} Point ::~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.1Destructor called.10.#include<iostream>using namespace std;class Test{static int count;public:Test(){++count;cout<<"对象数量="<<count<<endl; }～Test(){--count;cout<<"对象数量="<<count<<endl; } };int Test::count=0;int main(){Test t[4];}运行结果：对象数量=1对象数量=2对象数量=3对象数量=4对象数量=3对象数量=2对象数量=1对象数量=011.#include <iostream>using namespace std;int main(){ int num=2345;long p=1;do{p*=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 & fun(int i){return a[i];}int main(){ int i;fun(2)=10;for(i=0;i<5;i++)cout<<a[i]<<“”;//“”中间空2个格cout<<endl;system("pause");return 0;}运行结果：1 2 10 4 5 （中间空2个格）13.#include <iostream>using namespace std;int n=0;int &f(int m){ n+=m;return n;}int main(){ f(3)+=21;cout<<"n="<<n<<endl;return 0;}运行结果：n=2414．#include <iostream>#include <iomanip>using namespace std;class myclass{public:myclass(){cout<<setw(4)<<1;}myclass(char c){cout<<setw(4)<<2;}～myclass(){cout<<setw(4)<<3<<endl;}};int main(){myclass a,p1,*p2;p2=new myclass('X');delete p2;system("pause");return 0;}运行结果： 1 1 2 333 （数字左侧有三个空格）15. #include <iostream>using namespace std;int &f1(int n,int s[]){int &m=s[n];return m;}int main(){int s[]={1,2,3,4,5,6};f1(2,s)=10;cout<<f1(2,s)<<endl;return 0;}运行结果：1016.#include <iostream>using namespace std;class B;class A{public:A(int i){a=i;}friend int F(A &f1,B &f2);private:int a;};class B{public:B(int i){b=i;}friend int F(A &f1,B &f2);private:int b;};int F(A &f1,B &f2){return (f1.a+f2.b)*(f1.a-f2.b);}int main(){A n1(8);B n2(6);cout<<F(n1,n2)<<endl;return 0;}运行结果：2816. #include <iostream>using namespace std；class sample{public:sample(){cout<<"Constructor"<<endl；}~sample(){cout<<"Destructor"<<endl；}}；void fn(int i){static sample c；cout<<"i="<<i<<endl；}int main(){fn(15)；fn(30)；return 0；}运行结果：Constructori=15i=30Destructor四、程序填空1.下面的程序中定义抽象类Base1，利用基类指针作函数形参调用虚函数，以实现动态联编。