C++面向对象程序设计练习题.docx
《C++面向对象程序设计练习题.docx》由会员分享，可在线阅读，更多相关《C++面向对象程序设计练习题.docx（25页珍藏版）》请在冰豆网上搜索。
C++面向对象程序设计练习题
C++面向对象程序设计练习题
（1）
一、选择题
（1）C++语言对C语言做了很多改进,C++语言相对于C语言的最根本的变化是
A）增加了一些新的运算符
B）允许函数重载，并允许设置缺省参数
C）规定函数说明符必须用原型
D）引进了类和对象的概念
（2）下列哪个是C++语言的有效标识符?
A）_No1B）No.1C）12345D）int
（3）设有定义intx;floatv;，则10+x+v值的数据类型是
A）int B）doubleC）floatD）不确定
（4）下列程序的执行结果为
#include
voidmain（）
{
inta＝3，b＝0;
int*p＝&a：
b=+a++;
cout<<*P<<”，”<}
A）3，4B）4，3C）3,4D）4,4
（5）下面程序的运行结果为
#include
voidmain（）
{
for（inta=0，x＝0;!
x&&a<=10;a++）
{
a++;
}l
cout<}
A）10B）11C）12D）0
（6）下列选项，不正确的是
A）for（inta=1;a<=10;a++）;
B）inta=1;
do
{
a++;
}while（a<＝10）
C）inta=1：
while（a<＝10）
{
a++;
}l
D）for（inta=1;a<=10;a++）a++;
（7）下面关于数组的初始化正确的是
A）charstr[]＝{‘a'，’b'，'c‘}
B）charstr[2]＝{'a'，'b'，'c’}
C）charstr[2][3]＝{{'a‘，'b’}，{’e’，'d’}，{’e’，‘f'}}
D）charstr[]＝{'a'，'b'，'c’}
（8）下列程序的输出结果为
#include
voidmain（）
{
char，a[]＝{”hello"，”the"，”world”};
char**pa＝a：
pa++;
cout<<*pa<}
A）hello
B）the
C）world
D）hellotheworld
（9）决定C++语言中函数的返回值类型的是
A）return语句中的表达式类型
B）调用该函数时系统随机产生的类型
C）调用该函数时的主调用函数类型
D）在定义该函数时所指定的数据类型
（10）下列程序的输出结果是
#include
intmin（inta，intB）
{
if（aelsereturnB;
return0;
}
voidmain（）
{
cout<}
A）0B）1C）2D）3
（11）下列程序的运行结果为
#include
voidprint（doublea）
{
cout<<++a;
}
voidprint（inta，intb）
{
cout<}
voidmain（）
{
print（1.2）;
cout<<””;
print（3,4）;
}
A）1.234
B）2.234
C）1.243
D）2.243
（12）对类成员访问权限的控制，是通过设置成员的访问控制属性实现的，下列不是访问控制属性的是
A）公有类型
B）私有类型
C）保护类型
D）友元类型
（13）在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是
A）友元函数
B）虚函数
C）构造函数
D）析构函数
（14）类的析构函数的作用是
A）一般成员函数的初始化
B）类的初始化
C）对象的初始化
D）删除类创建的对象
（15）下列说法正确的是
A）内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方
B）内联函数在编译时是将该函数的月标代码插入每个调用该函数的地方
C）类的内联函数必须在类体内定义
D）类的内联函数必须在类体外通过加关键字inline定义
（16）下面对静态数据成员的描述中，正确的是
A）静态数据成员可以在类体内进行初始化
B）静态数据成员不可以被类的对象调用
C）静态数据成员不能受private控制符的作用
D）静态数据成员可以直接用类名调用
（17）下面对于友元函数描述正确的是
A）友元函数的实现必须在类的内部定义
B）友元函数是类的成员函数
C）友元函数破坏了类的封装性和隐藏性
D）友元函数不能访问类的私有成员
（18）在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是
A）派生类的对象可以赋给基类的对象
B）派生类的对象可以初始化基类的引用
C）派生类的对象可以直接访问基类中的成员
D）派生类的对象的地址可以赋给指向基类的指针
（19）下面程序的运行结果为
#include
classA
{
public：
A（）{cout<<”1”;}
～A（）{cout<<”2”;}
}
classB：
publicA
{
public：
B（）{cout<<”3”;}
～B（）{cout<<”4”;}
}
voidmain（）
{
Bb;
}
A）1234
B）1324
C）1342
D）3142
（20）下列关于虚基类的描述，错误的是
A）设置虚基类的目的是为了消除二义性
B）虚基类的构造函数在非虚基类之后调用
C）若同一层中包含多个虚基类，这些虚基类的构造函数按它们说明的次序调用
D）若虚基类由非虚基类派生而来，则仍然先调用基类构造函数，再调用派生类的构造函数
（21）下列关于多态性的描述，错误的是
A）C++语言的多态性分为编译时的多态性和运行时的多态性
B）编译时的多态性可通过函数重载实现
C）运行时的多态性可通过模板和虚函数实现
D）实现运行时多态性的机制称为动态绑定
（22）下列运算符中，在C++语言中不能重载的是
A）*B）>=C）：
：
D）/
（23）当使用fstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为
A）ios：
：
in
B）ios：
：
out
C）ios：
：
in|ios：
：
out
D）以上都不对
（24）下列程序的运行结果是
#include
classA
{
inta;
public：
A（）{a＝0;}
A（intas）
{
a=as;
cout<}
};
voidmain（）
{
Ax，y
（2），z（3）;
cout<}
（25）下面程序的输出结果是
#include
classexample
{
inta：
public：
example（intb）{a=n++;}
voidprint（）{a=a+1;cout< voidprint（）const{cout<}
voidmain（）
{
examplext（3）;
constexampley
（2）;
x.print（）;
y.print（）;
}
A）22B）43C）42D）32
二、填空题，请将答案分别写在答题卡中序号为【1】～【10】的横线上。
（1）在面向对象的程序设计中，类描述的是具有相似性质的一组【1】。
（2）在C++语言的结构化程序设计中，【2】是程序的基本组成单元;在C++语言的面向对象设计框架中，【3】是程序的基本组成单元。
（9）C++语言提供的基本控制结构可以分为3种类型：
顺序结构、【4】和循环结构。
（10）C++语句constchar*constp="hello",,所定义的指针p和它所指的内容都不能被【5】。
（11）C++语言的参数传递机制包括传值和传地址两种，如果调用函数时，需要改变实参或者返回多个值，应该采取【6】方式。
（12）对于下面定义的类MyClass,请在函数f（）中添加对象成员把n的值修改为50。
classMyClass
{
public：
MyClass（intx）{n＝x;}
voidSetNum（intn1）{n＝n1;}
private：
intn;
};
voidf（）
{
MyClass*ptr＝newMyClass（45）;
【7】}
（13）继承的方式有公有继承、私有继承和【8】3种。
（14）表达式operator+（x,y）还可以表示为【9】。
（15）类模板的使用实际士：
是将类模板实例化成一个具体的【10】。
三、名词解释
1、继承性
2、友元
四、简答题
1、友元函数的特点：
2、用类模板定义对象时用以下形式：
3、如果在类模板外定义成员函数，应写成类模板形式：
4、声明一个类模板，利用它分别实现两个整数、浮点数和字符的比较，求出大数和小数。
5、什么是重载？
6、运算符重载函数的一般语法格式为：
C++面向对象程序设计练习题
（2）
一、选择题
（1）下面关于C++语言的描述错误的是
A）C++语言支持数据封装
B）C++语言中引入友元没有破坏封装性
C）C++语言允许函数名和运算符重载
D）C++语言支持动态联编
（2）设有定义inta＝1;floatf＝1.2;charc＝’a';，则下列表示错误的是
A）++a;B）f--;
C）C++;D）8++;
（3）下列程序的运行结果为
#include
voidmain（）
{
inta＝2：
intb＝a+1;
cout<}
A）0.66667B）0
C）0.7D）0.66666666…
（4）设inta＝1，b＝2;，则（a++）+b和a+++b这两个表达式的值分别为
A）3，3B）3，4C）4，3D）4，4
（5）下面程序的运行结果为
#include（iostream．h>
voidmain（）
{
chara＝'3‘;
switch（a）
{
case'3‘：
cout<<”3”;
case'2’：
cout<<”2”;break;
default：
cout<<”1”;
}
}
A）3B）321C）31D）3
（6）存在定义inta[10]，x，*pa;，若pa=&a[0]，下列的哪个选项和其他3个选项不是等价的?
A）x＝*pa;B）x＝*（a+l）;C）x＝*（pa+1）;D）x＝a[1];
（7）下面程序的运行结果为
#include
voidswap（int&a，intb）
{
inttemp;
temp=a++;
a＝b;
b=temp;
}
voidmain（）
{
inta＝2，b＝3;
swap（a，b）：
cout<}
A）2，3B）3，2C）2，2D）3，3
（8）一个函数功能不太复杂但要求被频繁调用，应选用
A）内联函数B）重载函数C）递归函数D）嵌套函数
（9）下面关于C++语言变量的叙述错误的是
A）在C++语言中变量分为auto，static，extern和register四种存储类型
B）自动变量和外部变量的作用域为整个程序
C）内部静态变量的作用域是定义它的函数
D）外部静态变量的作用域是定义它的文件
（10）为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为
A）publicB）protectedC）privateD）static
（11）在C++语言程序中，对象之间的相互通信通过
A）继承实现B）调用成员函数实现
C）封装实现D）函数重载实现
（12）类的析构函数是在什么时候调用的?
A）类创建时B）创建对象时C）删除对象时D）不自动调用
（13）通常拷贝构造函数的参数是
A）某个对象名B）某个对象的成员名
C）某个对象的引用名D）某个对象的指针名
（14）下面程序的运行结果为
#include
classA
{
staticintn;
public：
A（）{n＝1;}
A（intnum）{n＝num;}
voidprint（）{coot<}
intA：
：
n=2：
voidmain（）
{
Aa.b（3）;
a.print（）;
b.pint（）;
cout<}
A）11B）13C）23D）33
（15）下列不是描述类的成员函数的是
A）构造函数B）析构函数C）友元函数D）拷贝构造函数
（16）继承机制的作用是
A）信息隐藏B）数据封装C）定义新类D）数据抽象
（17）在C++语言类体系中，不能被派生类继承的有
A）转换函数B）构造函数C）虚函数D）静态成员函数
（18）下面程序的运行结果是
#include
classbase
{
protected：
inta;
public：
base（）{cout<<”0”;}
classbasel：
virtualbase
}
public：
base1（）{cout<<”1”;}
};
classbase2：
virtualbase
{
public：
base2（）{cout<<”2”;（
};
classderived：
publicbase1，publicbase2
{
public：
derived（）{cout<<”3”;}
};
voidmain（）
{
derivedobj;
cout<}
A）0123B）3120C）0312D）3012
（19）对于类定义
classA{
public：
virtualvoidfuncl（）{}
voidfunc2（）{}
};
classB：
publicA
{
public：
voidfuncl（）{cout<<"classBfunc1”下面正确的叙述是
A）A：
：
func2（）和B：
：
funcl（）都是虚函数
B）A：
：
func2（）和B：
：
funcl（）都不是虚函数
C）B：
：
funcl（）是虚函数，而A：
：
func2（）不是虚函数
D）B：
：
funcl（）不是虚函数，而A：
：
func2（）是虚函数
（20）下面关于运算符重载的描述错误的是
A）运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算符的语法结构
B）不是所有的运算符都可以进行重载
C）运算符函数的调用必须使用关键字operator
D）在C++语言中不可通过运算符重载创造出新的运算符
（21）下面程序的运行结果是
#include
intfun（inta[]．intn）
{
intresult＝l：
for（inti＝1;iresult＝result*a[i];
returnresult;
}
voidmain（）
{
inta[3]={3，4，5};
cout<}
A）12;
B）15;
C）20;
D）60
（22）下面程序的运行结果是
#include
voidman（）
{
inti＝1;
while（i<=8）
if（++i%3!
＝2）continue;
elsecout<}
A）25B）36C）258D）369
（23）下列程序的运行结果为
#include
template
classFF
{TTa1,a2,a3;
public：
FF（TTb1，TTb2，TTb3）}al＝b1;a2=b2;a3＝b3;
TTSum（）{returnal+a2+a3;}
};
voidmain（）
{FFx（int（1，l），2，3），Y（int（4，2）,5,6）：
cout二、填空题，请将答案分别写在答题卡中序号为【1】～【7】的横线上。
（1）在C++中封装性、继承性和【1】是面向对象思想的主要特征。
（2）下面程序的结果为【2】
BR>#include
voidmain（）
{
inta＝1，b=2：
boolc=1;
if（（a>b）‖C）cout<<”true”cout<<”false”<}
（3）C++程序是从【3】函数开始执行的。
（4）假定A为一个类，则语句A（A&A）为该类【4】。
（5）派生类构造函数的执行顺序是先执行【5】的构造函数．然后执行成员对象的构造函数，最后执行【6】的构造函数。
（6）类模板不同于函数模板类模板只可用【6】型函数。
（7）下列程序的执行结果为【7】。
#include（iostream.h>
voidmain（）
{
Cout.fill（’*’）;
cout.width（10）;
cout<<”hello”<}
三、简答题
1、多态类和抽象类的区别；它们的基类和派生类的定义实现代码要求有何不同。
2、析构函数的概念、多态性。
3、C++语言的五种数据类型的长度。
4、对重载函数的调用依据、不依据什么？
5、protected的用法。
6、<<、>>的功能，在什么类中定义？
什么叫流？
7、构造函数的作用？
8、在类外定义构造函数语法格式：
9、classTime
{public:
Time（）
{hour=0;
minute=0;
sec=0;
}
10、在类外定义构造函数？
11、带有形参的构造函数首部的一般格式为：
12、以Box∷Box（inth,intw,intlen）为例//在类外定义带参数的构造函数
{height=h;
width=w;
length=len;
}
用参数初始化表对数据成员初始化的一般格式为：
13、构造函数的重载？
14、使用默认参数的构造函数的好处？
15、析构函数的作用及其定义的的一般格式为：
16、假设要创建三个对象s1，s2，s3，并且在使用完毕后进行释放，其构造函数和析构函数被调用的顺序为：
C++面向对象程序设计练习题（3）
一、名词解释
1、多态性 2、构造函数
二、填空
1、类的三大基本特性__________、__________、__________。
2、C++语言的函数参数传递方式有__________。
3、含有虚函数的类称为__________，含有纯虚函数的类为__________，为克服重复继承的二义性，用__________声明的基类称为虚基类，用__________声明函数称为虚函数。
4、在含有对象成员的派生类中，构造函数的调用次序，基类的构造函数对象成员的构造函数，派生类的构造函数的调用次序？
5、派生类对基类继承控制访问有三种__________。
三、单项选择
1、那个不是C++的基本数据类型（ ）。
2、C++语言中有哪些存放在动态存储区。
（ ）
3、下面对于指针的描述不正确的是（ ）。
A、指针是地址变量 B、指针不能用除0以外的常量赋值
C、两个指针变量的加减法无意义 D、指针指向不同基类型的变量长度不同
4、下面对于析构函数的描述中不正确的是（ ）。
A、析构函数是内置函数 B、析构函数与类名相同
C、析构函数不能有参数 D、析构函数在对象撤销时自动执行
5、下列指针用法中错误的是（ ）。
A、inti;int*ptr=&i； B、inti;int*ptr;i=*ptr；
C、int*ptr;ptr=0; D、inti=5;int*ptr;*ptr=i;
6、派生类的对象对它的基类成员中什么是可访问的（ ）。
A、公有继承的公有成员 B、公有继承的私有成员
C、公有继承的保护成员 D、私有继承的公有成员
四、简答题
1、什么是多重继承的名字冲突？
怎样解决多重继承的名字冲突？
2、说明C++系统保留字Protected的用法。
3、什么是抽象类？
抽象类有什么特点？
4、C++语言的结束标志、语句结束标志、语句块结束标志、类定义结束标志。
5、隐式类型转换的概念。
6、类成员重载和友元重载的区别。
五、分析下列程序，写出结果
1、#include
intg=1;
voiddisp（）
{
inti=1;
staticints=1;
cout<<"g="< cout<<"i="< cout<<"s="< g=g+1;i=i+1;s=s+1;
}
intmain（）
{
while（g
disp;
return0;
}
2、#include
classAAA{
intA,B;
public:
AAA（inti,intj）
{A=i,B=j;
cout<<"Cn";
}
~AAA（）{cout<<"Dn";}
voidprint（）
{
voidAAA:
:
print（）
{cout< voidmain（）
{
AAA*a1,*a2;
a1=newAAA（1,2）
a2=newAAA（5,6）
a1->print（）;
a2->print（）;
deletea1;
deletea2;
}
3、#include
classb1{
public:
b1（intx）
{cout<An";}
~b1（）
{cout<<"Bn";}
};
classb2{
public:
b2（intx）
{cout<Cn";}
~b2（）
{cout<<"Dn";}
}
classderived:
publicb
升级会员 