面向对象程序设计复习题.docx

资源描述

面向对象程序设计复习题.docx

《面向对象程序设计复习题.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计复习题.docx（18页珍藏版）》请在冰豆网上搜索。

面向对象程序设计复习题.docx

面向对象程序设计复习题

《面向对象程序设计》复习题

一、单项选择题

1.（A）是面向对象系统包含的要素。

A、类B、多态C、友元D、重载

2.下列对常量的定义中，错误的是（　C　）。

A、MyClassconstobj（3,4）;B、char*constp="hello";

C、int&ref=2;　　　　D、voidshow（）const;

3.若有如下函数声明：

voidFun（intx）;，则下列（D　　）能与该函数形成重载。

A、voidFun（inty）;B、voidFun（intx,inty='1'）;

C、intFun（intx）;D、voidFun（int）const;

4.下列对构造函数和析构函数的描述中，错误的是（　B　）。

A、构造函数可以重载

B、析构函数名与类名相同

C、构造函数中可以设置参数的缺省值

D、类中只有一个析构函数

5.下列对友元的描述中，错误的是（　C　）。

A、友元破坏了类的封装性

B、友元提高了程序的运行效率

C、友元可以在类外声明和定义

D、友元能够访问类中的私有成员

6.下列对继承的描述中，正确的是（　A　）。

A、公有派生类对象能够访问基类的公有成员

B、派生类只继承了基类的公有成员和保护成员

C、派生类对象不能访问基类的保护成员

D、派生类不改变基类成员的访问权限

7.程序中，编译时出错的语句是（D　）。

classBase{};

classDerived:

publicBase{};

DerivedobjD1;

BaseobjB=objD1;数据成员C.构造函数D.静态成员函数

答案：

分析：

当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作；

28：

下列表达方式正确的是（）。

A．classP{B．classP{

public：

intx=15；intx；

voidshow（）{cout<

}；}

C．classP{D.classP{

intf;public：

}；inta；

f=25；voidSeta（intx）{a=x;}};

答案：

分析：

在类体内不可对数据成员进行初始化；类定义结束时需用分号；只有类中的成员函数才能存取类中的私有数据。

29：

拷贝构造函数具有的下列特点中，（）是错误的。

A．?

如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的

B．?

拷贝构造函数至少有一个参数，并且是该类对象的引用

C．?

拷贝构造函数是一种成员函数

D．拷贝构造函数的名字不能用类名

答案：

分析：

如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的；拷贝构造函数至少有一个参数，并且是该类对象的引用；拷贝构造函数的名字与类同名，并且不被指定返回类型；拷贝构造函数是一种成员函数。

30：

关于静态成员的描述中，（）是错误的。

A．?

静态成员可分为静态数据成员和静态成员函数

B．?

静态数据成员定义后必须在类体内进行初始化

C．?

静态数据成员初始化不能在构造函数中完成

D．?

静态成员函数中不能直接引用非静态成员

答案：

分析：

静态成员可分为静态数据成员和静态成员函数；静态数据成员被定义后，必须对它进行初始化，初始化在类体外进行，一般放在该类的实现部分最合适，也可以放在其他位置，例如，放在主函数前面等；静态数据成员初始化与该类的构造函数和析构函数无关；在静态成员函数的实现中，可以直接引用静态成员，但不能直接引用非静态成员。

31：

关于友元的描述中，（）是错误的。

A．?

友元函数是成员函数，它被说明在类体内

B．?

友元函数可直接访问类中的私有成员

C．?

友元函数破坏封装性，使用时尽量少用

D．?

友元类中的所有成员函数都是友元函数

答案：

分析：

友元函数是非成员函数，在类体内说明了，在类体外定义，定义和调用等同于一般的普通函数；由于它可以直接访问类的私有成员，因此破坏了类的封装性和隐藏性，尽量少用。

二、填空题

1.下列运算符既可以作为类的成员函数重载，也可以作为类的友元函数重载，请在表格中的空白处填上正确的表达式。

表达式

成员函数

友元函数

a+b

（1）

（2）

a++

（3）

operator++（a）

-a

-（）

（4）

1.答案:

（1）+（b）

（2）operator+（a,b）

（3）++（）（4）operator–（a）

2.下列程序执行后的输出结果是12,21,22，请将下列程序补充完整。

#include<>

voidfun1（　

（1）　,intb）{intc;c=a;a=b;b=c;}

voidfun2（　

（2）　,int*b）{intc;c=*a;　（3）　;*b=c;}

voidfun3（　（4）　,intb）{intc;c=a;　（5）　;b=c;}

voidmain（）{

intx,y;

x=1;y=2;fun1（x,y）;cout<

x=1;y=2;fun2（&x,&y）;cout<

x=1;y=2;fun3（x,y）;cout<

}

2.答案:

（1）inta

（2）int*a（3）*a=*b

（4）int&a（5）a=b

3.下列程序执行后的输出结果是B0D00B1D23~D~B~D~B，请将下列程序补充完整。

classBase{

public:

Base（inti=0）{x=i;cout<<'B'<

~Base（）{cout<<"~B"<

private:

intx;

};

classDerived:

publicBase{

inty,z;

public:

__________________

（1）________________________员名”的形式访问的对象成员仅限于被声明为

（1）的成员；若要访问其他成员变量，需要通过

（2）函数或（3）函数。

答案：

（1）public

（2）成员（3）友元

分析：

类体内的数据成员可声明为公有的、私有的和保护的，公有的数据成员可利用“对象名.成员名”形式来进行访问；私有的数据成员能被类中的成员函数或友元函数所调用；保护的数据成员可以在类体中使用，也可以在派生类中使用，但不能在其他类外通过对象使用。

三、写程序结果题

1.#include<>

classTest{

public:

Test（doublem,doublen,doubled）:

p（d）{x=m;y=n;}

voidShow（）;

voidShow（）const;

private:

doublex,y;

constdoublep;

};

voidTest:

Show（）{

cout<

cout<<"p="<

}

voidTest:

Show（）const{

cout<

cout<<"p="<

}

voidmain（）{

Testa,,;

（）;

constTestb,,;

（）;

}

答案：

const

p=const

2.#include<>

classA{

public:

A（inti）{cout<<"Constructor"<

A（A&r）{cout<<"Copyconstructor"<

~A（）{cout<<"Destructor"<

A&operator=（A&r）;

voidoutput（）{cout<<*p<

private:

int*p;

};

A&A:

operator=（A&r）{

cout<<"Assignment"<

if（this==&r）return*this;

deletep;

p=newint;

return*this;

};

voidmain（）{

Aa（5）;

Ab=a;

Ac（6）;

c=a;

（）;

};

答案：

Constructor

Copyconstructor

Constructor

Assignment

Destructor

3.#include<>

classBase1{

public:

Base1（intx）{cout<<"Base1'scon."<

~Base1（）{cout<<"Base1'sdes."<

};

classBase2{

public:

Base2（intx）{cout<<"Base2'scon."<

~Base2（）{cout<<"Base2'sdes."<

};

classDerived:

publicBase2,publicBase1{

public:

Derived（intx,inty）:

Base1（y）,Base2（x）{cout<<"Derived'scon."<

~Derived（）{cout<<"Derived'sdes."<

};

voidmain（）{

Derivedobj（1,2）;

}

答案：

Base2'scon.1

Base1'scon.2

Derived'scon.

Derived'sdes.

Base1'sdes.

Base2'sdes.

4．#include<>

classA{

inta,b;

public:

A（）{

a=b=0;

cout<<"DefaultConstructingObject"<<''<

}

A（intaa,intbb）{

a=aa;b=bb;

cout<<"ConstructingObject"<<''<

}

~A（）{cout<<"DestructingObject"<<''<

};

voidmain（）

{

Ax,y（2,3）,z（4,5）;

}

答案：

DefaultConstructingObject00

ConstructingObject23

ConstructingObject45

DestructingObject45

DestructingObject23

DestructingObject00

5．#include<>

template

classFF{

TTa1,a2,a3;

public:

FF（TTb1,TTb2,TTb3）{

a1=b1;a2=b2;a3=b3;

}

TTSum（）{returna1+a2+a3;}

};

voidmain（）

{

FFx（2,3,4）,y（5,7,9）;

cout<<（）<<''<<（）<

}

答案：

921

6：

分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。

#include<>

classone

{

inta1,a2;

public:

one（intx1=0,x2=0）;

};

voidmain（）

{

onedata（2,3）;

cout<<<

}

分析：

出错原因：

构造函数参数表语法错；构造函数没有函数体；类的对象不能直接访问类的私有成员。

改正后的程序如下：

#include<>

classone

{inta1,a2;

public:

one（intx1=0,intx2=0）{a1=x1;a2=x2;}

intgeta1（）{returna1;}

intgeta2（）{returna2;}

};

voidmain（）

{onedata（2,3）;

cout<<（）<

}

7：

分析以下程序的错误原因，给出修改方案使之能正确运行。

#include<>

classAmplifier{

floatinvol,outvol;

public:

Amplifier（floatvin,floatvout）

{invol=vin;outvol=vout;}

floatgain（）;

};

Amplifier:

floatgain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp,;

cout<<"\n\nThegainis=>"<

}

分析：

成员函数在类体外定义格式是：

函数返回类型类名：

：

成员函数名（参数表）；成员函数调用格式是：

对象名.成员函数名（参数表）。

改正后的程序如下：

#include<>

classAmplifier

{floatinvol,outvol;

public:

Amplifier（floatvin,floatvout）{invol=vin;outvol=vout;}

floatgain（）;

};

floatAmplifier:

gain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp,;

cout<<"\n\nThegainis=>"<<（）<

}

8：

下列程序的运行结果是。

#include<>

classpoint

{intx,y;

public:

point（inta,intb）

{x=a;y=b;

cout<<"callingtheconstructorfunction."<

}

point（point&p）;

friendpointmove（pointq）;

~point（）{cout<<"callingthedestructorfunction.\n";}

intgetx（）{returnx;}

intgety（）{returny;}

};

point:

point（point&p）

{x=;y=;

cout<<"callingthecopy_initializationconstructorfunction.\n";

}

pointmove（pointq）

{cout<<"OK!

\n";

inti,j;

i=+10;

j=+20;

pointr（i,j）;

returnr;

}

voidmain（）

{pointm（15,40）,p（0,0）;

pointn（m）;

p=move（n）;

cout<<"p="<<（）<<","<<（）<

}

答案：

callingtheconstructorfunction.

callingthecopy_initializationconstructorfunction.

OK！

callingtheconstructorfunction.

callingthecopy_initializationconstructorfunction.

callingthedestructorfunction.

P=25,60

callingthedestructorfunction.

说明：

（1）构造函数执行三次，分别初始化主函数中的对象m，p和move函数中的对象r。

（2）拷贝构造函数共执行了三次。

第一次，初始化对象n；第二次在调用函数move（）时，实参n给形参q进行初始化；第三次是执行函数move的returnr；语句时，系统用r初始化一个临时对象时使用了拷贝构造函数。

（3）析构函数执行了六次。

在退出函数move时释放对象r和q共调用二次；返回主函数后，临时对象赋值给对象p后，释放临时对象又调用一次析构函数；最后退出整个程序时释放对象m，n和p调用三次。

四、编程题

1.根据下面类中Count函数成员的原型和注释写出它的类外定义。

classAA{

int*a;

intn;

intMS;

public:

voidInitAA（intaa[],intnn,intms）{

if（nn>ms）{cout<<"Error!

（1）;}

MS=ms;

n=nn;

a=newint[MS];

for（inti=0;i

}

intCount（intx）;根据下面类中Search函数成员的原型和注释写出它的类外定义。

classAA{

int*a;

intn;

intMS;

public:

voidInitAA（intaa[],intnn,intms）{

if（nn>ms）{cout<<"Error!

（1）;}

MS=ms;

n=nn;

a=newint[MS];

for（inti=0;i

}

intSearch（intx）;根据下面类中MaxMin函数成员的原型和注释写出它的类外定义。

classAA{

int*a;

intn;

intMS;

public:

voidInitAA（intaa[],intnn,intms）{

if（nn>ms）{cout<<"Error!

（1）;}

MS=ms;

n=nn;

a=newint[MS];

for（inti=0;i

}

intMaxMin（int&x,int&y）;根据下面类中Compare函数成员的原型和注释写出它的类外定义。

classAA{

int*a;

intn;

intMS;

public:

voidInitAA（intaa[],intnn,intms）{

if（nn>ms）{cout<<"Error!

（1）;}

MS=ms;

n=nn;

a=newint[MS];

for（inti=0;i

}

intCompare（AAb）;根据下面类中CompareBig函数成员的原型和注释写出它的类外定义。

classAA{

int*a;

intn;

intMS;

public:

voidInitAA（intaa[],intnn,intms）{

if（nn>ms）{cout<<"Error!

（1）;}

MS=ms;

n=nn;

a=newint[MS];

for（inti=0;i

}

intCompareBig（AAb）;//比较*this与b的大小，从前向后按两数组

//中的对应元素比较，若*this中元素值大则返回1，若b中

//元素值大则返回-1，若相等则继续比较下一个元素，直到

//一个数组中无元素比较，此时若两者的n值相同则返回0，

//否则若*this中的n值大则返回1，若b中的n值大则返回-1。

};

答案：

intAA:

CompareBig（AAb）

{

intk;

if（n>k=;elsek=n;

for（inti=0;i

if（a[i]>[i]）return1;

elseif（a[i]<[i]）return-1;

if（k==n&&k==return0;

elseif（k

elsereturn-1;

}

展开阅读全文