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

简答题

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<

　　【参考答案】

　　【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.123456789 << 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

　　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<

　  　cout<

　　  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<

　　 cout<

五、阅读程序题(写出程序运行结果)

1  .#include

#include

class Student

{ public:

Student(char *pName="No name")

{ cout<<"构造新同学："<

strncpy(name, pName, sizeof(name));

name[sizeof(name)-1]='\0';

}

Student(Student &s)

{ cout<<"构造copy of "<

strcpy(name, " copy of ");

strcat(name,s.name);

}

~Student()

{ cout<<"析构 "<

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"<

};

class B2

{ protected:

int b2;

public:

B2(int val2)

{ b2=val2;

cout<<"base2 is called"<

};

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

# include

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 << "  编号:"<

}

int  married :: glob= 0 ;

void main ()

{    married  person[100];

int  i ;

char str[8] ;

cout<

for ( i=0; i<3; i++)

{  cout << "  输入姓名：";  cin >> str ;

person[i].set_mes ( str ) ;       }

cout<

}

假定输入

zhang↙

wang↙

li↙

请写出程序的结果。

4 .

# include

template class ABC

{  private:

T array [I] ;

public:

void  set (int x)

{  int  i;

for (i=0; i

array[i]=x+i;

}

void  get ()

{ cout <<"\n   数组元素总数为："<< I<

cout <<"   array["<

};

void main()

{ ABC abc1;

abc1.set(0);

abc1.get();

ABC abc2;

abc2.set(10);

abc2.get();    }

程序运行结果：

5.#include

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

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="<

void Myclass::myfunc()

{ int x=9,y=10;

cout<<"In myfunc: x="<

cout<<"Myclass::x="<}

void main()

{ Myclass test(100,200);

test.print(); //通过对象名访问公有成员

test.myfunc();   }

7.  #include

class A

{private:

int a;

public:

A(int i=0){a=i;}

void print();

};

void A::print ()

{ cout<<"In class A, print() is called."<

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<<"用友元函数求各和："<

void sum1(X1 &a,X1 &b)

{cout<< "用普通函数调用类公共接口函数求和："

<

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

// 定义类模板ABC

template class ABC

{  private:

T array [I] ;            // 定义数组array

public:

void  set (int x)        // 定义成员函数set

{  int  i;

for (i=0; i

array[i]=x+i;        //数组元素赋值

}

void  get ()            //定义成员函数get

{ cout <<"\n   数组元素总数为："<< I<

cout <<"   array["<

};

void main()

{ //由模板ABC生成对象abc1

ABC abc1;

abc1.set(0);          //调用对象abc1.set

abc1.get();           //调用对象abc1.get

//由模板ABC生成对象abc2

ABC 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

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   经度："<

cout<<"      纬度："<

cout<<"      高度："<

cout<<"      面积："<

};

void main()

{  //用Build_2生成对象obj

Build_2  obj;

obj.set1(100,200,300);

obj.set2(400);

obj.disp();

}