C++复习题武汉大学.docx
《C++复习题武汉大学.docx》由会员分享，可在线阅读，更多相关《C++复习题武汉大学.docx（44页珍藏版）》请在冰豆网上搜索。
C++复习题武汉大学
18911121315！
1620212324252628293137（三道没号的）27293031321267无号414445467810122037无号303133
1）下列关于对象概念的描述中，（a）是错误的。
A.对象就是C语言中的结构变量
B.对象代表着正在创建的系统中的一个实体
C.对象是一个状态和操作（或方法）的封装体
D.对象之间的信息传递是通过消息进行的
2）#include
#include
voidmain（）
{
cout.fill（'*'）;
cout.width（10）;
cout<<"123.45"<cout.width（8）;
cout<<"1234.45"<cout.width（4）;
cout<<"1234.45"<}
程序运行的结果是（B）。
A.****123.45**1234.45*1234.45
B.****123.45*1234.451234.45
C.****123.45**1234.45*1234.45
D.*****123.45***1234.45*1234.45
3）分析下面的C++代码段：
classEmployee
{
private:
inta;
protected:
intb;
public:
intc;
};
classDirector:
publicEmployee{};
在Main（）中，下列（c）操作是正确的。
a）Employeeobj;
obj.b=1;
b）Directorboj;
obj.b=10;
c）Employeeobj;
obj.c=3;
d）Directorobj;
obj.a=20;
4）#include
#defineSQR（x）x*x
voidmain（）
{
inta=10,k=2,m=1;
a/=SQR（k+m）;
cout<}
执行上面的C++程序后，a的值是（b）。
（选择一项）
a）10
b）2
c）9
d）0
不要忘了sqr中的x不是一个变量，编译器仅仅是把x替换为10+2，因此sqr（10+2）的结果是10+2*10+2，当然是32咯。
为了避免这种情况，这样写就没问题了：
#definesqr（x）（（x）*（x））本文出自51CTO.COM技术博客
5）在C++语言中，下列语句中，正确的是（d）。
a）voidmain（）
{
cout<intx=7;
return0;
}
b）char*s="Hello,Myworld";
deletes;
c）类Time的析构函数：
void~Time（int）;
d）在类Employee中声明如下的构造函数：
Employee（constchar*,constchar*）;
e）类Time的部分定义：
classTime
{
public:
inthour=0;
intmonth=0;
intsecond=0;
}
6）
7）#include
{
//Thisismyfirstprogram
cout<<"MyfirstprograminC++";
}
这段C++程序的输出是（d）。
a）MyfirstprograminC++
b）Thisismyfirstprogram
c）MyfirstPrograminC
d）Noneoftheabove
8）#include
classexample
{
private:
staticintnum;
public:
example（）{num++;cout<~example（）{num--;cout<};
intexample:
:
num=1;
voidmain（）
{
exampleobject1;
exampleobject2;
}
上面Ｃ＋＋程序的输出结果是（d）。
a）1111
b）2121
c）2232
d）2321
e）1212
9）在c++中下列声明之间有（B）不同。
constint*myptr1=#
int*constmyptr2=#
A.根本没有不同
B.不能用myptr1改变常整数的内容，然而可以用myptr2改变它指向的整数的内容
C.不能用myptr2改变常整数的内容，然而可以用myptr1改变它指向的整数的内容
10）在C++中，一个函数为voidf（int=1,char='a'）,另一个函数为voidf（int）,则它们（b）。
a）不能在同一程序中定义
b）可以在同一程序中定义并可重载
c）可以在同一程序中定义，但不可重载
d）以上说法都不正确
11）C++基类中的private成员通过（d）类型的继承，可以被派生类访问。
a）public
b）protected
c）private
d）任何类型的继承都不能使得派生类可以访问基类的private成员
12）下列概念（）体现了面向对象的多态性。
（b）
a）虚基类
b）虚函数
c）对象容器
d）封装
13）#include
classOne
{
public:
voiddisplay（）{cout<<"1"<<"";}
};
classTwo:
publicOne
{
public:
voiddisplay（）{cout<<"2"<<"";}
};
voidmain（）
{
Onefirst;
Twosecond;
first.display（）;
second.display（）;
One*p=&first;
p->display（）;
p=&second;
p->display（）;
}
在C++中，以上程序的运行结果为（c）。
a）1112
b）1212
c）1211
d）2112
14}
15）对于C++类
classdate
{
private:
intday,month,year;
public:
voidsetdate（int,int,int）;
print（）;
};
下列描述是正确的（d）。
（选择两项）
a）setdate（）函数内参数没有写变量名，因而它是错误的；
b）year是私有的,print（）是公有的，setdate（）可以访问day，而print（）不能访问day
c）setdate（）可以访问day，而print（）不能访问day
d）setdate（）可以访问day，而print（）也可以访问day
16）在C++中，可以重载的运算符有（d）。
a）sizeof（）
b）:
:
c）.*
d）++
17）#include
classdate
{
private:
intday,month,year;
public:
date（）{}
date（intx,inty,intz）{day=x;month=y,year=z;}
voidset（）{day=1;month=10;year=2002;}
voiddisplay（）{cout<};
voidmain（）
{
dateday1;
dateday2（10,10,2002）;
day1.set（）;
day1.display（）;
day2.display（）;
}
上面C＋＋程序运行的结果是（b）。
a）10/10/20021/10/2002
b）1/10/200210/10/2002
c）10/10/200210/10/2002
d）1/10/20021/10/2002
18）#include
classA
{
public:
A（）{cout<<"Aconstruct";}
};
classB:
publicA
{
public:
B（）:
A（）{cout<<"Bconstruct"<};
voidmain（）{Bobj;}
上面的C++程序运行的结果是（b）。
a）BconstructAconstruct
b）AconstructBconstruct
c）Aconstruct
d）Bconstruct
19）classwheel
{
intnum;
public:
wheel（intw）{num=w;}
};
classcar
{
wheelcarWheel;
public:
//写出car的构造函数
}
在C++中，上面程序中，空白处正确的语句是（b）。
a）voidcar（intn）:
:
carWheel（n）{}
b）car（intn）:
carWheel（n）{}
c）voidcar（intn）:
:
carWheel（n）{}
d）car（intn）:
:
carWheel（n）{}
20）下面关于模版说法正确的是（a）。
a）类模版提供了一种对类中类型进行参数化的方法;在实例化模版类时，实际的数据类型会代替与类成员或方法相关联的类型参数
b）类模版中必须包含类成员与类方法
c）不可以用自定义的数据类型实例化一个模版类
d）类模版中类方法的参数必须用占位符替代，而不能使用实际数据类型
21）在类的说明符中，被指定为私有的数据可以被以下（c）访问。
a）程序中的任何函数
b）其他类的成员函数
c）类中的成员函数
d）派生类中的成员函数
22）在C++程序中出现（c）情况时，将引发一个异常。
a）在main函数的结尾少了一个大括号
b）for循环语法错误
c）被零除或数组溢出
d）数组没有被赋满值
23）classEmployee
{
private:
inta;
protected:
intb;
public:
intc;
voiddisplay（）;
};
classDirector:
publicEmployee
{
public:
voidshow（）;
};
在C++中，以下操作正确的是（d）。
a）voidEmployee:
:
show（）{cout<b）voidDirector:
:
display（）{cout<c）voidDirector:
:
show（）{cout<d）voidDirector:
:
show（）{cout<24）#include
classX
{
private:
intnum;
public:
X（intintx）{num=intx;}
X（X&Y）
{
num=++Y.num;
}
voiddisp（）{cout<};
voidmain（）
{
Xa（10）;
Xb（a）;
a.disp（）;
b.disp（）;
}
在C++中，以上程序的运行结果为（c）。
a）1010
b）1011
c）1111
d）1110
25）在C++中，下列类的成员函数（c）属于纯虚函数。
A）voiddisplay（）;
B）Virtualvoiddisplay（）;
C）Virtualvoiddisplay（）=0;
D）Virtualvoiddisplay（）{inta=0};
26）C++中，下列关于继承的描述。
（a）是错误的。
a）继承是基于对象操作的层面而不是类设计的层面上的
b）子类可以继承父类的公共行为
c）继承是通过重用现有的类来构建新的类的一个过程
d）将相关的类组织起来，从而可以共享类中的共同的数据和操作
27）#include
int&func（int&num）
{
num++;
returnnum;
}
voidmain（）
{
intn1,n2=5;
n1=func（n2）;
cout<}
上面C++程序运行结果是（c）.（选择一项）
a）56
b）65
c）66
d）55
28）#include
classA
{
public:
A（）{}
~A（）{cout<<"Adestroy";}
};
classB:
publicA
{
public:
B（）:
A（）{}
~B（）{cout<<"Bdestroy";}
};
voidmain（）{Bobj;}
上面的C++程序运行的结果是（a）。
a）BdestroyAdestroy
b）AdestroyBdestroy
c）Adestroy
d）Bdestroy
29）如果基类A和A的派生类B中都有成员函数func（）；
要在派生类的func（）中调用同名的基类的func（）成员函数，下列（b）操作下正确的。
a）func（）;
b）A:
:
func（）;
c）B:
:
func（）;
d）A.func（）;
30）#include
classA
{
public:
virtual~A（）{cout<<"A"<<"";}
};
classB:
publicA
{
~B（）{cout<<"B"<<"";}
};
voidmain（）
{
A*pObj=newB;
deletepObj;
}
上面的C++程序的运行结果是（d）.
a）A
b）B
c）AB
d）BA
31）在C++中,（b）一定不能创建类的对象和实例.
a）虚基类
b）抽象类
c）基类
d）派生类
32）读下面C++程序：
#include
classline
{
public:
intcolor;
};
intstartx;
classbox
{
private:
intupx,upy;
intlowx,lowy;
public:
intcolor;
intsame_color（linea,boxb）;
voidset_color（intc）
{
color=c;
}
voiddefine_line（intx,inty）
{
startx=x;
}
};
int（在此添入答案）same_color（linea,boxb）
{
if（a.color==b.color）
return1;
return0;
}
在括号中添入（b）,该程序才能正常运行.
a）line:
:
b）box:
:
c）line->
d）box->
33）在c++中，定义了以下的一个类
classexample
{
Private:
intdata;
Public:
intset（intparam）;
};
下列操作（d）是正确的
a）exampleobject;
object.data=10;
b）exampleobject;
data=object.set（10）;
c）exampleobject;
object.data=object.set（10）
d）exampleobject;
34）读下面C++程序：
#include
classvehicle
{
protected:
intwheels;
public:
vehicle（intin_wheels=4）{wheels=in_wheels;}
intget_wheels（）{returnwheels;}
};
voidmain（）
{
vehicleunicyclel;
vehicleunicycle2（3）;
cout<<"Theunickele1has"<cout<<"Theunickele2has"<}
编译后输出结果为（c）。
a）Theunicycle1has0wheel.
Theunicycle2has3wheel.
b）Theunicycle1has4wheel.
Theunicycle2has4wheel.
c）Theunicycle1has4wheel.
Theunicycle2has3wheel.
d）Theunicycle1has0wheel.
Theunicycle2has4wheel.
35）在C++中，编写一个内联函数func,使用类型int的参数，求其平方并返回，返回值为int类型，
下列定义（b）是正确的
a）intfunc（intx）{return（x*x）;}
b）inlineintfunc{return（x*x）;}
c）intinlinefunc{return（x*x）;}
d）intfunc（intx）{return（x*x）;}
36）classsample
{
private:
intdata;
public:
intset（）;
};
在C++中，下列对类sample的成员函数set（）的定义（b）正确的。
a）intset（）{data=10;returndata;}
b）intsample:
:
set（）{data=10;returndata;}或intsample:
:
set（）{sample:
:
data=10;returndata;}
c）intsample:
:
set（）{:
:
data=10;returndata;}
d）intset（）{sample:
:
data=10;returndata;}
37）在C++中,运算符new的作用是（c）
a）创建名为new的对象
b）获取一个新类的内存
c）返回指向所创建对象的指针，并为创建的对象分配内存空间
d）返回为所创建的对象分配内存的大小
对类的构造函数和析构函数描述正确的是（A）
A）构造函数可以重载，析构函数不能重载
B）构造函数不能重载，析构函数可以重载
C）构造函数可以重载，析构函数也可以重载
D）构造函数不能重载，析构函数也不能重载
下面程序的运行结果为（C）
#include（iostream.h>
classA
{
intnum;
public：
A（inti）{num=i;}
A（A&a）{num＝a.num++;}
voidprint（）{cout< };
voidmain（）
{
Aa
（2），b（a）;
a.print（）;
b.print（）;
A）23 B）33 C）32 D）22
下面对静态数据成员的描述中，正确的是（A）
A）静态数据成员是类的所有对象共享的数据
B）类的每个对象都有自己的静态数据成员
C）类的不同对象有不同的静态数据成员值
D）静态数据成员不能通过类的对象调用
27）如果类A被说明成类B的友元，则（D）
A）类A的成员即类B的成员
B）类B的成员即类A的成员
C）类A的成员函数不得访问类B的成员
D）类B不一定是类A的友元
（28）可以用p.a的形式访问派生类对象p的基类成员a,其中a是（d）
A）私有继承的公有成员
B）公有继承的私有成员
C）公有继承的保护成员
D）公有继承的公有成员
29）建立派生类对象时,3种构造函数分别是a（基类的构造函数）、b（成员对象的构造函数）、c（派生类的构造函数）这3种构造函数的调用顺序为（a）
A）abc
B）acb
C）cab
D）cba
（30）下面关于虚函数的描述，错误的是（B）
A）在成员
升级会员 