2024年面向对象程序设计考前复习题及答案.doc

简答题
1、老式的结构化程序设计的优点和缺陷是什么？
优点：
（1）这种程序设计措施力求算法描述准确。
（2）对每一子过程模块轻易进行程序正确性证明。
缺陷：
（1）这种程序设计措施本质上是面对“过程”的，而“过程”和“操作”又是不稳定和多变的，因此不能直接反应人类求解问题的思绪。
（2）程序代码可重用性差。程序中除少数标准库函数外，每设计一个程序时，程序员几乎从零做起。虽然重用代码，一般也是通过拷贝或编辑重新生成一份。
（3）维护程序的一致性困难。该种措施将数据与对数据进行处理的程序代码分离。
2、什么是对象？
每个对象都具备属性（Attribute）和措施（Method）这两方面的特性。对象的属性描述了对象的状态和特性，对象的措施阐明了对象的行为和功效，并且对象的属性值只应由这个对象的措施来读取和修改，二者结合在一起就组成了对象的完整描述。
3、什么是消息？
在面对对象的程序设计中，因为对象描述了客观实体，它们之间的联系通过对象间的联系来反应。当一个对象需要另外一个对象提供服务时，它向对方发出一个服务祈求，而收到祈求的对象会响应这个祈求并完成指定的服务。这种向对象发出的服务祈求就称为消息。
4、什么是多态性？
　所谓多态性是指当程序中的其他部分发出同样的消息时，按照接收消息对象的不一样能够自动执行类中对应的措施。其好处是，用户无须懂得某个对象所属的类就能够执行多态行为，从而为程序设计带来更大以便。
5、什么是面对对象的程序设计措施?
这种措施将设计目标从模拟现实世界的行为转向了模拟现实世界中存在的对象及其各自的行为。
　 在OOP中，将“对象”作为系统中最基本的运行实体，整个程序即由各种不一样类型的对象组成，各对象既是一个独立的实体，又可通过消息相互作用，对象中的措施决定要向哪个对象发消息、发什么消息以及收到消息时怎样进行处理等。
6、面对对象措施的特点是什么？
（1）OOP以“对象”或“数据”为中心。因为对象自然地反应了应用领域的模块性，因此具备相对稳定性，能够被用作一个组件去组成更复杂的应用，又因为对象一般封装的是某一实际需求的各种成份，因此，某一对象的变化对整个系统几乎没有影响。
（2）引入了“类”（class）的概念。类与类以层次结构组织，属于某个类的对象除具备该类所描述的特性外，还具备层次结构中该类上层所有类描述的所有性质，OOP中称这种机制为继承。
（3）OOP措施的模块性与继承性，确保了新的应用程序设计可在原有对象的数据类型和功效的基础上通过重用、扩展和细化来进行，而无须从头做起或复制原有代码，这么，大大减少了重新编写新代码的工作量，同时减少了程序设计过程中犯错的也许性，达成了事半功倍的效果。
7、面对对象的程序设计措施与结构化程序设计措施的比较
（1）老式的结构化程序设计措施以过程为中心结构应用程序，数据和处理数据的过程代码是分离的、相互独立的实体，设计出的程序可重用代码少，且当代码量增加时维护数据和代码的一致性困难。
（2）面对对象程序设计措施中，对象所具备的封装性和继承性使得代码重用成为也许，并大大减少了程序犯错的也许性。
（3）面对对象措施吸取了结构化程序设计措施的优点，同时引入了新概念、新机制并建立了比老式措施更高层次的抽象。
二、选择题
略

三、填空题

　　(1)类是一个支持集成的抽象数据类型，而对象是类的 【1】 。
　　【参考答案】
　　【1】实例
　　(2)在C++语言的面对对象程序设计框架中， 【2】 是程序的基本组成单元。
　　【参考答案】
　　【2】类
　　(3)C++语言程序的注释能够出目前途序中的任何地方，一个注释以 【3】 作为开始和结束的标识。
　　【参考答案】
【3】/* */
　　(4)如下程序的输出成果是 【4】 。
#include "iostream.h"
void fun()
{ static int a;
a+=2;
cout << a << " "; }
void main()
{ int cc;
for(cc=1;cc<4;cc++)
fun();
cout << endl;}
　　【参考答案】
　　【4】2 4 6

　　(5)下列程序在结构函数和析构函数中申请和释放类的数据组员int *a，申请时使用形参b初始化a，请填空。
　　class A
　　{ public:
　　A(int b);
　　~A();
　　private:
　　int *a; };
　　A::A(int b)
　　{ 【5】 ; }
　　A::~A()
　　{ 【6】 ; }
　　【参考答案】
　　【5】a = new int(b); 【6】delete a
　　6. 多态性与【7】和【8】共同组成面对对象程序设计的三大机制。
　　【参考答案】
　　【7】数据封装 【8】继承

　　(7)将x+y*z中的"+"用组员函数重载，"*"用友元函数重载应写为 【9】 。
　　【参考答案】
　　【9】x. operator+(operator*(y,z))
　(8)派生类的组员一般分为两部分，一部分是 【10】 ，另一部分是自己定义的新组员。
　　【参考答案】
　　【10】从基类继承的组员
(9)如下程序输出的成果是 【11】 。
　#include "iostream.h"
void main()
{int a=5,b=4,c=3,d;
d=(a>b>c);
cout<<d; }
　　【参考答案】
　　【11】 0
　(10)假如要把返回值为void的函数A申明为类B的友元函数，则应在类B的定义中加入的语句是 【12】 。
　　【参考答案】
　　【12】friend void A( );
　　(11)假如类B继承了类A,则称类A为类B的基类，类B称为类A的 【13】 。
　　【参考答案】
　　【13】派生类
　　(12)将x+y中的+运算符用友元函数重载应写为 【14】 。
　　【参考答案】
　　【14】operator+(x，y)
　　(13)已知程序的成果为1 2 3，请填空。
　　#include　　template　　class A
　　{ public:
　　T x,y,z;
　　void display(){cout << x << " " << y << " " << z;} };
　　void main()
　　{ Aa1;
　　【15】
　　【16】
　　【17】
　　a1.display(); }
　　【参考答案】
　　【15】a1.x=1 【16】a1.y=2 【17】a1.z=3
　　(14)下列程序段的输出成果是 【18】 。
　　cout << fixed << 509. << endl;
　　【参考答案】
　　【18】509.123457
四、综合应用题
1. 使用VC6打开考生文献夹下的工程kt15_3。此工程包括一个kt15_3.cpp，其中定义了类A、A1和A2，其中A1类由A类公有派生，A2类由A1类公有派生。上述三个类的定义并不完整，请按要求完成下列操作，将程序补充完整。
　　（1）定义类A的结构函数，该结构函数有一个整型的参数x，在结构函数中请将x赋值给数据组员a。请在注释“//**1**”之后添加适当的语句。
　　（2）定义类A1的结构函数，该结构函数有两个整型参数x和y，在结构函数中请将x赋值给数据组员b，将y作为基类A结构函数的参数值传入。请在注释“//**2**”后添加适当的语句。
　　（3）定义类A2的结构函数，该结构函数有三个整型的参数x，y和z，在结构函数中请将x赋值给数据组员c，将y和z分别赋值给基类A1结构函数的参数x和y。请在注释“//**3**”之后添加适当的语句。
　　（4）完成类A2的组员函数show的定义，该函数调用基类组员函数，输出基类数据组员a和b及类A2自身的数据组员c的值，上述三个值在输出时以空格隔开。请在注释“//**4**”之后添加适当的语句。
　　注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。
　　程序输出成果如下：
　　9
　　6
　　962
　　源程序文献kt15_3.cpp清单如下：
　　#include<iostream.h>
　　classA
　　{ inta;
　　 public:
　　 //**1**
　　 intgeta(){returna;} };
　　classA1:publicA
　　{ intb;
　　 public:
　 　//**2**
　　 intgetb(){returnb;} };
　　classA2:publicA1
　　{ intc;
　 　public:
　　 //**3**
　 　voidshow()
　　 { //**4** } };
　　voidmain()
　　{ A2a(2,6,9);
　　 cout<<a.geta()<<endl;
　 　cout<<a.getb()<<endl;;
　　 a.show(); }
　　【参考答案】
　　（1）A(int x) {a=x;}
　　（2）A1(int x,int y) : A(y){b=x;}
　　（3）A2(int x,int y,int z):A1(y,z){c=x;}
　　（4）cout<<geta()<<" "<<getb()<<" ";
　　 cout<<c<<"n";

五、阅读程序题(写出程序运行成果)
1 .#include <iostream.h>
#include <string.h>
class Student
{ public:
Student(char *pName="No name")
{ cout<<"结构新同学："<<pName<<endl;
strncpy(name, pName, sizeof(name));
name[sizeof(name)-1]='\0';
}
Student(Student &s)
{ cout<<"结构copy of "<<s.name<<endl;
strcpy(name, " copy of ");
strcat(name,s.name);
}
~Student()
{ cout<<"析构 "<<name<<endl; }
protected:
char name[40]; };
class Tutor
{ public:
Tutor(Student &s):student(s)
{ cout<<"结构指引教师 \n"; }
protected:
Student student;
};
void main()
{ Student st1;
Student st2("zhang");
Tutor tutor(st2);
}

2. #include "iostream.h"
class B1
{protected:
int b1;
public:
B1(int val1)
{ b1=val1;
cout<<"base1 is called"<<endl; }
};
class B2
{ protected:
int b2;
public:
B2(int val2)
{ b2=val2;
cout<<"base2 is called"<<endl; }
};
class D: public B1,public B2
{protected:
int d;
public:
D(int val1, int val2, int val3);
};
D::D(int val1, int val2, int val3):B1(val1),B2(val2)
{ d=val3;
cout<<"derived class is called";}
void main()
{ D dobj(1,2,3); }

3. # include <windows.h>
# include <iostream.h>
class married
{private:
int number;
char *name;
public:
static int glob;
void set_mes (char *a);
} ;
void married :: set_mes (char *a)
{name = new char[strlen(a) + 1] ;
strcpy (name, a) ;
number=++glob;
cout << " 编号:"<<number<<endl;
}
int married :: glob= 0 ;
void main ()
{ married person[100];
int i ;
char str[8] ;
cout<<endl;
for ( i=0; i<3; i++)
{ cout << " 输入姓名："; cin >> str ;
person[i].set_mes ( str ) ; }
cout<<endl;
}
假定输入
zhang↙
wang↙
li↙
请写出程序的成果。

4 .
# include <iostream.h>
template <class T, int I> class ABC
{ private:
T array [I] ;
public:
void set (int x)
{ int i;
for (i=0; i<I; i++)
array[i]=x+i;
}
void get ()
{ cout <<"\n 数组元素总数为："<< I<<endl;
cout <<" array["<<I-1<<"]="<<array[I-1]<<endl; }
};
void main()
{ ABC <int,50> abc1;
abc1.set(0);
abc1.get();
ABC <int,100> abc2;
abc2.set(10);
abc2.get(); }
程序运行成果：
5. #include <iostream.h>
class Student
{ public:
Student()
{ cout<<”construct student.\n”;
semeshours=100;
gpa=3.5; }
protected:
int semeshours;
float gpa;
};
class Teacher
{ public:
Teacher() { cout<<”construct Teacher.\n”; }
};
class Tourpair
{public:
Tourpair()
{cout<<”construct tourpair.\n”;
nomeeting=0; }
protected:
Student student;
Teacher teacher;
int nomeeting;
};
void main()
{Tourpair tp;
cout<<”back in main.\n”; }

6. #include <iostream.h>
class Myclass
{ private:
int x;
int y;
public:
Myclass(int a,int b) { x=a;y=b;}
void print();
void myfunc();
};
void Myclass::print()
{ cout<<"x="<<x<<","<<"y="<<y<<endl; }
void Myclass::myfunc()
{ int x=9,y=10;
cout<<"In myfunc: x="<<x<<","<<"y="<<y<<endl;
cout<<"Myclass::x="<<Myclass::x<<","<<" <<Myclass::y="<<Myclass::y<<endl;
}
void main()
{ Myclass test(100,200);
test.print(); //通过对象名访问公有组员
test.myfunc(); }

7. #include <iostream.h>
class A
{private:
int a;
public:
A(int i=0){a=i;}
void print();
};
void A::print ()
{ cout<<"In class A, print() is called."<<endl; }
class B:public A
{
private:
int b;
public:
B(int j=-1){b=j;}
};
void commfun(A &aref)
{ aref.print(); }
void main()
{A a;
commfun(a);
B b;
commfun(b);
}

8. #include “iostream.h”
class X1()
{ private:
int x;
public:
X1(int i) { x=i; }
int getx();
friend void sum(X1 &a, X1 &b);
};
int X1::getx(){ return x;}
void sum(X1 &a,X1 &b)
{cout<<"用友元函数求各和："<<a.x+b.x<<endl; }
void sum1(X1 &a,X1 &b)
{cout<< "用一般函数调用类公共接口函数求和："
<<a.getx()+b.getx()<<endl; }
void main()
{ X1 m(1);
X1 n(2);
sum(m,n);
sum1(m,n);}
答案：
1. 执行成果如下：
结构新同学：No name
结构新同学：zhang
结构copy of zhang
结构指引教师
析构 copy of zhang
析购zhang
析构 No name
2. 该程序的执行成果是：
base1 is called
base2 is called
derived class is called
3. 程序的成果：
Zhang
编号1
Wang
编号2
Li
编号3
4. 程序的成果：
数组元素总数为：50
array[49]=49

数组元素总数为：100
array[99]=109
5.其执行成果是：
construct student.
construct teacher.
construct tourpair.
back in main.
6. 程序的运行成果为：
x=100,y=200
In myfunc: x=9,y=10
Myclass::x=100,Myclass::y=200
7. 程序的运行成果为：
In class A, print() is called.
In class A, print() is called.
8. 程序的运行成果为：
用友元函数求各和：3
用一般函数调用类公共接口函数求和：3
六、编程题
1．定义类模板ABC，内含组员函数set和get。用ABC生成对象abc1和abc2。它们的数组元素数不一样，显示的成果也不一样。
# include <iostream.h>
// 定义类模板ABC
template <class T, int I> class ABC
{ private:
T array [I] ; // 定义数组array
public:
void set (int x) // 定义组员函数set
{ int i;
for (i=0; i<I; i++) //循环I次
array[i]=x+i; //数组元素赋值
}
void get () //定义组员函数get
{ cout <<"\n 数组元素总数为："<< I<<endl;
cout <<" array["<<I-1<<"]="<<array[I-1]<<endl; }
};
void main()
{ //由模板ABC生成对象abc1
ABC <int,50> abc1;
abc1.set(0); //调用对象abc1.set
abc1.get(); //调用对象abc1.get
//由模板ABC生成对象abc2
ABC <int,100> abc2;
abc2.set(10); //调用对象abc2.set
abc2.get(); //调用对象abc2.get
}

2. 类Build_1是一个有关楼房数据的类。它的数据组员有posi_x、posi_y和area，分别是楼房位置的经、纬度和建筑面积。它的函数组员只有set1，用于设置数据组员posi_x、posi_y和area的值。让Build_1作为基类，再增加数据组员high、函数组员set2和disp来定义派生类Build_2。
#include <iostream.h>
class Build_1 //定义基类
{ protected:
int posi_x; // 有三个保护型的数据组员
int posi_y;
int area;
public:
void set1(int x, int y, int a)
{ posi_x=x; posi_y=y; area=a; }
};
//定义派生类Build_2
class Build_2 : public Build_1
{ int height;
public:
void set2(int h)
{ height=h;}
void disp()
{ cout<<"\n 经度："<<posi_x<<endl;
cout<<" 纬度："<<posi_y<<endl;
cout<<" 高度："<<height<<endl;
cout<<" 面积："<<area<<endl<<endl; }
};
void main()
{ //用Build_2生成对象obj
Build_2 obj;
obj.set1(100,200,300);
obj.set2(400);
obj.disp();
}