面向对象程序设计复习试题(答案)

语法扩充
1.1选择题
在C++中用（D）能够实现将参数值带回。

a）数组b）指针c）引用d）上述ABC都可
考虑函数原型voidtest(inta,intb=7,char*ch="*"),下面的函数调用中，属于不合法调用的是：（C）
A)test(5)B)test(5,8)C)test(6,"#")D)test(0,0,"*")；
已知:intm=10；下列表示引用的方法中，正确的是：（C）
A)
C)
在
A)
对
在
A)
C)
A)
C)
A)intFunc(int，int，int)；B)doubleFunc(int，int)；
C)doubleFunc(double，double)；D)doubleFunc(int，double)；
下面的哪个保留字不能作为函数的返回类型（C）
A)voidB)intC)newD)long
一个函数功能不太复杂，但要求被频繁调用，选用（A）。

A.内联函数
B.重载函数
C.递归函数
D.嵌套函数
已知函数f的原型为：voidf(int&a,char*b)；变量s,t的定义是：ints；chart[]="ABCD"；
把s和t分别作为第一参数和第二参数来调用函数f，正确的调用语句是（C）
Af(&s,&t)；Bf(&s,t)；Cf(s,t)；Df(s,&t)；
若定义cin>>str;
当输入
MicrosoftVisualStudio6.0！
所得结果是str=（B）。

A、MicrosoftVisualStudio6.0！
B、Microsoft
C、MicrosoftVisual
D、MicrosoftVisualStudio6.0
.函数模板（C）。

A、代表某一具体函数
B、与模板函数是同一个函数
C、与某一个具体的数据类型连用
D
在
A
B
C
D
A
C
1.2
1。

2
3
int*&p=c;
p=&b;
4、假设有如下函数定义:voidFun(intx,inty=100);则语旬Fun(5)语句__Fun(5，100)_等价。

5、在一个C++程序中,每个变量都必须遵循__先定义后使用__的原则。

6、下面是一个求数组元素之和的程序。

主程序中定义并初始化了一个数组，然后计算该数组各元素之和,并输出结果。

函数TotalSum计算数组元素之和。

请完成下列程序。

#include<iostream.h>
__int?Totalsum(int?array[],int?len)__;
voidmain()
inta[5]={2,3,6,8,10};
__intTotal___;
Total=Totalsum(a,5);
cout<<"Sumofarray:"<<Total<<endl;
}
intTotalsum(intarray[],intlen)
{
____intsum=0____;
for(intI=0;____I<len____;I++)
____sum+=array[I]_____;
即在该形
则编译时
C、引用与指针的区别
D、内联函数使用上的限制
E、定义带默认参数值函数的规则
F、指针与常量的关系
1.4程序阅读题
1）写出下列程序的运行结果。

#include<iostream.h>
voidmain()
int&p=x;
x=10;
p=x+10;
cout<<x<<","<<p<<endl;
}
结果：20,20
2）写出下列程序的运行结果。

#include<iostream.h>
intf(inta)
{
}
{
}
{
}
结果：
m=3
n=2
3)
{
}
voidmain()
{
intnum=10;
cout<<"Themain'snumis"<<num<<endl;
Fun();
{
intnum=30;
cout<<"TheField'snumis"<<num<<endl;
}
cout<<"Themain'snumis"<<num<<endl;
Themain'snumis10
TheFun'snumis20
TheField'snumis30
Themain'snumis10
类和对象
CC1()；//(B)
public:
CC1(intval)；//(C)
~CC1()；//(D)
}；
类的指针成员的初始化是通过函数完成的，这个函数通常是：(B) A)析构函数B)构造函数C)其它成员函数D)友元函数
关于构造函数的说法，不正确的是：（A）
A)没有定义构造函数时，系统将不会调用它B)其名与类名完全相同C)它在对象被创建时由系统自动调用D)没有返回值
通常拷贝构造函数的参数是：（C）
A)对象名B)对象的成员名C)对象的引用名D)对象的指针名
关于成员函数特征的描述中，错误的是：（A）
A)成员函数一定是内联函数B)成员函数可以重载
C)成员函数可以设置参数的默认值D)成员函数可以是静态的
下列关于构造函数的描述中，错误的是：（D）
A)构造函数可以设置默认参数；B)构造函数在定义类对象时自动执行
C)构造函数可以是内联函数；D)构造函数不可以重载
有如下类声明“classA{intx；……}；”，则A类的成员x是：（B）
A)公有数据成员B)私有数据成员C)公有成员函数D)私有成员函数
类TM和类TN是两个独立的类，那么类TM中哪种形式的数据成员一定是不允许的：(C) A)TM*aB)TN&aC)TMaD)TNa；
A)
C)
.
A)
B)
C)
D)
.
A)
C)
A)
C)
A)0个
A)0个
．this指针存在的目的是：（B）
A)保证基类公有成员在子类中可以被访问
B)保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码
C)保证基类保护成员在子类中可以被访问
D)保证基类私有成员在子类中可以被访问
．下列关于类的权限的描述错误的是：（A）
A)类本身的成员函数只能访问自身的私有成员
B)类的对象只能访问该类的公有成员
C)普通函数不能直接访问类的公有成员，必须通过对象访问
D)一个类可以将另一个类的对象作为成员
．设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是：（B）
A)A类构造函数先执行B)成员构造函数先执行
C)两者并行执行D)不能确定
.假定有类AB，有相应的构造函数定义，能正确执行“ABa(4),b(5),c[3],*p[2]={&a,&b}；”语句，
A.
C.
A
B.
C.
D.
A
A．
A
C.
A
C.?
A
C.
下述静态数据成员的特性中，（D）是错误的。

A．说明静态数据成员时前边要加修饰符static；
B．静态数据成员要在类体外进行初始化；
C．引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符；
D．静态数据成员不是所有对象所共用的。

2.2填空题
1、在撤销类的对象时,C++程序将自动调用该对象的__析构___函数。

2、类中的构造函数是一个特殊的成员函数,它由类的对象__自动_调用，它的作用是___为对象分配内存，数据成员初始化___。

3、对类中的成员函数和属性的访问是通过__public__、__protected__和___private__这3个关键字来控制的。

4、__delete__运算符删除new运算符所动态分配的内存空间。

5、假定用户没有给一个名为MyClass的类定义析构函数,则系统为其定义的默认析构函数形式为__MyClass()__。

6、类中构造函数有__一个或多__个,析构函数有___一___个。

7、类是对具有共同属性和行为的一类事物的抽象描述，共同属性被描述为类中的___数据成员___，共同行为被描述为类中的__成员函数__。

8、若要把类FriendClass定义为类MyClass的友元类,则应在类MyClass的定义中加入语句_friendclassFriendClass；___。

9、在结构定义中,数据和成员函数默认权限是__public__。

在类定义中,数据和成员函数默认权限是__private___。

{
{
}
{
intGetNum(____MyClass______my)
{
___returnmy.x;
}
12、__new__运算符对指定类型对象动态分配内存并返回该类型的__指针__。

13、若要把函数voidFriendFunction()定义为类MyClass的友元函数,则应在类MyClass的定义中加入语句__friendvoidFriendFunction();_______。

14、类的具体表现是通过定义_对象__来操作的。

15、在定义类的对象时,C++程序将自动调用该对象的__构造___函数初始化对象自身。

16、一般情况下,按照面向对象的要求,把类中的数据成员(属性)定义为__private__权限,而把成员函数(方法)定义为__public__权限。

17、在类中定义和实现的函数称为_内联函数__。

18、非成员函数应声明为类的__友元函数__才能访问这个类的private成员。

2.3简答题
A、类的含义
B、构造函数的特点
C、拷贝构造函数的调用
D、析构函数的定义及其特点
E、静态成员的分类及各自的特点
2.4
1)
{
public:
};
{
}
{
}
{
cout<<"Thevalueofchis"<<ch<<endl;
}
MyClass::~MyClass()
{
cout<<"Thisisadestructor!"<<endl;
}
voidmain()
{
MyClassfirst,second('b');
first.Print();
second.Print();
}
运行结果：Thisisaconstructor! Thisisaconstructor! Thevalueofchisa Thevalueofchisb Thisisadestructor! Thisisadestructor!
2）写出下列程序的运行结果
{
public:
private:
intI;
};
{
j+=10;
}
{
}
{
}
voidmain()
{
MyClassfirst,second;
first.Print();
second.Print();
}
Thisisconstructor! Thisisconstructor! Thevalueofjis20 Thevalueofjis20
Thisisadestructor!
Thisisadestructor!
继承与派生
3.1选择题
.在C++中，类与类之间的继承关系具有（C）
A)
.
A)
.
}；
public
}；
A)fun()
.在保护继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（C）A)受限制B)保持不变C)受保护D)不受保护
.下面描述中，表达错误的是：（B）
A)公有继承时，基类中的public成员在派生类中仍是public的
B)公有继承时，基类中的private成员在派生类中仍是private的
C)公有继承时，基类中的protected成员在派生类中仍是protected的
D)私有继承时，基类中的public成员在派生类中是private的.下列虚基类的声明中，正确的是：（B）
A)classvirtualB:publicAB)classB:virtualpublicA
C)classB:publicAvirtualD)virtualclassB:publicA
.C++设置虚基类的目的是(A)
A)消除二义性B)简化程序C)提高运行效率D)减少目标代码
classX{
inta;
public:
};
intb;
public:
};
};
classDerived:protectedBase
{Baseb;
intj;
public:
Derived(intt);
};
在构造函数Derived的下列定义中，正确的是(B)
A.Derived::Derived(intt):b(t),j(t){}
B.Derived::Derived(intt):b(t),Base(t),j(t){}
C.Derived::Derived(intt):Base(t),j(t){}
D.Derived::Derived(intt):i(t),b(t),j(t){}
．在哪种派生方式中，派生类可以访问基类中的protected成员（B）
A)public和privateB)public、protected和private
C)protected和privateD)仅protected
在C++中，类与类之间的继承关系具有（C）
A)自反性B)对称性C)传递性D)反对称性
下列关于类的继承描述中，（A）是错误的
A)派生类可以访问基类的所有数据成员，也能调用基类的所有成员函数
B)派生类也是基类，但基类不一定具有派生类的全部属性和方法
C)继承描述类的层次关系，派生类可以具有与基类相同的属性和方法
D)一个基类可以有多个派生类，一个派生类可以有多个基类
.
A)
B)
C)
D)
A)
B)
C)
D)
A)
B)
C)
D)保护继承时基类中的public成员在派生类中是protected的
关于多继承二义性的描述中，错误的是（B）。

A)一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性
B)解决二义性的最常用的方法是对成员名的限定法
C)基类和派生类中同时出现的同名函数，也存在二义性问题
D)一个派生类是从两个基类派生出来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，可能出现二义性
下面叙述错误的是（C）。

A)派生类可以使用private派生
B)对基类成员的访问必须是无二义性的
C)基类成员的访问能力在派生类中维持不变
D)赋值兼容规则也适用于多继承的组合
派生类的构造函数的成员初始化列表中，不能包含（C）。

A)基类的构造函数
B)派生类中子对象的初始化
C)基类中子对象的初始化
D)派生类中一般数据成员的初始化
下面（B）的叙述不符合赋值兼容规则。

A)派生类的对象可以赋值给基类的对象
B)基类的对象可以赋值给派生类的对象
C)派生类的对象可以初始化基类的引用
D)
.
.C++
A)
3.2
1
2、
3
4
5、C++
6
7
8
9
{
protected:
doubledistance;___//行星距太阳的距离
intrevolve;___//行星的公转周期
public:
planet(doubled,intr)
{
distance=d;
revolve=r;
}
};
classearth:publicplanet
{
doublecircumference;//地球绕太阳公转的轨道周长
public:
//定义构造函数earth(doubled,intr)，并计算地球绕太阳公转的轨道周长。

//假定:circumnference=2*d*3.1416
___earth(doubled,intr):planet(d,r){__circumnference=2*d*3.1416;}___
//定义show()函数显示所有信息
___voidshow(){cout<<”distanceis”<<distance<<”miles,revolveis”<<revolve<<”days”<<endl;cou<<”circumferenceis“< <circumference<<endl;}___
};
{
}
10
11
12
{
public:
private:
intX,Y;
};
{
public:
intGetX(){__returnPoint:GetX();__}
intGetY(){___returnPoint:GetY();__}
intGetW(){__returnW;__}
intGetH(){__returnH;__}
private:
intW,H;
}
#include<iostream.h>
#include<math.h>
voidmain()
{
Rectanglerect(1,2,3,4);
rect.Move(5,6);
cout<<“Thedataofrect(X,Y,W,H):(“
<<rect.GetX()<<“,”<<rect.GetY()<<“,”
<<rect.GetW()<<“,”<<rect.GetH()<<“)”<<endl;
13、多继承可以视为是__单继承__的扩展。

14、在划线处填上适当的语句，完成下列程序。

#include<math.h>
classPoint
{
public:
Lineobj(1.2,3.4,5.6,7.8);
obj.show();
}
15、类继承中，缺省的继承方式是__private___。

16、当用protected继承从基类派生→个类时，基类的public成员成为派生类的__protected__成员，protected成员成为派生类的_____protected____成员。

18、__公有派生__类的对象可作为____基___类的对象处理。

19、指向基类的对象的指针变量也可以指向__公有派生类_的对象。

20、类之间的”有”关系代表__组合___，”是”关系代表__继承__。

3.3简答题
A、派生类的定义及其特点
B、单继承和多继承的概念及其关系
C、继承方式的种类及其各自的特点
D、在继承中构造函数和析构函数的调用规则
F、赋值兼容原则
G、类模板和模板类的含义及其关系
3.4
1
{
public:
};
{
public:
};
{
public:
};
{
p=&obj2;
p->Who();
p=&obj3;
p->Who();
obj2.Who();
obj3.Who();
}
答案：
classBase
classBase
classBase
classDerived1
classDerived2
2、写出下列程序的运行结果。

#include<iostream.h>
classinstrument
{
public:
voiddisplay()const{cout<<"instument::display."<<endl;} };
classpiano:publicinstrument
{
public:
};
{
public:
};
{
};
{
}
答案
3
classA
{
public:
A(chari){cout<<"A'scons."<<i<<endl;}
~A(){cout<<"A'sdes."<<endl;}
};
classB:virtualpublicA
{
public:
B(chari,charj):A(i){b=j;cout<<"B'scons."<<j<<endl;}
~B(){cout<<"B'sdes."<<b<<endl;} private:
charb;
};
classC:virtualpublicA
{
public:
C(chari,charj):A(i)
{
cout<<"C'scons."<<j<<endl;
}
};
{
public:
private:
};
{
}
答案：
D'sdes.
A'sdes.
C'sdes.
B'sdes.
A'sdes.
类的多态性
4.1选择题
.实现运行时的多态性采用(D)
A)重载函数B)构造函数C)析构函数D)虚函数
.在派生类中重新定义虚函数时，必须在下列哪方面与基类保持一致。

(A)
A)参数类型B)参数名字C)操作内容D)赋值
.当一个类的某个函数被说明为virtual时，在该类的所有派生类中的同原型函数(A)
A)都是虚函数B)只有被重新说明时才是虚函数
C)都不是虚函数D)只有被重新说明为virtual时才是虚函数
.通过下述哪一项调用虚函数时，采用动态联编。

（A）
A)
A)
C)
A)基类
假设A
在C++
A)类名
A)
B）A)不同
D)false
{
public:______//B
A(){func();}___//C
virtualvoidfunc()=0;___//D
};
实现运行时的多态性要使用（D）。

A)重载函数
B)构造函数
C)析构函数
D)虚函数
对虚函数的调用（D）。

A)一定使用动态联编
B)必须使用动态联编
C)一定使用静态联编
D)不一定使用动态联编
在派生类中重新定义虚函数时,除了（D）方面,其他方面都必须与基类中相应的虚函数保持一致。

A)参数个数
B)参数类型
C)函数名称
D)函数体
A)
B)
C)
D)
A)
B)
C)
D)
A)
B)
C)
D)
以下（
A)
B)
C)
D)
如果一个类至少有一个纯虚函数,那么就称该类为（A）。

A)抽象类
B)虚基类
C)派生类
D)以上都不对
下面的描述中,正确的是（A）。

A)virtual可以用来声明虚函数
B)含有纯虚函数的类是不可以用来创建对象的,因为它是虚基类
C)即使基类的构造函数没有参数,派生类也必须显示调用其构造函数
4.2填空题
1、在析构函数中调用虚函数时,采用__静态__联编。

2、动态联编是在__虚函数___的支持下实现的,它通过__指针或引用__来调用该函数操作。

3、动态联编中直到__程序运行__时才能确定调用哪个函数:而静态联编则是在__程序编译__时进行的。

4、C++中__不支持__虚构造函数,但___支持___虚析构函数。

5、静态联编所支持的多态性称为__编译时__多态性,动态联编所支持的多态性则称为___运行时___多态性,动态多态性由___虚函数___来支持。

6、在类定义中,将___=0__置于虚函数的函数原型的末尾可以将该函数声明为纯虚函数。

7、下列程序的运行结果如下:
{
{
{
}
8
9
#include<iostream.h>
classInstrument
{
public:
virtualvoidPrint()const{cout<<"Instrument:Print"<<endl;}
};
classPiano:publicInstument
{
public:
voidPrint()const{cout<<"Piano::Print<<endl;}
};
classGuitar:publicInstruIment
{
pub1ic:
voidPrint()const{cout<<"Guiur::Print"<<endl;}
};
voidTone(__Instrumentobj__)//第二个要求改成Instrument&obj {
__obj.print();__
}
voidmain()
{
}
{
classl_to_g:publicconvert
{
public:
__l_to_g(doubleI):convert(I){}____
voidcompute()
{
va12=va11/3.7854;
cout<<va11<<"litersis"<<val2<<"gdIons."<<endl;
}
//FahrenheittoCelsius
classf_to_c:publicconvert
{
public:
f_to_c(doubleI):convert(I){}
void&compute()
{
va12=(va11-32)*5/9;
cout<<va11<<“Fahrenheitis”<<va12<<“Celsius.”<<endl;
}
};
{
public:
__Derive1(int&I):Base(I){}___
voidPrint()
{
cout<<"Derive1'sPrint()called."<<endl;
}
};
classDerive2:publicBase
public:
Derive2(intI):Base(I){}
voidPrint(){cout<<“Derive2’sPrint()called.”<<endl;}
};
voidfun(__Base*obj____)
{
obj->Print();
};
voidmain()
{
Derive1*d1=newDerive1(1);
}
13
14
A
B
C
D
1
{
intx;
};
classDerived:publicBase
{
public:
Derived(inti,intj):Base(i){y=j;cout<<"Derived:"<<y<<endl;} ~Derived(){cout<<"~Derived:"<<y<<endl;}
private:
inty;
Base*b1=newBase(15);
deleteb1;
Base*b2=newDerived(20,25);
deleteb2;
}
答案
Base:15
~Base:15
Base:20
2
{
public:
private:
};
{
public:
private:
intz;
};
voidmain()
{
Base*d1=newDerived;
d1->Print();
Base*d2=newDerived(10,20,30);
d2->Print();
答案
x+z=0y+z=0
x+z=40y+z=50
x+z=40y+z=50
x=10y=20
x+z=0y+z=0
x=0y=0
3、阅读下列程序,回答后面提出的问题。

#include<iostream.h>
{
public:
private:
};
{
public:
};
{
public:
};
{
};
{
public:
};
voidmain()
{
Vehicle*vec;
vec=newCar;
vec->Move();
deletevec;
vec=newBus;
vec->Move();
vec=newSportsCar;
vec->Move();
deletevec;
vec=newCoupe;
vec->Move();
deletevec;
}
答案：
Carmoving.
Busmoving.
Carmoving.
5.1
下面对
A)
B)
C)
D)
A)
B)
C)
D)
A)友元
B)虚
C)成员
D)多态
在一个类中可以对一个操作符进行（D）重载。

A)1种
B)2种以下
C)3种以下
D)多种
下列关于运算符重载的描述中,正确的是（D）。

B)运算符重载可以改变优先级
C)运算符重载可以改变结合性
D)运算符重载不可以改变语法结构
下列运算符中,（C）运算符在C++中不能重载。

A)=
B)()
C)::
D)delete
下列运算符中,（A）运算符在C++中不能重载。

A〕?:
B)[]
C)new
D)&&
A)+
B)-
C)++
D)->
A)+
B)=
C)*
D)<<
A)
B)
C)
D)
.
A)类A
B)类B
C)类A
D)类B的成员函数可以访问类A的所有成员
.在C++中不能被重载的一组运算符是：（A）A)::?:.sizeofB)?:.sizeof++-> C)::?:newdeleteD)++--?:sizeof
5.2填空题
1、要在类的对象上使用运算符，除了运算符__=__和__&__以外，其他的运算符都必须被重载。

2、在C++中,只能重载为类的成员函数的运算符是___=__、__（）__、__[]__、_->__。

3、运算符()与运算符[]必须重载为__类的成员函数___。

4、利用成员函数对二元运算符重载,其左操作数为__this指针指向的当前对象__,右操作数为__成员函数参数__。

5、下列程序定义了一实部为mal,虚部为imag的复数类complex,并在类中重载了复数的+、-操作。

请将下列程序补充完整。

ClassComplex
{
A、友元的特点
B、运算符重载的含义
C、运算符重载的限制
5.4读程序题
1、写出下列程序的运行结果。

classRect
{
public:
Rect(intl,intw){length=l;width=w;}
voidPrint(){cout<<"Area:"<<length*width<<endl;}
Rectoperator*(intd){returnRect(length*d,width*d);} private:
intlength,width;
};
voidmain()
{
}
答案：
2
{
public:
{
}
{
}
voiddisplay(){cout<<"("<<x<<","<<y<<")"<<endl;} private:
intx,y;
};
voidmain()
{
Vectorv1(1,2),v2(3,4),v3,v4;
v3=v1+=v2;
v4=v1-=v2;
cout<<"v1=";
v1.display();
cout<<"v2=";
v2.display();
cout<<"v3=";
v3.display();
cout<<"v4=";
v4.display();
}
答案：
v1=(1,2)
3
{
public:
private:
};
{
}
{
returnop;
}
voidmain()
{
Coordobj(1,2),obj2(5,8);
obj.Print();
++obj;
obj2++;
obj.Print();
obj2.Print();
}
答案：x=1,y=2 x=1,y=2 x=6,y=9。