大学C期末考试题库及答案
良好的学习习惯-四川理工大学分数线
2012
一、单选题：
年大学C++期末考试题库
1.
能作为C++程序的基本单位是( C )。
A. 字符 B. 语句
C. 函数 D. 源程序文件
2. 程序中主函数的名字为（ A ）。
A. main B. MAIN C. Main D. 任意标识符
3. 关于C++与C语言的关系的描述中，（D）是错误的。
A.
C语言是C++的一个子集; B. C语言与C++是兼容的;
C.
C++对C语言进行了一些改进; D. C++和C语言都是面向对象的
4.
可用作C++语言用户标识符的一组标识符是( B)。
A. void define
+WORD B. a3_b3 _123 YN
C. for
-abc Case D. 2a DO sizeof
5. 存储以下数据，占用存储字节最多的是（ D）。
A. 0
B. ‘0’ C. “0” D. 0.0
6. 设int
a=12；则执行完语句a+=a*a；后，a的值是( C )。
A. 12
B. 144 C. 156 D. 288
7. 假设在程序中 a、b、c
均被定义成整型，所赋的值都大于1，则下列能正确表示代数式
是( D )。
A.
1.0a*b*c B. 1(a*b*c) C. 1ab(float)c D.
1.0abc
8. 以下说法中正确的是（B）。
A.
C++程序总是从第一个定义的函数开始执行
B.
C++程序总是从main函数开始执行
C.
C++函数必须有返回值，否则不能使用函数
D.
C++程序中有调用关系的所有函数必须放在同一个程序文件中
9.
下面有关构造函数的描述中，正确的是（B ）。
A. 构造函数可以带有返回值
B. 构造函数的名字与类名完全相同
C. 构造函数必须带有参数
D. 构造函数必须定义，不能缺省
10.10.在声明类时，下面的说法正确的是（ ）。
A. 可以在类的声明中给数据成员赋初值
B.
数据成员的数据类型可以是register
C.
private，public，protected可以按任意顺序出现
D.
没有用private，public，protected定义的数据成员是公有成员
11.在下面有关析构函数特征的描述中，正确的是（ A ）。
A.
一个类可以有多个析构函数 B. 析构函数与类名完全相同
C.
析构函数不能指定返回类型 D. 析构函数可以有一个或多个参数
12.构造函数是在（B ）时被执行的。
A. 程序编译
B. 创建对象 C. 创建类 D. 程序装入内存
13.
下面有关静态成员函数的描述中，正确的是（ B ）
A.
在静态成员函数中可以使用this指针
B.
在建立对象前，就可以为静态数据成员赋值
C.
静态成员函数在类外定义是，要用static前缀
D.
静态成员函数只能在类外定义
1
的表达式
abc
14.下面
有关友员函数的描述中，真确的说法是（A ）
A.
友员函数是独立于当前类的外部函数
B.
一个友员函数不可以同时定义为两个类的友员函数
C.
友员函数必须在类的外部进行定义
D.
在类的外部定义友员函数时必须加上friend关键字
15.友员的作用之一是（ A ）
A. 提高程序的运行效率 B. 加强类的封装
C. 实现数据的隐蔽性 D. 增加成员函数的种类
16.使用派生类的主要原因是（ A ）
A. 提高代码的可重用性
B. 提高程序的运行效率
C. 加强类的封装性 D.
实现数据的隐藏
17.在C++中继承方式有几中（ C ）
A. 1 B. 2 C. 3 D. 4
18.假设
已经定义好了类student，现在要定义类derived，它是从student私有派生的，则定义类d
erived
的正确写法是（ D ）
A. class
derived ：：student private{ ………….}
B.
class derived ：：student public { ………….}
C. class derived ：：public student { ………….}
D. class derived ：：private student{ ………….}
19.派生类的对象对它的基类成员中（C）是可以访问的。
A.公有继承的公有成员; B.公有继承的私有成员；
C.公有继承的保护成员； D.私有继承的公有成员。
20.
类中定义的成员默认为（A ）访问属性。
A. public B.
private C. protected D. friend
21.下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（
A ）
合适。
A. 内联函数; B. 重载函数; C.
递归调用； D. 嵌套调用。
22.C++对C语言作了很多改进，下列描述中（D）使得C语言
发生了质变，从面向过程变成了面向对象。
A. 增加了一些新的运算符；
B. 允许函数重载，并允许设置缺省参数；
C. 规定函数说明必须用原型；
D. 引进了类和对象的概念；
23.按照标识符的要求，（A）符号不能组成标识符。
A. 连接符 B. 下划线 C.大小写字母 D.
数字字符
24.下列变量名中，（ A ）是合法的。
A CHINA
B byte-size C double D A+a
25.下列各种函数中，（ C）不是类的成员函数。
A 构造函数
B 析构函数 C 友元函数 D 拷贝构造函数
26.下列（ A
）是正确的语句。
A ； B a=17 C x+y
D cout<<
27.不能作为函数重载判断的依据的是(B )
A.返回类型 B. const C.参数个数 D.
参数类型
28.通常,拷贝构造函数的参数是(C )
A.某个对象名
B.某个对象的成员名
C.某个对象的引用名
D.某个对象的指针名
29.下面对静态数据成员的描述中,正确的是(C )
A 类的不同对象有不同的静态数据成员值
B
类的每个对象都有自己的静态数据成员
C静态数据成员是类的所有对象共享的数据
D 静态数据成员不能通过类的对象调用
30.假定AB为一个类,则执行AB x;语句时将自动调用该类的( B)
A.有参构造函数 B.无参构造函数 C.拷贝构造函数 D.赋值构造函数
31.C++程序从上机到得到结果的几个操作步骤依次是( B )。
A. 编译、编辑、连接、运行 B. 编辑、编译、连接、运行
C. 编译、运行、编辑、连接 D. 编辑、运行、编辑、连接
32.假定一条定义语句为“int a[10], x,
*p=a;”，若要把数组a中下标为3的元素值赋给x，则不正确的
语句为（A ）。
A. x=p[3]; B. x=*(a+3); C. x=a[3];
D. x=*p+3;
33.关于封装，下列说法中不正确的是（D ）。
A. 通过封装，对象的全部属性和操作结合在一起，形成一个整体
B.
通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
C.
通过封装，每个对象都成为相对独立的实体
D.
通过封装，对象的属性都是不可见的
34.预处理命令在程序中都是以( B )符号开头的。
A. * B. # C. & D. @
35.存储以下数据，占用存储字节最少的是（ B ）。
A. 0
B. ‘0’ C. “0” D. 0.0
36.程序运行中需要从键盘上输入多于一个数据时，各数据之间应使用( D
)符号作为分隔符。
A. 空格或逗号 B. 逗号或回车
C. 逗号或分号 D. 空格或回车
37.假定变量m定义为“int
m=7;”，则定义变量p的正确语句为（ B ）。
A. int
p=&m; B. int *p=&m; C. int &p=*m;
D. int *p=m;
38.下面的哪个保留字不能作为函数的返回类型？ C
。
A. void B. int
C. new D. long
39.采用重载函数的目的是（ B
）。
A.实现共享 B.减少空间 C.提高速度
D.使用方便，提高可读性
40.假定AB为一个类，则( C
)为该类的拷贝构造函数的原型说明。
A. AB(AB x); B.
AB(int x); C. AB(AB& x); D. void AB(AB& x);
41、 C++对C语言作了很多改进，下列描述中（D
）使得C语言发生了质变，从面向过程变成了面向对象。
A、增加了一些新的运算符；
B、允许函数重载，并允许设置缺省参数；
C、规定函数说明必须用原型；
D、引进了类和对象的概念；
42、
所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是
(A)。
A.类 B.对象 C.函数体 D.数据块
43、
关于new运算符的下列描述中，（C ）是错误的。
A、 它可以用来动态创建对象和对象数组；
B、使用它创建的对象或对象数组可以使用运算符delete删除；
C、使用它创建对象时要调用构造函数；
D、使用它创建对象数组时必须指定初始值；
44、 （D ）不是构造函数的特征。
A、构造函数的函数名与类名相同；
B、构造函数可以重载；
C、构造函数可以设置缺省参数； D、构造函数必须指定类型说明。
45、 假定一个类的构造函数为B(int x,int
y){a=x--;b=a*y--;},则执行B x(3,5);
语句后，x.a和x.b
的值分别为(C )
A、 3和5 B、 5和3
C、 3和15 D、20和5
46、 关于成员函数特征的下列描述中，（
A）是错误的。
A、成员函数一定是内联函数； B、成员函数可以重载；
C、成员函数可以设置缺省参数值； D、成员函数可以是静态的；
47、
在公有继承的情况下，基类成员在派生类中的访问权限（B ）。
A、受限制
B、保持不变 C、受保护 D、不受保护
48、 友元的作用是（
A）。
A、提高程序的运用效率； B、加强类的封装性；
C、实现数据的隐藏性；
D、增加成员函数的种类；
49、 在C++中，关于下列设置缺省参数值的描述中，（B
）是正确的。
A、不允许设置缺省参数值；
B、在指定了缺省值的参数右边，不能出现没有指定缺省值的参数；
C、只能在函数的定义性声明中指定参数的缺省值；
D、设置缺省参数值时，必须全部都设置；
50、关于delete运算符的下列描述中，（
C）是错误的。
A、它必须用于new返回的指针；
B、使用它删除对象时要调用析构函数；
C、对一个指针可以使用多次该运算符；
D、指针名前只有一对方括号符号，不管所删除数组的维数。
51、const int
*p说明不能修改（ C）。
A、p指针； B、p指针指向的变量；
C、p指针指向的数据类型； D、上述A、B、C三者；
52、当需要打开A盘上的以文件用于输入时，则定义文件流对象的语句为 (B )。
A、fstream fin(“A:”,1) B、ifstream
fin(“A:”,ios::nocreate)
C、ofstream fin(“A:”)
D、ifstream fin(“A:”,ios::app)
53、派生类的对象对它的基类成员中（A ）是可以访问的。
A、公有继承的公有成员；
B、公有继承的私有成员；
C、公有继承的保护成员； D、私有继承的公有成员；
54、假定一个字符串的长度为n，则定义存储该字符串的字符数组的长度至少为（C）。
A、n-1 B、n C、 n+1 D、n+2
55、 在int a=3; *p=&a;中，*p的值是（ D）。
A、变量a的地址值
B、无意义 C、变量p的地址值 D、 3
56、
下列常量中，（ D）不是字符常量。
A、’005’ B、’n’ C、 ’c’
D、“a”
57、在int a=3,*p=&a;中，*p的值是（ D）。
A）变量a的地址值 B）无意义 C）变量p的地址值
D） 3
58、以下4个选项中，不能看作一条语句的是（B ）。
A)
if(b==0) m=1;n=2; B) a=0,b=0,c=0; C)
if(a>0); D) {;}
59、（D ）不是构造函数的特征。
A）构造函数的函数名与类名相同 B）构造函数可以重载
C）构造函数可以设置缺省参数 D）构造函数必须指定类型说明
60、以下程序段中与语句k=a>b 1:0；功能等价的是（D ）。
A）
if(a>b) k=1; B） if(a>b) k=0
C）if(a>b) k=1; D）if(a
A）’005’ B）’n’ C) ’c’
D）
62、表示“x大于1而小于10”的逻辑表达式是（B ）。
A）1
63、关于成员函数特征的下列描述中，（ A）是错误的。
A）成员函数一定是内联函数 B）成员函数可以重载
C）成员函数可以设置缺省参数值 D）成员函数可以是静态的
64、有以下程序
#include
void main( )
{
int i,s=0;
for(i=1;i<10;i+=2) s+=i;
cout<
A）
自然数1～9的累加和 B） 自然数1～10的累加和
C）
自然数1～9中的奇数之和 D） 自然数1～10中的偶数之和
65、设有定义：int
n=0,*p=&n,**q=&p;则以下选项中，正确的赋值语句是（D）。
A） p=1;
B） *q=2; C） q=p; D） *p=5;
66、（
A）能正确输出结果：C++。
A） char s[]=
B）char
s[3]=
C）char
s[3]={'C','+','+','0'};cout<
int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a,b;
b=p[5];
b中的值是（ B）。
A）5 B）6
C） 8 D） 9
68、有以下程序
#include
void main( )
{ char
*p[10]={
cout<
执行后输出结果是
B
A）dcdbe B） abbd C） abc
D） abb
69、下列静态数据成员的特性中，（C ）是错误的。
A）
说明静态数据成员时前边要加修饰符static
B） 静态数据成员要在类体外进行初始化
C） 静态数据成员不是所有对象所共用的
D）引用静态数据成员时，要在其名称前加<类名>和作用域运算符
70、有以下语句
struct S
{ int g;
char h;} T;
则下面叙述中不正确的是（C ）。
A）S是结构体名
B）该结构体包含2个成员
C）S是struct类型的变量 D）T是struct
S类型的变量
71、派生类的对象对它的基类成员中（ A）是可以访问的。
A）公有继承的公有成员
B）公有继承的私有成员
C）公有继承的保护成员
D）私有继承的公有成员
72、实现运行时的多态性用 。D
A、重载函数
B、构造函数 C、析构函数 D、虚函数
73．下列变量名中，（ A ）是合法的。
A. CHINA B. byte-size C. double D.
A+a
74. 在int
b[][3]={{1},{3,2},{4,5,6},{0}};b[2][2]的值是（D ）。
A. 0 B. 2 C. 5 D. 6
75. 下列各运算符中，（B）优先级最高。
A. +（双目） B. *（单目）
C. <= D. *=
76. 下列for循环的次数为（ B ）。
for(int i(0),x=0;!x&&i<=5;i++)
A. 5
B. 6 C . 1 D. 无限
77.
下述关于break语句的描述中，（ C ）是正确的。
A.
break语句可用于循环体内，它将退出该重循环。
B.
break语句可用于开关语句中，它将退出开关语句。
C.
break语句可用于if体内,它将退出if语句。
D.
break语句在一个循环体内可以出现多次。
78.
在一个被调用函数中，关于return语句使用的描述，（D ）是错误的。
A.
被调用函数中可以不用 return语句。
B. 被调用函数中可以使用多个return语句。
C. 被调用函数中，如果有返回值，就一定要有return语句。
D.
被调用函数中，一个return语句可返回多个值给调用函数。
79.
在C++中，关于下列设置参数默认的描述中，（ C ）是正确的。
A.
不允许设置参数的默认值。
B. 设置参数默认值只能在定义函数时设置。
C.
设置参数默认值时，应该是先设置右边的再设置左边的。
D.
设置参数默认值时，应该全部参数都设置。
80.
下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ A
）
合适。
A. 内联函数 B. 重载函数 C. 递归调用
D. 嵌套调用
81. 下列的各类函数中，（ C ）不是类的成员函数。
A.
构造函数 B. 析构函数 C . 友元函数 D. 拷贝初始化构造函数
82. （ D）不是构造函数的特征
A. 构造函数的函数名与类名相同 B.
构造函数可以重载
C. 构造函数可以设置缺省参数 D.
构造函数必须指定类型说明
83.
f1(int)是类A的公有成员函数，p是指向成员函数f1()的指针，采用（ C）是正确的。
A. p=f1 B. p=A::f1 C.
p=A::f1() D. p=f1()
84.
下列定义中，（A ）是定义指向数组的指针p。
A. int *p[5] B.
int (*p)[5] C. (int *)p[5] D. int *p[ ]
85．循环while(int i=0) i--；执行次数是（ A ）。
A. 0
B. 1 C . 5 D . 无限
86. 设int
x；，则经过（ C ）后，语句*px=0；可将x值置为0。
A. int * px；
B . int const * px=&x；
C. int * const
px=&x； D. const int * px=&x；
87. 设void
f1(int * m，long & n)；int a；long b；则以下调用合法的是（ B
）。
A. f1(a，b)； B. f1(&a，b)；
C. f1(a，&b)； D. f1(&a，&b)
88. 关于对象概念的描述中，（ A ）是错误的。
A.
对象就是C语言中的结构变量;
B. 对象代表着正在创建的系统中的一个实体；
C. 对象是一个状态和操作（或方法）的封装体;
D.
对象之间的信息传递是通过消息进行的;
89. 在下列double型常量表示中，（A
）是错误的。
A. E15; B. .35; C. 3E5;
D. 3E-5
90. 下列给字符数组进行初始化中，（A ）是正确的。
A.
char s1[ ]=
C. char s3[][3]={‘a’,’x’,’y’};
D. char s4[2[3]={
91. 对于int *pa[5];的描述，（ D
）是正确的。
A. pa是一个指向数组的指针，所指向的数组是5个int型元素；
B.
pa是一个指向某个数组中第5个元素的指针，该元素是int型变量；
C.
pa[5]表示某个数组的第5个元素的值；
D.
pa是一个具有5个元素的指针数组，每个元素是一个int型指针；
92. 下列各运算符中，（
A ）优先级最低。
A．？： B. | C. ||
D. ！=
93. 下列for循环的循环体执行次数为（ D ）。
for(int
i(0),j(10);i=j=4;i++,j- -)
A. 0; B.
1; C. 4; D. 无限;
94.
下述关于开关语句的描述中，（ A ）是正确的。
A.
开关语句中default子句可以没有，也可以有一个;
B.
开关语句中每个语句序列中必须有break语句;
C.
开关语句中default子句只能放在最后；
D.
开关语句中case子句后面的表达式可以是整形表达式。
95. 下列存储类标识符中，（ C
）的可见性与存在性不一值。
A. 外部类； B. 自动类; C.
内部静态类； D. 寄存器类。
96. 下述静态数据成员的特征中，（ D）是错误的。
A. 说明静态数据成员时前边要加修饰符static;
B.
静态数据成员要在类体外进行初始化；
C.
引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符；
D.
静态数据成员不是所有对象所共用的。
97. （ A）是析构函数的特征。
A.
一个类中只能定义一个析构函数; B. 析构函数与类名不同;
C.
析构函数的定义只能在类体内; D. 析构函数可以有各个或多个参数。;
98.
已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，（ C
）是
正确的。
A. A1.p=5; B.
A1->p=5;
C. A.*p=5; D.
*A1.p=5;
99. 关于new运算符的下列描述中，( D )是错的。
A.
它可以用来动态创建对象和对象数组；
B.
使用它创建的对象或对象数组可以使用运算符delete删除;
C.
使用它创建对象时要调用构造函数；
D. 使用它创建对象数组时必须指定初始值。
100. 派生类的构造函数的成员初始化列中，不能包含（C ）。
A.
基类的构造函数;
B. 派生类中子对象的初始化;
C. 基类的子对象初始化;
D. 派生类中一般数据成员的初始化
101. 派生类的对象对它的基类成员中（
A）是可以访问的。
A. 公有继承的公有成员;
B. 公有继承的私有成员；
C. 公有继承的保护成员；
D. 私有继承的公有成员。
102．C++类体系中，不能被派生类继承的有（ A）。
A.构造函数
B.虚函数 C.静态成员函数 D.赋值操作函数
103．下面标识符中正确的是（A ）。
A．_abc B．3ab
C． int D．+ab
104．下列哪项（ D
）不是面向对象程序设计的主要特征？
a.封装 b.继承 c.多态 d.结构
105．已知i=5，j=0，下列各式中运算结果为j=6的表达式是（ A ）。
A．j=i+（++j） B．j=j+i++ C．j=++i+j
D．j=j+++i
106．若整型变量a、b、c、d中的值依次为：1、4、3、2。则条件表达
式a
107．以下不正确的是（ C ）。
A．语句for（i=0；；i++）表示无限循环 B．for（；；）表示无限循环
C．for（）也表示无限循环 D．while（1）表示无限循环
108．有如下程序：
int x=3；
do{
X-=2；
cout<
执行这个程序的输出结果是（ C ）。
A． 1 B．30 C．1-2
D．死循环
109．若有以下定义，则说法错误的是( D)。
int
a=100,*p=&a
A．声明变量p，其中*表示p是一个指针变量
B．变量p经初始化，获得变量a的地址
C．变量p只可以指向一个整形变量
D．变量p的值为100
110．下面关于数组的初始化正确的是（ A
）。
A．char str[]＝{‘a'，’b'，'c‘}
B．char
str[2]＝{'a'，'b'，'c’}
C．char
str[2][3]＝{{'a‘，'b’}，{’e’，'d’}，{’e’，‘f'}}
D．char str[]＝{'a'，'b'，'c’}
111．若已定义：
int a[]={0，1，2，3,4,5，6，7，8，9}，*P=a，i;
其中0≤i≤9，则对a数组元素不正确的引用是（ D ）。
A．a[p-a]
B．*(&a[i]) C．p[i] D．a[10]
112．存在定义int
a[10]，x，*pa;，若pa=&a[0]，下列的哪个选项和其他3个选项不是等价的
A． x＝*pa; B．x＝*(a+l);
C．x＝*(pa+1); D．x＝a[1];
113．对数组名作函数的参数，下面描述正确的是（B）。
A．数组名作函数的参数，调用时将实参数组复制给形参数组。
B．数组名作函数的参数，主调函数和被调函数共用一段存储单元。
C．数组名作参数时，形参定义的数组长度不能省略。
D．数组名作参数，不能改变主调函数中的数据。
114．关于静态成员的描述中，（
B ）是错误的。
A． 静态成员可分为静态数据成员和静态成员函数。
B．
静态数据成员定义后必须在类体内进行初始化。
C． 静态数据成员初始化不使用其构造函数。
D． 静态数据成员函数中不能直接引用非静态成员。
115．下列关于构造函数的描述中，错误的是（ D ）。
A．构造函数可以设置默认的参数 B．构造函数在定义类对象的自动执行
C．构造函数可以是内联函数 D．构造函数不可以重载
116．假设OneClass为一个类，则该类的拷贝初始化构造函数的声明语句为（ C ）。
A. OneClass(OneClass p); B.
OneClass& (OneClass p);
C. OneClass(OneClass &
p); D. OneClass (OneClass *p);
117．如果类A被说明成类B的友元，则（ D ）。
A.类A的成员即类B的成员。
B.类B的成员即类A的成员。
C.类A的成员函数不得访问类B的成员 。
D.类B不一定是类A的友元。
118、关于对象和类的关系，说法正确的是（ C ）。
A) 同属于一类的对象，具有相同的数据成员和成员函数。
B)
对象是具体，是类的对象，同其他变量一样，先定义后使用。
C)
同一类的不同对象，其具有的操作可不同，具体的操作也不同。
D)
不同类的对象，可有相同的操作。
119、双精度浮点型的字节数是（ D ）。
A）4
B）1 C）0 D）8
120、下列关于C++函数的说明中正确的是（
D ）。
A) 内联函数就是定义在另一函数体内部的函数。
B)
函数体的最后一条语句必须是RETURN语句。
C)
标准C++要求在调用一个函数之前，必须先声明其原型。
D)
编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式。
A ）。 （
121、下列关于虚函数的说明中，正确的是（ B ）。
A)
从虚基类继承的函数都是虚函数。
B) 虚函数不得是静态成员函数。
C) 只能通过指针和引用调用虚函数。
D) 抽象类中的成员函数都是虚函数。
122、下列符号中可以用作C++标识符的是（ A ）。
A)
_radius B) foo~bar C) else D)
3room
123、结构化程序设计所规定的三种基本控制结构是（ C ）。
A)输入、处理、输出 B)树形、网形、环形
C)顺序、选择、循环
D)主程序、子程序、函数
124、下列语句中错误的是（ B ）。
A)
const int buffer=256; B) const int int
temp;
C) const double *point; D)
const double *rt=new double(5.5)
125、下列关于实参和形参说法错误的是（ D ）。
A）实参可以是变量、常量、或表达式。
B）实参与形参的类型必须一致，否则会发生“类型不匹配”的错误。
C）实参对形参的数据传递是单向传递，调用结束后，实参单元被释放。
D）形参必须是变量。
126、关于内联函数说法错误的是（ C ）。
A）不是任何一个函数都可定义成内联函数。
B）内联函数的函数体内不能含有复杂的结构控制语句。
C）递归函数可以被用来作为内联函数。
D）内联函数一般适合于只有1～5行语句的小函数。
127、关于保护继承的说法正确的是（ D ）。
A）基类的公有成员、私有成员可被子类继承下来，而且性质不变。
B）基类的公有成员、私有成员可被子类继承下来，而且性质改变为保护成员。
C）基类的公有成员、私有成员可被子类继承下来，而且性质均改变为私有成员。
D）基类的公有成员、私有成员可被子类继承下来，性质不变，私有成员不被继承。
128、关于函数的返回值说法正确的是（ A ）。
A)由return语句返回时，只带回一值，其类型在函数定义时确定。
B)其类型由调用表达式决定。
C)函数可以没有返回值，这时在函数定义，函数的类型说明就没必要了。
D)函数调用就要有返回值，否则调用就没意义了。
129、下列合法的标识符是（D ）。
A） abde+ B)#KSJF C)67KDJ D)DK3-
130、关于结构化程序设计方法说法错误的是（ D ）。
A）在数据处理过程中，采用的是自顶向下、分而治之的方法。
B）将整个程序按功能划分为几个可独立编程的子过程模块。
C）以“对象”或“数据”为中心。
D）数据和处理数据的过程代码是分离的、相互独立的实体。
131、运算符重载是对已有的运算符赋予多重含义，因此（ C ）。
A）可以对基本类型（如int类型）的数据，重新定义“+”运算符的含义。
B）可以改变一个已有运算符的优先级和操作数个数。
C）只能重载C++中已经有的运算符，不能定义新运算符。
D）C++中已经有的所有运算符都可以重载。
132、关于C++程序说法不正确的是（ D ）。
A)
C++程序由函数构成，但只有一个main()函数 。
B)
C++程序中main()函数可以在程序的任何位置 。
C)
C++程序由main()函数开始执行，由main()结束执行。
D)
main()都是没有参数的。
133、已知a=4,b=6,c=8,d=9,则“(a++,b>
a++&&c>d)++d:a
134、下面有关重载函数的说法中正确的是（ C ）。
A)重载函数必须具有不同的返回值类型。
B)重载函数形参个数必须不同。
C)重载函数必须有不同的形参列表。
D)重载函数名可以不同。
135、C++语言的跳转语句中，对于break和continue说法正确的是（ B ）。
A)break语句只应用于循环体中。
B)continue语句只应用于循环体中。
C)break是无条件跳转语句，continue不是。
D)break和continue的跳转范围不够明确，容易产生问题。
136、long[int]的字节数是（D ）。
A）4
B）1 C）0 D）8
137、下列非法的字符常量是（ C ）。
A）‘#’ B）‘’ C）a’ D）‘A’
二、填空：
1. C++语言的头文件与源程序文件扩展名分别是（.h ）和（ .cpp ）。
2. 在C++程序中使用基本输入与输出流时需要包含的头文件名是（ iostr
eam ）。
3. 在C++语言中，惟一的一个三目运算运算符是（ : ）。
4. C++中当一个函数无返回值时，则函数的类型是（void ）。
5. 一个类中可以有（多）个构造函数，只能有（ 一 ）个析构函数。
6.一般情况下,按照面向对象的要求,把类中的数据成员(属性)定义为（ 私有 ）权限,
而把成员函数(方法)定义为（公有 ）权限.
7.在定义类的对象时,C++程序将自动调用该对象的（ 构造
）函数初始化对象自身.在撤销类的对
象时,C++程序将自动调用该对象的（ 折构 ）
函数.
8.类继承中,缺省的继承方式是（ 私有继承 ）.
9．在C++语言中，用转义字符序列（ 'n' ）或操纵符（ endl
）表示输出一个换行符。
10．表达式a=a＋l表示成增量表达式为（ ++a ）。
11．当不需要函数返回任何值时，则应把该函数类型定义为（ void ）。
12．用于输出表达式值的标准输出流对象是（
cout）。，用于从键盘上为变量输人值的标准输人流对
象是（cin ）。
13、变量分为全局和局部两种，（全局变量默认初始化为0
）。变量没有赋初值时，其值是不确定的。
14、假定类AB中有一个公用属性的静态数据成员bb，
在类外不通过对象名访问该成员bb的写法为
（ AB：:bb ）。
15、类的成员分为＿数据成员＿和＿成员函数＿。
16、一个＿类＿和＿对象＿的关系，正如基本数据类型与该类型的变量一样，如int x;。 17、对一个类中的数据成员的初始化可以通过构造函数中的＿赋值＿实现，也可以通过构造函数中的＿初<
br>始化列表＿实现。
18、类有两种用法：一种是＿定义对象＿，即生成类的对象；另一种是通过＿派生＿，派生出新的类。
19、C++语言提供的＿多态＿机制允许一个派生类继承多个基类，即使这些基类是相
互无关的。
20、声明虚函数的方法是在基类中的成员函数原型前加上关键字＿virtual＿。
21、如果一个类中有一个或多个纯虚函数，则这个类称为＿虚基类＿。
22、静态数据成员在定义或说明时，前面要加上关键字＿static＿。
23、如果成员函数不需要访问类的＿非静态＿成员，则可以把它声明为静态成员函数。
24、友元可以是＿全局函数＿，也可以是＿其他类的成员函数＿。
25、若需要把一个函数“void
fun();”定义为一个类A的友元函数，则应在类A的定义中加入一条语句：
＿friend
void fun（）；＿。
26、运算符函数中的关键字是＿operator＿，它和＿运算符＿
一起组成该运算符函数的函数名。
27、类中运算符重载一般采用两种形式：＿成员函数＿和＿友元函数＿。
28、面向对象程
序设计的3大机制为：＿封装性＿、＿继承性＿和＿多态性＿。2、类的访问权限有＿
public＿、
＿private＿和＿protected＿三种。
29、构造函数是＿对象＿被创建时自动执行，对象消失时自动执行的成员函数称为＿析构函数＿。
30、如果类A继承了类B，则类A称为＿基类＿，类B称为＿派生类＿。
31、如果一个特定的类型S当且仅当它提供了类型T的行为时，则称类型S是类型T的＿＿子类型＿。
32、在类定义中，将＿=0＿置于虚函数的函数原型的末尾可以声明该函数为纯虚函数。
33、类的静态成员分为＿静态数据成员＿和＿静态成员函数＿。
34、友元函数的声明可以放在类的＿私有＿部分，也可以放在类的＿共有＿部分，它们是没有区别的。
35、如果说类B是类A的友元类，则类B的所有成员函数都是类A的＿成员函数＿。
36、
设a和b是两个整型变量，我们用a+b的形式求这两个变量的和；设c和d为浮点型变量，我们用c+d
的形式求这两个变量的和。显然运算符“+”具有不同的用途，这是＿运算符重载＿的例子。
37、对于双目运算符，若重载为类的成员函数，有1＿个参数；若重载为友元函数，则有＿2个参数。
38、 当建立__一个新的对象___，程序自动调用该类的构造函数。
39、
在C++中有二种参数传递方式：__传值___ 和___引用__ 。
40、
模板对处理数据的类型的要求不同可以分为两种类型：__函数模板__ 和 __ 类模板__。
41、 异常是通过_检查（try）__
、_抛出（throw）__和__捕捉（catch）__ 来实现的。
42、
虚函数实现了C++的__多态__ 机制，类实现了C++的___封装__ 机制。
43、
面向对象程序设计的___继承___机制提供了重复利用程序资源的一种途径。
44、C++语言程序设计的三种基本结构是：_顺序结构_ 、 _选择结构_ 、
__循环结构__ 。
45、为了避免嵌套的条件语句if-
else的二义性，C++语言规定else与__if __配对使用。
46、定义函数时，在函数的类型前加上修饰词 ___ inline
___，指明将该函数定义为内联函数。
47、有说明语句：*p；则*p++运算首先访问
___*p___，然后使__p____ 的值加1。
48、执行int *p=new int
操作，可以得到一个动态分配整型对象的__指针____。
49、有说明语句：int
*p；则(*p)++运算首先访问 ___*p___，然后使 __*p____的值加1。
50． C++目标程序经___编译链接___后生成扩展名为exe的可执行程序文件。
51． 16位计算机中整型占___2_______个字节存储空间。
52．
要在屏幕上显示，world!应执行语句cout<<_______ ，world!。
53．
表达式8&3的结果是___0_______。
54．
作为语句的函数调用是通过____
函数的副作用
____来体现的。
55．
执行if (x>=0||x<=0) cout<<；else
cout<<；屏幕上显示的是____abcd____。
56．
设一维整型数组data已进行了初始化，则其元素个数可由操作符sizeof通过表达式____
sizeof(data)
sizeof(int) ___计算出来。
57．
若一全局变量只允许本程序文件中的函数使用，则定义它时应加上修饰符__ static ______。
58． 设有int
w[3][4]；，pw是与数组名w等价的数组指针，则pw应初始化为____ int*[4] pw =
w; _____。
59.要使引用pr代表变量char *
p；，则pr应初始化为________ char*& pr = p; ________。
60．在C++中封装性、继承性和_____多态性
61．假设int
a=1，b＝2;则表达式a+++--b的值为 __2____。
62．下面的程序实现输出x，y，z三个数中的最大值，请填入正确的内容。
#include
void main（）
{
int x=5,y=8,z=9, u, v;
if__（x〉u）__ u=x;
else u=y;
if_（u〉v）__ v=u;
else v=z；
cout<<”v=”<
63．C++语言的参数传递机制
包括传值和传地址两种，如果调用函数时，需要改变实参或者返回多个值，应
该采取 __传地址___
方式。
64．在C++语言中，访问一个对象的成员所用的运算符是 ___ .,
____，访问一个指针所指向的对象的成员
所用的运算符是 ___ -> ___。
65．C++语言支持的两种多态性分别是编译时的多态性和 __运行时___的多态性。
66．设有如下程序结构：
class Box
{ … };
void
main()
{Box A,B,C; }
该程序运行时调用___3__次构造函数；调用 ___3__次析构函数。
67．目前，有两种重要的程序设计方法，分别是：___面向过程__和___面向对象___。
68． C++语言提供的基本控制结构可以分为3种类型：顺序结构、__分支__ 和循环结构。
69．函数的调用主要分为传值调用和__引用调用____调用。前者的特点是_不能改变传入变量的
值 _。
70．函数重载时要求同名函数的_参数个数__或_参数类型__不同，否则无法确定是哪个函数。
71．静态数据成员是类的所有对象中的____共享__成员，而非静态数据成员是属于___一个具
体___对象
的。
72． 设A为test类的对象且赋有初值,则语句test
B(A); 表示__
将对象A复制给对象B
___。
73.面向对象程序设计方
法中的每个对象都具有_
属性
__和___
方法
__两方面的特征。
74.“类”指的是____
对象的类型，代表了某一批对象的共性和特征
_____。 <
br>75.构造数据类型，包括数组、_
指针
_、_
结构体和共用体
_、_
_
枚举
_和类等。
76.C++中数据类型标识符Signed
Char，其字节数为__1___，范围是__
-128到127
___。
77.
在函数体内部定义的变量称为__
局部变量
_。在所有函数体外部定义的变量称为__
全局变量
__。
78.有一数学表达式为23(f-32)，要写成对应的C++的表达式时
，正确地写法应写__
2.03.0*（f-32）
_。
79.类的静态成员是_<
br>的所有对象中共享
_的成员，不是_
某个对象
___的成员，静态成员在___
类的声
明中
__进行引用性说明，在_
其文件作用域的其他地方
_进
行定义性说明。
80.使用传统的结构化程序设计方法设计程序的步骤是__
自顶向下
___、__
逐步细化
_、__
模块化设计
_。
81.
“封装”指的是_
将有关的数据和操作代码封装在一个对象中，形成一个基本单位，各个
对象之
间相互独立，互不干扰，且将对象中某些部分对外隐藏
_。
82.可以让新类继承已定义的
类的_
数据成员
_和_
成员函数
_，这个新类称为__
继承
_，原来的类称为___
基类
__。新类可以从一个类中派生，这叫__
单继承
__，也可以从多个类中派生，称为__
多重继承
_。
83.指针
类型变量用于存储__
另一变量的地址
__，在内存中它占有____
一个
_
_存储单元。
84.类有三种继承方式，分别是：__
公有继承
_、__
保
护继承
__、___
私有继承
_。
三、判断下列描述的正确性：
1、C++中标识符内的大小写字母是没有区别的。
（F）
2、C++是一种以编译方式实现的高级语言。
（T）
3、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
（ F）
4、在私有继承中，基类中所有成员对派生类都是不可见的。
（ F）
5、返回值类型、参数个数和类型都相同的函数也可以重载。
（F）
6、使用关键字class定义的类中缺省的访问权限是私有（private）的。
（T）
7、类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。（F） ）
8、C++中使用了新的注释符（），C语言中注释符（*…*）不能在C++中使用。
（ F）
9、While循环语句的循环体至少执行一次。
（ F）
10、引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。
（T ）
11、类封装了数据和操作。
（ T ）
（ F ）
13、类中的数据成员不能为指针类型。
（ F ）
14、析构函数可以有形参。 （T
）
15、派生类至少有一个基类。
（T ）
（ T ）
17、全局函数和静态成员函数也能声明为虚函数。 （F ）
18、在一个类的对象空间里不包含静态成员的空间。 （ T ）
20、运算符重载后，原运算符的优先级和结合特性会改变。 （ F ）
21、一个类只能有一个对象。 （
F）
22、在类中不能对所定义的数据成员进行初始化。 （ T ）
23、类的公有成员函数是类与外界的接口。 （ T ）
24、构造函数没有函数类型。 （
T ）
（ T ）
（ F ）
27、只有类的成员函数才能声明为虚函数。
（ T ）
28、在一个类的对象空间里已经包含了静态成员的空间。 （F ）
30、运算符重载后，原运算符的优先级和结合特性不会改变。 （ T ）
31.
C++中使用了新的注释符（），C语言中注释符（*…*）不能在C++中使用。 （ F）
32.
数组赋初值时，初始值表中的数据项的数目可以大于或等于数组元素的个数。 （ F）
33.
隐含的类型转换都是保值映射，显式的类型转换都是非保值映射。 （ F）
34. 宏定义命令是以分号结束的。
（ F）
35. While循环语句的循环体至少执行一次。
（ F）
36. 返回值类型、参数个数和类型都相同的函数也可以重载。
（ F）
37. 函数形参的作用域是该函数的函数体。
（ T）
38. 静态类标识符在它的作用域之外是不存在的。
（ F）
12、在类的定义中，必须包含private、public、protected三种存
取方式对应的部分。
16、在公有和保护继承方式下，派生类的对象可以对基类的保护成员进行访问。
19、友元本身就是类的成员。 （
T ）
25、在派生类的构造函数的初始化表中不能对包含基类的子对象初始化。
26、在公有和保护继承方式下，派生类的成员可以对基类的保护成员进行访问。
29、C++不允许将构造函数、析构函数和虚函数声明为友元函数。（ T ）
39. 对象成员的表示与结构变量成员表示相同，使用运算符.或->。
（T ）
40. 某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。
（T ）
41. 对象数组的元素可以是不同类的对象。
（ T）
42. const char *p说明了p是指向字符串的常量指针。
（F ）
43、引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。（
F）
44、无论是私有继承还是保护继承中，基类中所有成员对派生类对象都是不可见的。（T ）
45、当break语句用在双重循环的内循环中时，它只能退出内循环到外循环中去，而不能直出整个
双重循
环。
（ T）
46、 For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。
（F ）
47、返回值类型、参数个数和参数类型都相同的函数也可以重载。
（ F）
48、通常的拷贝初始化函数的参数是某个对象的成员名或对象的引用名。
（T ）
49、友元函数是类的成员函数，所以可以存取或修改该类中的私有成员。
（ F）
（F ）
51、在语句const char *ptr中，
ptr是指向字符串的常量指针。 （ F）
52、多继承情况下，派生
类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生
类构造函数中所定义的成
员初始化列表的各项顺序无关。 （ T）
53、在说明语句
int a(15),&b=a,*p=&a;中，b的值的*P的是不相等的。（ F ）
54、已知：int a(5),b(10); 表达式++a+b++有二义性。（ F ）
55、在不同类型操作数组成的表达式中，其表达式的类型一定是最高类型double型。（F ）
56、break语句也可以用于if体内，它可退出if语句。（ F ）
57、在一个被调用函数中，一个return语句可返回多个值给调用函数。（ F ）
58、在传值调用中，要求实参和形参的类型完全一致并且个数相等。（ F ）
59、for循环中，循环变量的作用域是该循环的循环体内。（ F ）
60、所谓私有成
员是指只有类中所提供的成员函数才能直接访问它们，任何类以外的函数对它们的访问都
是非法的。（
F ）
61、const char *p说明了p是指向字符串的常量指针。（ F ）
62、私有继承中，基类中所有成员对派生类的对象都是不可见的。（ F ）
50、已知：类A中一个成员函数说明如下：void Set(A&a)；其中A
&a的含意是将a的地给变量Set。
四、指出函数或程序的功能。
1、 template
void AC(Type &x , Type &y )
{
Type
a=x;
x=y
y=a
}
1.交换x和y；
2、int AB(int *a , int n)
{
int x=a[0];
for (int i=1; i
}
2.返回数组a[n]中元素的最小值
3． int AB(int *a , int n){
int
x=a[0];
for (int i=1; i
}
3.返回数组a[n]中元素的最小值
4. float fact(int n)
{float t=1;
for(int i=1;i<=n;i++)
t*=i;
return t;
}
#include
void main( )
{ float t;
int n=10;
cout<
4.输出10的阶乘
五、写出程序运行结果（每小题3分,共15分）
1、#include
int
a[]={2,4,6,8,10};
int &index(int i)
{
return a[i];
}
void main()
{
int i;
index(3)=12;
for
(i=0;i<=4;i++)
cout<
结果 2
4 6 12 10
2、#include
void
f(int *m,int n)
{
int temp;
temp=*m;
*m=n;
n=temp;
}
void main()
{
int a=5,b=10;
f(&a，b);
cout<
10 10
3、#include
int
i=15;
void main()
{
int i;
i=100;
∷i=i+1;
cout<<∷i<
101
4、#include
class toy
{
public:
toy(int q,
int p)
{
quan = q;
price = p;
}
int get_quan()
{
return quan;
}
int get_price()
{
return
price;
}
private:
int quan,
price;
};
main()
{
toy
op[3][2]={
toy(10,20),toy(30,48),
toy(50,68),toy(70,80),
toy(90,16),toy(11,120),
};
int i;
for (i=0;i<3;i++)
{
cout<
cout<
cout<<
return 0;
}
10,20
30,48
50,68
70,80
90,16
11,120
5、#include
class example
{
public:
example(int n)
{
i=n;
cout<<
}
~example()
{
cout
<<
}
int get_i()
{
return i;
}
private:
int i;
};
int sqr_it(example o)
{
return _i()* _i();
}
main()
{
example x(10);
cout<<_i()<
}
Constructing
10
Destructing
100
10
Destructing
6、#include
class Test
{
private:
int x;
public:
Test()
{
cout<<“构造函数被执行”<
}
~Test()
{cout<<“析构函数被执行”<
void
main()
{
Test obj1,obj2;
();
();
}
构造函数被执行
构造函数被执行
x=0
x=0
析构函数被执行
析构函数被执行
7、#include
class A
{
public:
A(int *s) {cout<
class B:public A
{
public:
B(char *s1,char *s2):A(s1)
{
cout<
};
class C:public A
{
public:
C(char *s1,char *s2):A(s1)
{
cout<
};
class D:public B,C
{
public:
D(char *s1,char *s2,char
*s3,char *s4):B(s1,s2),C(s3,s4)
{
cout<
};
void
main()
{
D d (“class A”,”class
B”,”class C”,”class D”);
}
class A
class B
class C
class D
class D
8、#include
class Base
{
public:
virtual void disp()
{cout<<”base class”<
class
Derivel:public Base
{
public:
void disp() {cout<<”derivel class”<
class Derive2:public Base
{
public:
void disp() {cout<<”derive2
class”<
void main()
{
Base *p;
Base b;
Derive1 d1;
Derive2 d2;
p=&b;
p->disp();
p=&d1;
p->disp();
p=&d2;
p->disp();
}
base class
derivel class
derive2 class
9、#include
class Sample
{
private:
int x;
static int y;
public:
Sample(int a);
void print();
};
Sample:: Sample(int a)
{
x=a;
y ++;
}
void
Sample::print()
{
cout<<”x=”<
int
Sample::y=25;
void main()
{
Sample s1(5);
Sample s2(10);
();
();
}
x=5,y=27
x=10,y=27
10、#include
class Sample
{
private:
int x;
public:
Sample () { }
Sample(int a) {x=a;}
void disp()
{cout<<”x=”<
};
Sample operator+( Sample &s1, Sample &s2)
{
return Sample(s1.x+s2.x);}
void main()
{
Sample obj1(10);
Sample
obj2(20);
Sample obj3;
obj3=obj1+obj2;
();
}
x=30
11、#include
class Test
{
private:
int x;
public:
Test()
{
cout<<“构造函数被执行” <
}
void print()
{
cout<<“x=”<
};
void main()
{
Test obj1,obj2;
();
();
}
构造函数被执行
构造函数被执行
x=0
x=0
12、#include
class A
{
protected:
int x;
public:
A(int x)
{
A::x=x;
cout<<”class A”<
};
class B
{
private:
A a1;
public:
B(int x):a1(x)
{
cout<<”class B”<
};
class C:public B
{
private:
A a2;
public:
C(int x):B(x),a2(x)
{
cout<<”class C”<
};
class D:public C
{
public:
D(int x):C(x)
{
cout<<”class D”<
};
void main()
{
D dobj(10);
}
class A
class B
class A
class C
class D
13、#include
class Point
{
private:
int x;
int y;
public:
Point (int a,int b)
{
x=a;
y=b;
}
virtual int area() {return 0;}
};
class Rectangle:public Point
{
private:
int length;
int
width;
public:
Rectangle(int
a,int b,int l,int w): Point(a,b)
{
length=l;
width=w;
}
virtual int area() { return length*width;}
};
void disp(Point &p)
{
cout<<“面积是：”<<()<
void
main()
{
Rectangle rect(3,5,7,9);
Disp(rect);
}
面积是：63
14、#include
class Sample
{
private:
int x;
static int y;
public:
Sample(int a);
void print();
};
Sample:: Sample(int a)
{
x=a;
y=x++;
}
void
Sample::print()
{cout<<”x=”<
void main()
{
Sample s1(5);
Sample s2(10);
();
();
}
x=6,y=10
x=11,y=10
15、#include
class Sample
{
private:
int x;
public:
Sample(){}
Sample (int a)
{
x=a;
}
void disp() {cout<<”x=”<
};
Sample Sample:: operator+( Sample &s)
{
return Sample(x+s.x);
}
void main()
{
Sample obj1(20);
Sample obj2(20);
Sample obj3;
obj3=obj1+obj2;
();
}
x=40
16、# include
class A {
int a , b
public :
A( ) { a=b=0; }
A( int aa ,
int bb ) : a(aa),b(bb) {
cout
<<”a=”<
~A(
){cout <<”Destructor!”<
void
main() {
A x , y(2 , 3);
}
a=2,b=3
Destructor!
Destructor!
17、 # include
int AD(int a[] , int n) {
int
x=1;
for (int i=0; i
return x;
}
void main() {
int
a[]={ 2, 8, 6, 5};
cout <
480
18、#include
class R
{
public:
R(int r1,int r2)
{R1=r1;R2=r2;}
void print();
void print()
const;
private:
int R1,R2;
};
void
R::print()
{
cout<
}
void R::print() const
{
cout<
void main()
{
R
a(5,4);
();
const R b(20,52);
();
}
5:4
20;52
19、#include
class A
{
public:
virtual void act1();
void act2() {act1();}
};
void A::act1()
{
cout<<
}
class B : public A
{
public:
void
act1();
};
void B::act1()
{
cout<<
}
void main()
{
B b;
2();
}
# include
void fun(int，int，int * )；
void main()
{
int x，y，z；
fun (2，3，&x)；
fun (4，x，&y)；
fun (x，y，&z)；
cout<
void fun(int a，int b，int * c )
{
b*=a；*c=b-a；}
B::act1() called.
20、#include
void main()
{
}
hello third
21、#include
int a[8]={1,2,3,4,5,6,7};
void fun(int b[
],int n);
void main( )
{ int m=8;
fun(a,m);
cout<
{
}
28
22、#include
class AA
{
public:
AA(int i,int j)
{A=i;B=j;cout<<
{A=obj.A+1;B=obj.B+2;cout<<
{cout<<
AA(AA &obj)
~AA()
void print()
{cout<<
for (int I=0;I
int x=3,y=3;
switch(x%2)
{
case 1: switch (y)
}
{ case 0:cout<<
}
default: cout<<
case
1:cout<<
case 2:cout<<
private:
int A,B;
};
void main()
{
AA a1(2,3);
AA a2(a1);
}
Constructor
Copy_Constructor
A=3,B=5
Constructor
A=5,B=6
Destructor
Destructor
Destructor
23、#include
void main()
{
int i(0);
while(++i)
{
if(i= =10)
break;
if(i%3!=1) continue;
cout<
}
1
4
7
24、#include
int a[8]={1,2,3,4,5,6,7};
void fun(int *pa,int n);
void main( )
{ int m=8;
fun(a,m);
cout<
void fun(int
*pa,int n)
{
}
for (int I=0;I
();
AA
*pa=new AA(5,6);
pa->print();
delete
pa;
28
25、#include
void ff(int x),ff(double x);
void main()
{ float a(88.18);
ff(a);
char
b('a');
ff(b);
}
void ff(int x)
{
{
cout<<
cout<<
void ff(double
x)
ff(double): 88.18
ff(int): 97
26、#include
class AA
{
public:
AA(int i,int j)
{A=i;B=j;cout<<
{A=obj.A+1;B=obj.B+2;cout<<
{cout<<
AA(AA
&obj)
~AA()
void print()
{cout<<
private:
int A,B;
};
void main()
{ AA a1(2,3);
AA
a2(a1);
}
Constructor
Copy_Constructor
A=3,B=5
Constructor
A=5,B=6
Destructor
Destructor
Destructor
();
AA *pa=new AA(5,6);
pa->print();
delete pa;
27、#include
void
main()
{
int a,b,c,d(5);
c=2,c+=10;
a =b=10;
a * = 2;
b
= 2;
c % = 2;
cout<
20,5,0
28、#include
void
main()
{
char flag='c'
switch(flag)
{
case 'a' :cout<<
case
'b' :cout<<
case 'c' : cout <<
default :
cout <<
}
}
3
4
29、#include
void main()
{
}
1
30
30、#include
void Swap( int
&a, int & b);
void main()
{
}
int x( 10 ), y( 7 );
cout<<
Swap( x , y );
cout<<
4 4 18
static int b[][3] = { {1,2,3},{4},{5,6} };
b[0][2]=12,b[1][2]=18;
cout <<
b[0][2]+b[1][2]+b[2][2]<< endl;
cout <<
**b<<
void Swap(int & a, int & b)
{
int temp; temp = a a=b b=temp }
x=10
y=7
x=7 y=10
31、#include
class A
{
public:
};
A::A()
{
a=b=10;cout<<
A::A(int i,int j)
{
a=i,b=j;cout<<
void A::print()
{cout<<
void main()
{
}
Default constructor.
Constructor.
a=10,b=10
a=15,b=18
Donstructor.
Donstructor
32、 program 1_
#include
void main()
{
int a,b,sum;
a=43;
b=37;
sum=a+b;
cout<<
cout<
The sum is80
A m,n(15,18);
();
();
A();
A(int i,int j);
~A(){cout<<
void print();
int a,b;
private:
33、#include
class Sample
{
int n;
static
int sum;
public:
Sample(int x){n=x;}
void add(){sum+=n;}
void disp()
{
cout<<
}
};
int Sample::sum=0;
void main()
{
Sample a(2),b(3),c(5);
();
();
();
();
();
();
}
n=2,sum=2
n=3,sum=5
n=5,sum=10
34、#include
class Sample
{
int x;
public:
Sample(){};
Sample(int a){x=a;}
Sample(Sample &a){x=a.x++ +10;}
void
disp(){cout<<
};
void main()
{
Sample s1(2),s2(s1);
();
();
}
x=3
x=12
35、 #include
class A
{
public:
A(char *s) { cout << s << endl; }
~A() {}
};
class B:public A
{
public:
B(char *sl,char *s2) :A(sl)
{
cout
<< s2 << endl;
}
};
class C:public
A
{
public:
C(char *sl,char *s2)
:A(sl)
{
cout << s2 << endl;
}
};
class D:public B,public C
{
public:
D(char *sl,char *s2,char *s3,char
*s4) :B(sl,s2),C(sl,s3)
{
cout << s4 <<
endl;
}
void main ()
{
D
d(
}
class A
class B
class A
class C
class D
36、 program 1_
#include
void main()
{
cout<<
();
}
Let's learn to
write a C++ Program.
37、#include
void main()
{ int i,n;
n=0;
for(i=1;i<=5;i++)
n=n+i;
cout<<
n=15
38、#include
class Sample
{
int n;
public:
Sample(int i){n=i;}
friend int add(Sample
&s1,Sample &s2);
};
int add(Sample
&s1,Sample &s2)
{
return s1.n+s2.n;
}
void main()
{
Sample
s1(10),s2(20);
cout<
30
39、#include
class
Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int
b){x=a;y=b;}
~Sample()
{
if(x==y)
cout<<
else
cout<<
}
void
disp()
{
cout<<
}
};
void main()
{
Sample s1(2,3);
();
}
x=2,y=3
x!=y
六、分别指出下面的p各是什么。
1、int *p； 2、int
*p[3]；
3、int (*p)[3]； 4、int *p( )；
5、int **p；
1. 指向整型变量的指针；
2.
指向整型一维数组的指针；
3.
指向整型变量的一维指针数组，既：数组里存放的是指向整型变量的指针；
4.
指向一个函数返回值为整形的函数指针；
5.指向整形变量的二次指针.
七、指出下列程序的错误，并说明为什么：
1、#include
class Student{
int sno;
int age;
void printStu();
void setSno(int d);
};
void printStu()
{
cout<<
cout<<
}
void setSno(int s)
{
sno=s;
}
void setAge(int a)
{
age=a;
}
void main()
{
Student lin;
(20021);
(20);
tu();
}
1)void printStu() 应该改为 void
Student::printStu()
2)void setSno(int s) 应该改为
void Student::setSno(int s)
3)Student的定义中应加入成员函数的声明语句 void setAge(int a);
4)void setAge(int a) 应该改为 void
Student::setAge(int a)
5)应将成员函数定义为public类型
在前面加 public:
2、
#include
class Point{
public:
int x,y;
private:
Point(){x=1;y=2;}
};
void main()
{
Point cpoint;
cpoint.x=2;
}
2.应将成员x定义为public
3、#include
void main( )
{
int x=0,y=5,z=3;
while(z>0 && ++x<3) y=y-1;
cout<
4、#include
void main()
{
int x=10;
int &y=x;
cout<<
x++;
cout<<
y++;
cout<<
}
5、#include
void main( )
{ int i,n=0;
for(i=2;i<10;i++)
{ if(i%3!=0) continue;
n++;
}
cout<
6、#include
class A
{
int *a;
public:
A(int x)
{
a=new int(x);
cout<<
}
};
void
main()
{
A x(3),*p;
p=new A(5);
delete p;
}
7、# include
class base
{
public:
virtual int
func () { return 0; }};
class derived: public
base
{
public:int func() { return 100; }
};
void main()
{
derived d;
base& b = d;
cout << () << endl;
cout
<< ::func() << endl;
}
8、#include
#define pi=3.1416;
const
float r=3.2;
void main()
{
float
s1,s2,c1,c2,r1;
c1=pi*r*r;
s1=2*pi*r;
r=2.8;
c2=pi*r*r;
s2=2*pi*r;
cout
1）#define pi=3.1416;
应改为 #define pi 3.1416
2) 修改了const类型的变量r 应改为
static float r=3.2;
3）cout
1、
class A
{
int * a;
int n;
public :
A(int
nn=0):n(nn)
{
if (n==0) a=0;
else a=__
a=(int *)malloc(n*sizeof(int));
_
分配长度为n的动态数组
}
void Seta(int * aa)
{
for (int i=0; i
_____~A();___ 定义析构造函数，释放动态数组空间
};
2、程序输出结果为
a转换为A
b转换为B
请将程序补充完整
#include
class Sample
{
char c1,c2;
public:
Sample （1）
void disp()
{
cout<
};
void main()
{
（2）
();
();
}
2.
1）
(char c)
{
}
2）
Sample a('a'),b('b');
3、下列程序的输出结果为：The
result is :5，请将程序补充完整
#include
#include
void main()
{ float
a=3,b=4;
cout<< （3）
（4）
}
3.
3）
4）
cout<
请将程序补充完整
#include
class c {
（5）
int x;
c(int px=10)
{x=px;}
void setx (int a) {x=a;}
（6）
};
（7）
{ cp(11); c*q;q=&p;
int p::c*cptr; int(c::*fptr)();
(8);
cptr=&c::x;
fptr=c::getx;
cout<
4.
5)
c1=c;
if(c1>='a'&&c1<='z')
c2=c1+'A'-'a';
public:
6)
int getx() {return x; }
7)
void main ()
5、下面程序是输出100内能被3整除且个位数是6的所有整数，请将程序补充完整
#include
void main()
{
int i,j;
for (i=0; ___（1）__;i++)
{
j=i*10+6;
if (___（2）__)
continue;
___（3）__;
cout<
}
5.
1)
i<10
2)
j%3
3)
else
6、 程序输出结果为counstructing object:x=1
请将程序补充完整
#include
class
Sample
{
int x;
public:
Sample(int a)
{
___（4）__
cout<<
}
};
void func(int n)
{
___（5）__
}
void main()
{
func(1);
func(10);
}
6.
4)
x=a;
5)
static Sample obj(n);
7、程序输出结果为：
A=2,B=7
A=5,B=7
请把程序补充完整
#include
class
Sample
{
int A;
static int B;
public:
Sample(int a){A=a,B+=a;}
static void func(Sample s);
};
void
Sample::func(Sample s)
{
___（6）__
}
int Sample::B=0;
void main()
{
Sample s1(2),s2(5);
___（7）__
Sample::func(s2);
}
7.
6)
cout<<
7)
Sample ::func(s1);
九、编程题：
1. 编写一个函数，实现两个数的交换。
#include
void Swap(int *x,int *y)
{
int a;
a=*x;
*x=*y;
*y=a;
}
int main()
{
int b,c;
cin>>b>>c;
cout<
cout<
2. 编写一个函数，返回三个整数形参中的最小值。
#include
void maxmin(int
a,int b,int c,int* max,int* min)
{
*max=a>b(a>ca:c):(b>cb:c);
*min=a
void main()
{
int a,b,c,max,min;
cin>>a>>b>>c;
maxmin(a,b,c,&max,&min);
cout<<
}
3. 编写一个类LEI，实现打印私有变量a的值。
class LET
{
public:
} 4、下面的函数统计子字符串substr在字符串str中出现的次数，如果substr在str中不出
现，则返回值
0。请完成该函数。
int str_count(char
*substr, char *str)
{
}
#include
int str_count(char *substr, char
*str)
{
int sum,len;
char * p;
len = strlen(substr);
display()
{
cin>>x;
cout<
int x;
private:
if(len<1)
return -1;
for(sum=0,p=str;;)
{
p = strstr(p,substr);
if(p!=NULL)
{
sum++;
p+=len;
}
else
break;
}
return sum;
}
5、定义个datetime类，使其对象可以显示当前系统时间和日期 。
#include
#include
class datetime
{
public:
int
year;
int month;
int day;
int hour;
int min;
int sec;
datetime()
{
struct tm* ptm;
time_t m;
time(&m);
ptm = localtime(&m);
year =
ptm->tm_year+1900;
month =
ptm->tm_mon+1;
day = ptm->tm_mday;
hour = ptm->tm_hour;
min =
ptm->tm_min;
sec = ptm->tm_sec;
}
void output()
{
printf(
}
};
void main(void)
{
datetime d;
();
}
6、
设计一个汽车类Vehicle，包含数据成员车轮数和车重，由它派生出类Car和类Truck，前者包含载
客
数，后者包含载重量。编写程序实现。
#include
class vehicle 定义汽车类
{
protected:
int wheels; 车轮数
float weight; 重量
public:
vehicle(int wheels,float weight);
int get_wheels();
float get_weight();
float wheel_load();
void show();
};
class car:public vehicle 定义小车类
{
int passenger_load; 载人数
public:
car(int wheels,float weight,int passengers=4);
int get_passengers();
void show();
};
class truck:public vehicle 定义卡车类
{
int passenger_load; 载人数
float
payload; 载重量
public:
truck(int
wheels,float weight,int passengers=2,float
max_load=24000.00);
int get_passengers();
float efficiency();
void show();
};
vehicle::vehicle(int wheels,float weight)
{
vehicle::wheels=wheels;
vehicle::weight=weight;
}
int
vehicle::get_wheels()
{
return wheels;
}
float vehicle::get_weight()
{
return weightwheels;
}
void
vehicle::show()
{
cout << 车轮:个
cout
<< 重量:公斤
}
car::car(int wheels, float
weight,
int passengers) :vehicle (wheels,
weight)
{
passenger_load=passengers;
}
int car::get_passengers ()
{
return passenger_load;
}
void car::show()
{
cout
<<车型:小车
vehicle::show();
cout <<
载人:人
cout << endl;
}
truck::
truck(int wheels, float weight,int passengers,
float max_load):vehicle(wheels,weight)
{
passenger_load=passengers;
payload=max_load;
}
int
truck::get_passengers()
{
return
passenger_load;
}
float
truck::efficiency()
{
return
payload(payload+weight);
}
void
truck::show()
{
cout
<<车型:卡车
vehicle:: show ();
cout <<
载人:人
cout << 效率:
cout << endl;
}
void main ()
{
car car1(4,2000,5);
truck tru1(10,8000,3,340000);
cout <<
输出结果
car1. show ();
tru1. show ();
}
7、设计一个点类Point，包含点的坐标x,y
两个数据成员，采用友元类的方式分别计算两点间的水平距离
和垂直距离。
#include
using namespace std;
class Point;先声明类型Point
int
horizontalDistance(const Point& first, const
Point& second);水平距离函数声明
int
verticalDistance(const Point& first, const Point&
second);垂直距离函数声明
class Point
{
private:
int x;横坐标
int y;纵坐标
public:
Point(int x=0, int y = 0)构造函数
{
this->x = x;
this->y = y;
}
friend int horizontalDistance(const Point&
first, const Point& second);
friend int
verticalDistance(const Point& first, const Point&
second);
};
水平距离函数定义
int
horizontalDistance(const Point& first, const
Point& second)
{
if(first.x -second.x
>=0)
return first.x-second.x;
else
return second.x-first.x;
}
垂直距离函数定义
int verticalDistance(const Point& first,
const Point& second)
{
if(first.y
-second.y >=0)
return first.y-second.y;
else
return second.y-first.y;
}
int
main()
{
Point a(1,2); 定义三个Point对象
Point b(0,0);
Point c(-1,-1);
测试
cout<< horizontalDistance(a,b) <
}
8、设计一个点类Point，包含横、纵两个坐标数据x,y，由它派生出圆类Circle,并添加
一个半径数据r，
求其面积area。
#include
上，控制输出精度
using namespace std;
#define PI 3.1415926
点类如下：
class Point
{
public:
Point()
{}
Point(float x1,float y1)
{
x=x1;
y=y1;
}
virtual
float area()=0;
virtual float perim()=0;周长
private:
float x;
float y;
};
class Circle:public Point
{
public:
Circle(float x1,float y1,float r1);
float area();
float perim();
private:
float r;
};
2012
一、单选题：
年大学C++期末考试题库
1. 能作为C++程序的基本单位是( C )。
A. 字符 B. 语句 C. 函数 D. 源程序文件
2.
程序中主函数的名字为（ A ）。
A. main B. MAIN
C. Main D. 任意标识符
3.
关于C++与C语言的关系的描述中，（D）是错误的。
A.
C语言是C++的一个子集; B. C语言与C++是兼容的;
C.
C++对C语言进行了一些改进; D. C++和C语言都是面向对象的
4.
可用作C++语言用户标识符的一组标识符是( B)。
A. void define
+WORD B. a3_b3 _123 YN
C. for
-abc Case D. 2a DO sizeof
5. 存储以下数据，占用存储字节最多的是（ D）。
A. 0
B. ‘0’ C. “0” D. 0.0
6. 设int
a=12；则执行完语句a+=a*a；后，a的值是( C )。
A. 12
B. 144 C. 156 D. 288
7. 假设在程序中 a、b、c
均被定义成整型，所赋的值都大于1，则下列能正确表示代数式
是( D )。
A.
1.0a*b*c B. 1(a*b*c) C. 1ab(float)c D.
1.0abc
8. 以下说法中正确的是（B）。
A.
C++程序总是从第一个定义的函数开始执行
B.
C++程序总是从main函数开始执行
C.
C++函数必须有返回值，否则不能使用函数
D.
C++程序中有调用关系的所有函数必须放在同一个程序文件中
9.
下面有关构造函数的描述中，正确的是（B ）。
A. 构造函数可以带有返回值
B. 构造函数的名字与类名完全相同
C. 构造函数必须带有参数
D. 构造函数必须定义，不能缺省
10.10.在声明类时，下面的说法正确的是（ ）。
A. 可以在类的声明中给数据成员赋初值
B.
数据成员的数据类型可以是register
C.
private，public，protected可以按任意顺序出现
D.
没有用private，public，protected定义的数据成员是公有成员
11.在下面有关析构函数特征的描述中，正确的是（ A ）。
A.
一个类可以有多个析构函数 B. 析构函数与类名完全相同
C.
析构函数不能指定返回类型 D. 析构函数可以有一个或多个参数
12.构造函数是在（B ）时被执行的。
A. 程序编译
B. 创建对象 C. 创建类 D. 程序装入内存
13.
下面有关静态成员函数的描述中，正确的是（ B ）
A.
在静态成员函数中可以使用this指针
B.
在建立对象前，就可以为静态数据成员赋值
C.
静态成员函数在类外定义是，要用static前缀
D.
静态成员函数只能在类外定义
1
的表达式
abc
14.下面
有关友员函数的描述中，真确的说法是（A ）
A.
友员函数是独立于当前类的外部函数
B.
一个友员函数不可以同时定义为两个类的友员函数
C.
友员函数必须在类的外部进行定义
D.
在类的外部定义友员函数时必须加上friend关键字
15.友员的作用之一是（ A ）
A. 提高程序的运行效率 B. 加强类的封装
C. 实现数据的隐蔽性 D. 增加成员函数的种类
16.使用派生类的主要原因是（ A ）
A. 提高代码的可重用性
B. 提高程序的运行效率
C. 加强类的封装性 D.
实现数据的隐藏
17.在C++中继承方式有几中（ C ）
A. 1 B. 2 C. 3 D. 4
18.假设
已经定义好了类student，现在要定义类derived，它是从student私有派生的，则定义类d
erived
的正确写法是（ D ）
A. class
derived ：：student private{ ………….}
B.
class derived ：：student public { ………….}
C. class derived ：：public student { ………….}
D. class derived ：：private student{ ………….}
19.派生类的对象对它的基类成员中（C）是可以访问的。
A.公有继承的公有成员; B.公有继承的私有成员；
C.公有继承的保护成员； D.私有继承的公有成员。
20.
类中定义的成员默认为（A ）访问属性。
A. public B.
private C. protected D. friend
21.下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（
A ）
合适。
A. 内联函数; B. 重载函数; C.
递归调用； D. 嵌套调用。
22.C++对C语言作了很多改进，下列描述中（D）使得C语言
发生了质变，从面向过程变成了面向对象。
A. 增加了一些新的运算符；
B. 允许函数重载，并允许设置缺省参数；
C. 规定函数说明必须用原型；
D. 引进了类和对象的概念；
23.按照标识符的要求，（A）符号不能组成标识符。
A. 连接符 B. 下划线 C.大小写字母 D.
数字字符
24.下列变量名中，（ A ）是合法的。
A CHINA
B byte-size C double D A+a
25.下列各种函数中，（ C）不是类的成员函数。
A 构造函数
B 析构函数 C 友元函数 D 拷贝构造函数
26.下列（ A
）是正确的语句。
A ； B a=17 C x+y
D cout<<
27.不能作为函数重载判断的依据的是(B )
A.返回类型 B. const C.参数个数 D.
参数类型
28.通常,拷贝构造函数的参数是(C )
A.某个对象名
B.某个对象的成员名
C.某个对象的引用名
D.某个对象的指针名
29.下面对静态数据成员的描述中,正确的是(C )
A 类的不同对象有不同的静态数据成员值
B
类的每个对象都有自己的静态数据成员
C静态数据成员是类的所有对象共享的数据
D 静态数据成员不能通过类的对象调用
30.假定AB为一个类,则执行AB x;语句时将自动调用该类的( B)
A.有参构造函数 B.无参构造函数 C.拷贝构造函数 D.赋值构造函数
31.C++程序从上机到得到结果的几个操作步骤依次是( B )。
A. 编译、编辑、连接、运行 B. 编辑、编译、连接、运行
C. 编译、运行、编辑、连接 D. 编辑、运行、编辑、连接
32.假定一条定义语句为“int a[10], x,
*p=a;”，若要把数组a中下标为3的元素值赋给x，则不正确的
语句为（A ）。
A. x=p[3]; B. x=*(a+3); C. x=a[3];
D. x=*p+3;
33.关于封装，下列说法中不正确的是（D ）。
A. 通过封装，对象的全部属性和操作结合在一起，形成一个整体
B.
通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
C.
通过封装，每个对象都成为相对独立的实体
D.
通过封装，对象的属性都是不可见的
34.预处理命令在程序中都是以( B )符号开头的。
A. * B. # C. & D. @
35.存储以下数据，占用存储字节最少的是（ B ）。
A. 0
B. ‘0’ C. “0” D. 0.0
36.程序运行中需要从键盘上输入多于一个数据时，各数据之间应使用( D
)符号作为分隔符。
A. 空格或逗号 B. 逗号或回车
C. 逗号或分号 D. 空格或回车
37.假定变量m定义为“int
m=7;”，则定义变量p的正确语句为（ B ）。
A. int
p=&m; B. int *p=&m; C. int &p=*m;
D. int *p=m;
38.下面的哪个保留字不能作为函数的返回类型？ C
。
A. void B. int
C. new D. long
39.采用重载函数的目的是（ B
）。
A.实现共享 B.减少空间 C.提高速度
D.使用方便，提高可读性
40.假定AB为一个类，则( C
)为该类的拷贝构造函数的原型说明。
A. AB(AB x); B.
AB(int x); C. AB(AB& x); D. void AB(AB& x);
41、 C++对C语言作了很多改进，下列描述中（D
）使得C语言发生了质变，从面向过程变成了面向对象。
A、增加了一些新的运算符；
B、允许函数重载，并允许设置缺省参数；
C、规定函数说明必须用原型；
D、引进了类和对象的概念；
42、
所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是
(A)。
A.类 B.对象 C.函数体 D.数据块
43、
关于new运算符的下列描述中，（C ）是错误的。
A、 它可以用来动态创建对象和对象数组；
B、使用它创建的对象或对象数组可以使用运算符delete删除；
C、使用它创建对象时要调用构造函数；
D、使用它创建对象数组时必须指定初始值；
44、 （D ）不是构造函数的特征。
A、构造函数的函数名与类名相同；
B、构造函数可以重载；
C、构造函数可以设置缺省参数； D、构造函数必须指定类型说明。
45、 假定一个类的构造函数为B(int x,int
y){a=x--;b=a*y--;},则执行B x(3,5);
语句后，x.a和x.b
的值分别为(C )
A、 3和5 B、 5和3
C、 3和15 D、20和5
46、 关于成员函数特征的下列描述中，（
A）是错误的。
A、成员函数一定是内联函数； B、成员函数可以重载；
C、成员函数可以设置缺省参数值； D、成员函数可以是静态的；
47、
在公有继承的情况下，基类成员在派生类中的访问权限（B ）。
A、受限制
B、保持不变 C、受保护 D、不受保护
48、 友元的作用是（
A）。
A、提高程序的运用效率； B、加强类的封装性；
C、实现数据的隐藏性；
D、增加成员函数的种类；
49、 在C++中，关于下列设置缺省参数值的描述中，（B
）是正确的。
A、不允许设置缺省参数值；
B、在指定了缺省值的参数右边，不能出现没有指定缺省值的参数；
C、只能在函数的定义性声明中指定参数的缺省值；
D、设置缺省参数值时，必须全部都设置；
50、关于delete运算符的下列描述中，（
C）是错误的。
A、它必须用于new返回的指针；
B、使用它删除对象时要调用析构函数；
C、对一个指针可以使用多次该运算符；
D、指针名前只有一对方括号符号，不管所删除数组的维数。
51、const int
*p说明不能修改（ C）。
A、p指针； B、p指针指向的变量；
C、p指针指向的数据类型； D、上述A、B、C三者；
52、当需要打开A盘上的以文件用于输入时，则定义文件流对象的语句为 (B )。
A、fstream fin(“A:”,1) B、ifstream
fin(“A:”,ios::nocreate)
C、ofstream fin(“A:”)
D、ifstream fin(“A:”,ios::app)
53、派生类的对象对它的基类成员中（A ）是可以访问的。
A、公有继承的公有成员；
B、公有继承的私有成员；
C、公有继承的保护成员； D、私有继承的公有成员；
54、假定一个字符串的长度为n，则定义存储该字符串的字符数组的长度至少为（C）。
A、n-1 B、n C、 n+1 D、n+2
55、 在int a=3; *p=&a;中，*p的值是（ D）。
A、变量a的地址值
B、无意义 C、变量p的地址值 D、 3
56、
下列常量中，（ D）不是字符常量。
A、’005’ B、’n’ C、 ’c’
D、“a”
57、在int a=3,*p=&a;中，*p的值是（ D）。
A）变量a的地址值 B）无意义 C）变量p的地址值
D） 3
58、以下4个选项中，不能看作一条语句的是（B ）。
A)
if(b==0) m=1;n=2; B) a=0,b=0,c=0; C)
if(a>0); D) {;}
59、（D ）不是构造函数的特征。
A）构造函数的函数名与类名相同 B）构造函数可以重载
C）构造函数可以设置缺省参数 D）构造函数必须指定类型说明
60、以下程序段中与语句k=a>b 1:0；功能等价的是（D ）。
A）
if(a>b) k=1; B） if(a>b) k=0
C）if(a>b) k=1; D）if(a
A）’005’ B）’n’ C) ’c’
D）
62、表示“x大于1而小于10”的逻辑表达式是（B ）。
A）1
63、关于成员函数特征的下列描述中，（ A）是错误的。
A）成员函数一定是内联函数 B）成员函数可以重载
C）成员函数可以设置缺省参数值 D）成员函数可以是静态的
64、有以下程序
#include
void main( )
{
int i,s=0;
for(i=1;i<10;i+=2) s+=i;
cout<
A）
自然数1～9的累加和 B） 自然数1～10的累加和
C）
自然数1～9中的奇数之和 D） 自然数1～10中的偶数之和
65、设有定义：int
n=0,*p=&n,**q=&p;则以下选项中，正确的赋值语句是（D）。
A） p=1;
B） *q=2; C） q=p; D） *p=5;
66、（
A）能正确输出结果：C++。
A） char s[]=
B）char
s[3]=
C）char
s[3]={'C','+','+','0'};cout<
int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a,b;
b=p[5];
b中的值是（ B）。
A）5 B）6
C） 8 D） 9
68、有以下程序
#include
void main( )
{ char
*p[10]={
cout<
执行后输出结果是
B
A）dcdbe B） abbd C） abc
D） abb
69、下列静态数据成员的特性中，（C ）是错误的。
A）
说明静态数据成员时前边要加修饰符static
B） 静态数据成员要在类体外进行初始化
C） 静态数据成员不是所有对象所共用的
D）引用静态数据成员时，要在其名称前加<类名>和作用域运算符
70、有以下语句
struct S
{ int g;
char h;} T;
则下面叙述中不正确的是（C ）。
A）S是结构体名
B）该结构体包含2个成员
C）S是struct类型的变量 D）T是struct
S类型的变量
71、派生类的对象对它的基类成员中（ A）是可以访问的。
A）公有继承的公有成员
B）公有继承的私有成员
C）公有继承的保护成员
D）私有继承的公有成员
72、实现运行时的多态性用 。D
A、重载函数
B、构造函数 C、析构函数 D、虚函数
73．下列变量名中，（ A ）是合法的。
A. CHINA B. byte-size C. double D.
A+a
74. 在int
b[][3]={{1},{3,2},{4,5,6},{0}};b[2][2]的值是（D ）。
A. 0 B. 2 C. 5 D. 6
75. 下列各运算符中，（B）优先级最高。
A. +（双目） B. *（单目）
C. <= D. *=
76. 下列for循环的次数为（ B ）。
for(int i(0),x=0;!x&&i<=5;i++)
A. 5
B. 6 C . 1 D. 无限
77.
下述关于break语句的描述中，（ C ）是正确的。
A.
break语句可用于循环体内，它将退出该重循环。
B.
break语句可用于开关语句中，它将退出开关语句。
C.
break语句可用于if体内,它将退出if语句。
D.
break语句在一个循环体内可以出现多次。
78.
在一个被调用函数中，关于return语句使用的描述，（D ）是错误的。
A.
被调用函数中可以不用 return语句。
B. 被调用函数中可以使用多个return语句。
C. 被调用函数中，如果有返回值，就一定要有return语句。
D.
被调用函数中，一个return语句可返回多个值给调用函数。
79.
在C++中，关于下列设置参数默认的描述中，（ C ）是正确的。
A.
不允许设置参数的默认值。
B. 设置参数默认值只能在定义函数时设置。
C.
设置参数默认值时，应该是先设置右边的再设置左边的。
D.
设置参数默认值时，应该全部参数都设置。
80.
下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ A
）
合适。
A. 内联函数 B. 重载函数 C. 递归调用
D. 嵌套调用
81. 下列的各类函数中，（ C ）不是类的成员函数。
A.
构造函数 B. 析构函数 C . 友元函数 D. 拷贝初始化构造函数
82. （ D）不是构造函数的特征
A. 构造函数的函数名与类名相同 B.
构造函数可以重载
C. 构造函数可以设置缺省参数 D.
构造函数必须指定类型说明
83.
f1(int)是类A的公有成员函数，p是指向成员函数f1()的指针，采用（ C）是正确的。
A. p=f1 B. p=A::f1 C.
p=A::f1() D. p=f1()
84.
下列定义中，（A ）是定义指向数组的指针p。
A. int *p[5] B.
int (*p)[5] C. (int *)p[5] D. int *p[ ]
85．循环while(int i=0) i--；执行次数是（ A ）。
A. 0
B. 1 C . 5 D . 无限
86. 设int
x；，则经过（ C ）后，语句*px=0；可将x值置为0。
A. int * px；
B . int const * px=&x；
C. int * const
px=&x； D. const int * px=&x；
87. 设void
f1(int * m，long & n)；int a；long b；则以下调用合法的是（ B
）。
A. f1(a，b)； B. f1(&a，b)；
C. f1(a，&b)； D. f1(&a，&b)
88. 关于对象概念的描述中，（ A ）是错误的。
A.
对象就是C语言中的结构变量;
B. 对象代表着正在创建的系统中的一个实体；
C. 对象是一个状态和操作（或方法）的封装体;
D.
对象之间的信息传递是通过消息进行的;
89. 在下列double型常量表示中，（A
）是错误的。
A. E15; B. .35; C. 3E5;
D. 3E-5
90. 下列给字符数组进行初始化中，（A ）是正确的。
A.
char s1[ ]=
C. char s3[][3]={‘a’,’x’,’y’};
D. char s4[2[3]={
91. 对于int *pa[5];的描述，（ D
）是正确的。
A. pa是一个指向数组的指针，所指向的数组是5个int型元素；
B.
pa是一个指向某个数组中第5个元素的指针，该元素是int型变量；
C.
pa[5]表示某个数组的第5个元素的值；
D.
pa是一个具有5个元素的指针数组，每个元素是一个int型指针；
92. 下列各运算符中，（
A ）优先级最低。
A．？： B. | C. ||
D. ！=
93. 下列for循环的循环体执行次数为（ D ）。
for(int
i(0),j(10);i=j=4;i++,j- -)
A. 0; B.
1; C. 4; D. 无限;
94.
下述关于开关语句的描述中，（ A ）是正确的。
A.
开关语句中default子句可以没有，也可以有一个;
B.
开关语句中每个语句序列中必须有break语句;
C.
开关语句中default子句只能放在最后；
D.
开关语句中case子句后面的表达式可以是整形表达式。
95. 下列存储类标识符中，（ C
）的可见性与存在性不一值。
A. 外部类； B. 自动类; C.
内部静态类； D. 寄存器类。
96. 下述静态数据成员的特征中，（ D）是错误的。
A. 说明静态数据成员时前边要加修饰符static;
B.
静态数据成员要在类体外进行初始化；
C.
引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符；
D.
静态数据成员不是所有对象所共用的。
97. （ A）是析构函数的特征。
A.
一个类中只能定义一个析构函数; B. 析构函数与类名不同;
C.
析构函数的定义只能在类体内; D. 析构函数可以有各个或多个参数。;
98.
已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，（ C
）是
正确的。
A. A1.p=5; B.
A1->p=5;
C. A.*p=5; D.
*A1.p=5;
99. 关于new运算符的下列描述中，( D )是错的。
A.
它可以用来动态创建对象和对象数组；
B.
使用它创建的对象或对象数组可以使用运算符delete删除;
C.
使用它创建对象时要调用构造函数；
D. 使用它创建对象数组时必须指定初始值。
100. 派生类的构造函数的成员初始化列中，不能包含（C ）。
A.
基类的构造函数;
B. 派生类中子对象的初始化;
C. 基类的子对象初始化;
D. 派生类中一般数据成员的初始化
101. 派生类的对象对它的基类成员中（
A）是可以访问的。
A. 公有继承的公有成员;
B. 公有继承的私有成员；
C. 公有继承的保护成员；
D. 私有继承的公有成员。
102．C++类体系中，不能被派生类继承的有（ A）。
A.构造函数
B.虚函数 C.静态成员函数 D.赋值操作函数
103．下面标识符中正确的是（A ）。
A．_abc B．3ab
C． int D．+ab
104．下列哪项（ D
）不是面向对象程序设计的主要特征？
a.封装 b.继承 c.多态 d.结构
105．已知i=5，j=0，下列各式中运算结果为j=6的表达式是（ A ）。
A．j=i+（++j） B．j=j+i++ C．j=++i+j
D．j=j+++i
106．若整型变量a、b、c、d中的值依次为：1、4、3、2。则条件表达
式a
107．以下不正确的是（ C ）。
A．语句for（i=0；；i++）表示无限循环 B．for（；；）表示无限循环
C．for（）也表示无限循环 D．while（1）表示无限循环
108．有如下程序：
int x=3；
do{
X-=2；
cout<
执行这个程序的输出结果是（ C ）。
A． 1 B．30 C．1-2
D．死循环
109．若有以下定义，则说法错误的是( D)。
int
a=100,*p=&a
A．声明变量p，其中*表示p是一个指针变量
B．变量p经初始化，获得变量a的地址
C．变量p只可以指向一个整形变量
D．变量p的值为100
110．下面关于数组的初始化正确的是（ A
）。
A．char str[]＝{‘a'，’b'，'c‘}
B．char
str[2]＝{'a'，'b'，'c’}
C．char
str[2][3]＝{{'a‘，'b’}，{’e’，'d’}，{’e’，‘f'}}
D．char str[]＝{'a'，'b'，'c’}
111．若已定义：
int a[]={0，1，2，3,4,5，6，7，8，9}，*P=a，i;
其中0≤i≤9，则对a数组元素不正确的引用是（ D ）。
A．a[p-a]
B．*(&a[i]) C．p[i] D．a[10]
112．存在定义int
a[10]，x，*pa;，若pa=&a[0]，下列的哪个选项和其他3个选项不是等价的
A． x＝*pa; B．x＝*(a+l);
C．x＝*(pa+1); D．x＝a[1];
113．对数组名作函数的参数，下面描述正确的是（B）。
A．数组名作函数的参数，调用时将实参数组复制给形参数组。
B．数组名作函数的参数，主调函数和被调函数共用一段存储单元。
C．数组名作参数时，形参定义的数组长度不能省略。
D．数组名作参数，不能改变主调函数中的数据。
114．关于静态成员的描述中，（
B ）是错误的。
A． 静态成员可分为静态数据成员和静态成员函数。
B．
静态数据成员定义后必须在类体内进行初始化。
C． 静态数据成员初始化不使用其构造函数。
D． 静态数据成员函数中不能直接引用非静态成员。
115．下列关于构造函数的描述中，错误的是（ D ）。
A．构造函数可以设置默认的参数 B．构造函数在定义类对象的自动执行
C．构造函数可以是内联函数 D．构造函数不可以重载
116．假设OneClass为一个类，则该类的拷贝初始化构造函数的声明语句为（ C ）。
A. OneClass(OneClass p); B.
OneClass& (OneClass p);
C. OneClass(OneClass &
p); D. OneClass (OneClass *p);
117．如果类A被说明成类B的友元，则（ D ）。
A.类A的成员即类B的成员。
B.类B的成员即类A的成员。
C.类A的成员函数不得访问类B的成员 。
D.类B不一定是类A的友元。
118、关于对象和类的关系，说法正确的是（ C ）。
A) 同属于一类的对象，具有相同的数据成员和成员函数。
B)
对象是具体，是类的对象，同其他变量一样，先定义后使用。
C)
同一类的不同对象，其具有的操作可不同，具体的操作也不同。
D)
不同类的对象，可有相同的操作。
119、双精度浮点型的字节数是（ D ）。
A）4
B）1 C）0 D）8
120、下列关于C++函数的说明中正确的是（
D ）。
A) 内联函数就是定义在另一函数体内部的函数。
B)
函数体的最后一条语句必须是RETURN语句。
C)
标准C++要求在调用一个函数之前，必须先声明其原型。
D)
编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式。
A ）。 （
121、下列关于虚函数的说明中，正确的是（ B ）。
A)
从虚基类继承的函数都是虚函数。
B) 虚函数不得是静态成员函数。
C) 只能通过指针和引用调用虚函数。
D) 抽象类中的成员函数都是虚函数。
122、下列符号中可以用作C++标识符的是（ A ）。
A)
_radius B) foo~bar C) else D)
3room
123、结构化程序设计所规定的三种基本控制结构是（ C ）。
A)输入、处理、输出 B)树形、网形、环形
C)顺序、选择、循环
D)主程序、子程序、函数
124、下列语句中错误的是（ B ）。
A)
const int buffer=256; B) const int int
temp;
C) const double *point; D)
const double *rt=new double(5.5)
125、下列关于实参和形参说法错误的是（ D ）。
A）实参可以是变量、常量、或表达式。
B）实参与形参的类型必须一致，否则会发生“类型不匹配”的错误。
C）实参对形参的数据传递是单向传递，调用结束后，实参单元被释放。
D）形参必须是变量。
126、关于内联函数说法错误的是（ C ）。
A）不是任何一个函数都可定义成内联函数。
B）内联函数的函数体内不能含有复杂的结构控制语句。
C）递归函数可以被用来作为内联函数。
D）内联函数一般适合于只有1～5行语句的小函数。
127、关于保护继承的说法正确的是（ D ）。
A）基类的公有成员、私有成员可被子类继承下来，而且性质不变。
B）基类的公有成员、私有成员可被子类继承下来，而且性质改变为保护成员。
C）基类的公有成员、私有成员可被子类继承下来，而且性质均改变为私有成员。
D）基类的公有成员、私有成员可被子类继承下来，性质不变，私有成员不被继承。
128、关于函数的返回值说法正确的是（ A ）。
A)由return语句返回时，只带回一值，其类型在函数定义时确定。
B)其类型由调用表达式决定。
C)函数可以没有返回值，这时在函数定义，函数的类型说明就没必要了。
D)函数调用就要有返回值，否则调用就没意义了。
129、下列合法的标识符是（D ）。
A） abde+ B)#KSJF C)67KDJ D)DK3-
130、关于结构化程序设计方法说法错误的是（ D ）。
A）在数据处理过程中，采用的是自顶向下、分而治之的方法。
B）将整个程序按功能划分为几个可独立编程的子过程模块。
C）以“对象”或“数据”为中心。
D）数据和处理数据的过程代码是分离的、相互独立的实体。
131、运算符重载是对已有的运算符赋予多重含义，因此（ C ）。
A）可以对基本类型（如int类型）的数据，重新定义“+”运算符的含义。
B）可以改变一个已有运算符的优先级和操作数个数。
C）只能重载C++中已经有的运算符，不能定义新运算符。
D）C++中已经有的所有运算符都可以重载。
132、关于C++程序说法不正确的是（ D ）。
A)
C++程序由函数构成，但只有一个main()函数 。
B)
C++程序中main()函数可以在程序的任何位置 。
C)
C++程序由main()函数开始执行，由main()结束执行。
D)
main()都是没有参数的。
133、已知a=4,b=6,c=8,d=9,则“(a++,b>
a++&&c>d)++d:a
134、下面有关重载函数的说法中正确的是（ C ）。
A)重载函数必须具有不同的返回值类型。
B)重载函数形参个数必须不同。
C)重载函数必须有不同的形参列表。
D)重载函数名可以不同。
135、C++语言的跳转语句中，对于break和continue说法正确的是（ B ）。
A)break语句只应用于循环体中。
B)continue语句只应用于循环体中。
C)break是无条件跳转语句，continue不是。
D)break和continue的跳转范围不够明确，容易产生问题。
136、long[int]的字节数是（D ）。
A）4
B）1 C）0 D）8
137、下列非法的字符常量是（ C ）。
A）‘#’ B）‘’ C）a’ D）‘A’
二、填空：
1. C++语言的头文件与源程序文件扩展名分别是（.h ）和（ .cpp ）。
2. 在C++程序中使用基本输入与输出流时需要包含的头文件名是（ iostr
eam ）。
3. 在C++语言中，惟一的一个三目运算运算符是（ : ）。
4. C++中当一个函数无返回值时，则函数的类型是（void ）。
5. 一个类中可以有（多）个构造函数，只能有（ 一 ）个析构函数。
6.一般情况下,按照面向对象的要求,把类中的数据成员(属性)定义为（ 私有 ）权限,
而把成员函数(方法)定义为（公有 ）权限.
7.在定义类的对象时,C++程序将自动调用该对象的（ 构造
）函数初始化对象自身.在撤销类的对
象时,C++程序将自动调用该对象的（ 折构 ）
函数.
8.类继承中,缺省的继承方式是（ 私有继承 ）.
9．在C++语言中，用转义字符序列（ 'n' ）或操纵符（ endl
）表示输出一个换行符。
10．表达式a=a＋l表示成增量表达式为（ ++a ）。
11．当不需要函数返回任何值时，则应把该函数类型定义为（ void ）。
12．用于输出表达式值的标准输出流对象是（
cout）。，用于从键盘上为变量输人值的标准输人流对
象是（cin ）。
13、变量分为全局和局部两种，（全局变量默认初始化为0
）。变量没有赋初值时，其值是不确定的。
14、假定类AB中有一个公用属性的静态数据成员bb，
在类外不通过对象名访问该成员bb的写法为
（ AB：:bb ）。
15、类的成员分为＿数据成员＿和＿成员函数＿。
16、一个＿类＿和＿对象＿的关系，正如基本数据类型与该类型的变量一样，如int x;。 17、对一个类中的数据成员的初始化可以通过构造函数中的＿赋值＿实现，也可以通过构造函数中的＿初<
br>始化列表＿实现。
18、类有两种用法：一种是＿定义对象＿，即生成类的对象；另一种是通过＿派生＿，派生出新的类。
19、C++语言提供的＿多态＿机制允许一个派生类继承多个基类，即使这些基类是相
互无关的。
20、声明虚函数的方法是在基类中的成员函数原型前加上关键字＿virtual＿。
21、如果一个类中有一个或多个纯虚函数，则这个类称为＿虚基类＿。
22、静态数据成员在定义或说明时，前面要加上关键字＿static＿。
23、如果成员函数不需要访问类的＿非静态＿成员，则可以把它声明为静态成员函数。
24、友元可以是＿全局函数＿，也可以是＿其他类的成员函数＿。
25、若需要把一个函数“void
fun();”定义为一个类A的友元函数，则应在类A的定义中加入一条语句：
＿friend
void fun（）；＿。
26、运算符函数中的关键字是＿operator＿，它和＿运算符＿
一起组成该运算符函数的函数名。
27、类中运算符重载一般采用两种形式：＿成员函数＿和＿友元函数＿。
28、面向对象程
序设计的3大机制为：＿封装性＿、＿继承性＿和＿多态性＿。2、类的访问权限有＿
public＿、
＿private＿和＿protected＿三种。
29、构造函数是＿对象＿被创建时自动执行，对象消失时自动执行的成员函数称为＿析构函数＿。
30、如果类A继承了类B，则类A称为＿基类＿，类B称为＿派生类＿。
31、如果一个特定的类型S当且仅当它提供了类型T的行为时，则称类型S是类型T的＿＿子类型＿。
32、在类定义中，将＿=0＿置于虚函数的函数原型的末尾可以声明该函数为纯虚函数。
33、类的静态成员分为＿静态数据成员＿和＿静态成员函数＿。
34、友元函数的声明可以放在类的＿私有＿部分，也可以放在类的＿共有＿部分，它们是没有区别的。
35、如果说类B是类A的友元类，则类B的所有成员函数都是类A的＿成员函数＿。
36、
设a和b是两个整型变量，我们用a+b的形式求这两个变量的和；设c和d为浮点型变量，我们用c+d
的形式求这两个变量的和。显然运算符“+”具有不同的用途，这是＿运算符重载＿的例子。
37、对于双目运算符，若重载为类的成员函数，有1＿个参数；若重载为友元函数，则有＿2个参数。
38、 当建立__一个新的对象___，程序自动调用该类的构造函数。
39、
在C++中有二种参数传递方式：__传值___ 和___引用__ 。
40、
模板对处理数据的类型的要求不同可以分为两种类型：__函数模板__ 和 __ 类模板__。
41、 异常是通过_检查（try）__
、_抛出（throw）__和__捕捉（catch）__ 来实现的。
42、
虚函数实现了C++的__多态__ 机制，类实现了C++的___封装__ 机制。
43、
面向对象程序设计的___继承___机制提供了重复利用程序资源的一种途径。
44、C++语言程序设计的三种基本结构是：_顺序结构_ 、 _选择结构_ 、
__循环结构__ 。
45、为了避免嵌套的条件语句if-
else的二义性，C++语言规定else与__if __配对使用。
46、定义函数时，在函数的类型前加上修饰词 ___ inline
___，指明将该函数定义为内联函数。
47、有说明语句：*p；则*p++运算首先访问
___*p___，然后使__p____ 的值加1。
48、执行int *p=new int
操作，可以得到一个动态分配整型对象的__指针____。
49、有说明语句：int
*p；则(*p)++运算首先访问 ___*p___，然后使 __*p____的值加1。
50． C++目标程序经___编译链接___后生成扩展名为exe的可执行程序文件。
51． 16位计算机中整型占___2_______个字节存储空间。
52．
要在屏幕上显示，world!应执行语句cout<<_______ ，world!。
53．
表达式8&3的结果是___0_______。
54．
作为语句的函数调用是通过____
函数的副作用
____来体现的。
55．
执行if (x>=0||x<=0) cout<<；else
cout<<；屏幕上显示的是____abcd____。
56．
设一维整型数组data已进行了初始化，则其元素个数可由操作符sizeof通过表达式____
sizeof(data)
sizeof(int) ___计算出来。
57．
若一全局变量只允许本程序文件中的函数使用，则定义它时应加上修饰符__ static ______。
58． 设有int
w[3][4]；，pw是与数组名w等价的数组指针，则pw应初始化为____ int*[4] pw =
w; _____。
59.要使引用pr代表变量char *
p；，则pr应初始化为________ char*& pr = p; ________。
60．在C++中封装性、继承性和_____多态性
61．假设int
a=1，b＝2;则表达式a+++--b的值为 __2____。
62．下面的程序实现输出x，y，z三个数中的最大值，请填入正确的内容。
#include
void main（）
{
int x=5,y=8,z=9, u, v;
if__（x〉u）__ u=x;
else u=y;
if_（u〉v）__ v=u;
else v=z；
cout<<”v=”<
63．C++语言的参数传递机制
包括传值和传地址两种，如果调用函数时，需要改变实参或者返回多个值，应
该采取 __传地址___
方式。
64．在C++语言中，访问一个对象的成员所用的运算符是 ___ .,
____，访问一个指针所指向的对象的成员
所用的运算符是 ___ -> ___。
65．C++语言支持的两种多态性分别是编译时的多态性和 __运行时___的多态性。
66．设有如下程序结构：
class Box
{ … };
void
main()
{Box A,B,C; }
该程序运行时调用___3__次构造函数；调用 ___3__次析构函数。
67．目前，有两种重要的程序设计方法，分别是：___面向过程__和___面向对象___。
68． C++语言提供的基本控制结构可以分为3种类型：顺序结构、__分支__ 和循环结构。
69．函数的调用主要分为传值调用和__引用调用____调用。前者的特点是_不能改变传入变量的
值 _。
70．函数重载时要求同名函数的_参数个数__或_参数类型__不同，否则无法确定是哪个函数。
71．静态数据成员是类的所有对象中的____共享__成员，而非静态数据成员是属于___一个具
体___对象
的。
72． 设A为test类的对象且赋有初值,则语句test
B(A); 表示__
将对象A复制给对象B
___。
73.面向对象程序设计方
法中的每个对象都具有_
属性
__和___
方法
__两方面的特征。
74.“类”指的是____
对象的类型，代表了某一批对象的共性和特征
_____。 <
br>75.构造数据类型，包括数组、_
指针
_、_
结构体和共用体
_、_
_
枚举
_和类等。
76.C++中数据类型标识符Signed
Char，其字节数为__1___，范围是__
-128到127
___。
77.
在函数体内部定义的变量称为__
局部变量
_。在所有函数体外部定义的变量称为__
全局变量
__。
78.有一数学表达式为23(f-32)，要写成对应的C++的表达式时
，正确地写法应写__
2.03.0*（f-32）
_。
79.类的静态成员是_<
br>的所有对象中共享
_的成员，不是_
某个对象
___的成员，静态成员在___
类的声
明中
__进行引用性说明，在_
其文件作用域的其他地方
_进
行定义性说明。
80.使用传统的结构化程序设计方法设计程序的步骤是__
自顶向下
___、__
逐步细化
_、__
模块化设计
_。
81.
“封装”指的是_
将有关的数据和操作代码封装在一个对象中，形成一个基本单位，各个
对象之
间相互独立，互不干扰，且将对象中某些部分对外隐藏
_。
82.可以让新类继承已定义的
类的_
数据成员
_和_
成员函数
_，这个新类称为__
继承
_，原来的类称为___
基类
__。新类可以从一个类中派生，这叫__
单继承
__，也可以从多个类中派生，称为__
多重继承
_。
83.指针
类型变量用于存储__
另一变量的地址
__，在内存中它占有____
一个
_
_存储单元。
84.类有三种继承方式，分别是：__
公有继承
_、__
保
护继承
__、___
私有继承
_。
三、判断下列描述的正确性：
1、C++中标识符内的大小写字母是没有区别的。
（F）
2、C++是一种以编译方式实现的高级语言。
（T）
3、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
（ F）
4、在私有继承中，基类中所有成员对派生类都是不可见的。
（ F）
5、返回值类型、参数个数和类型都相同的函数也可以重载。
（F）
6、使用关键字class定义的类中缺省的访问权限是私有（private）的。
（T）
7、类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。（F） ）
8、C++中使用了新的注释符（），C语言中注释符（*…*）不能在C++中使用。
（ F）
9、While循环语句的循环体至少执行一次。
（ F）
10、引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。
（T ）
11、类封装了数据和操作。
（ T ）
（ F ）
13、类中的数据成员不能为指针类型。
（ F ）
14、析构函数可以有形参。 （T
）
15、派生类至少有一个基类。
（T ）
（ T ）
17、全局函数和静态成员函数也能声明为虚函数。 （F ）
18、在一个类的对象空间里不包含静态成员的空间。 （ T ）
20、运算符重载后，原运算符的优先级和结合特性会改变。 （ F ）
21、一个类只能有一个对象。 （
F）
22、在类中不能对所定义的数据成员进行初始化。 （ T ）
23、类的公有成员函数是类与外界的接口。 （ T ）
24、构造函数没有函数类型。 （
T ）
（ T ）
（ F ）
27、只有类的成员函数才能声明为虚函数。
（ T ）
28、在一个类的对象空间里已经包含了静态成员的空间。 （F ）
30、运算符重载后，原运算符的优先级和结合特性不会改变。 （ T ）
31.
C++中使用了新的注释符（），C语言中注释符（*…*）不能在C++中使用。 （ F）
32.
数组赋初值时，初始值表中的数据项的数目可以大于或等于数组元素的个数。 （ F）
33.
隐含的类型转换都是保值映射，显式的类型转换都是非保值映射。 （ F）
34. 宏定义命令是以分号结束的。
（ F）
35. While循环语句的循环体至少执行一次。
（ F）
36. 返回值类型、参数个数和类型都相同的函数也可以重载。
（ F）
37. 函数形参的作用域是该函数的函数体。
（ T）
38. 静态类标识符在它的作用域之外是不存在的。
（ F）
12、在类的定义中，必须包含private、public、protected三种存
取方式对应的部分。
16、在公有和保护继承方式下，派生类的对象可以对基类的保护成员进行访问。
19、友元本身就是类的成员。 （
T ）
25、在派生类的构造函数的初始化表中不能对包含基类的子对象初始化。
26、在公有和保护继承方式下，派生类的成员可以对基类的保护成员进行访问。
29、C++不允许将构造函数、析构函数和虚函数声明为友元函数。（ T ）
39. 对象成员的表示与结构变量成员表示相同，使用运算符.或->。
（T ）
40. 某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。
（T ）
41. 对象数组的元素可以是不同类的对象。
（ T）
42. const char *p说明了p是指向字符串的常量指针。
（F ）
43、引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。（
F）
44、无论是私有继承还是保护继承中，基类中所有成员对派生类对象都是不可见的。（T ）
45、当break语句用在双重循环的内循环中时，它只能退出内循环到外循环中去，而不能直出整个
双重循
环。
（ T）
46、 For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。
（F ）
47、返回值类型、参数个数和参数类型都相同的函数也可以重载。
（ F）
48、通常的拷贝初始化函数的参数是某个对象的成员名或对象的引用名。
（T ）
49、友元函数是类的成员函数，所以可以存取或修改该类中的私有成员。
（ F）
（F ）
51、在语句const char *ptr中，
ptr是指向字符串的常量指针。 （ F）
52、多继承情况下，派生
类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生
类构造函数中所定义的成
员初始化列表的各项顺序无关。 （ T）
53、在说明语句
int a(15),&b=a,*p=&a;中，b的值的*P的是不相等的。（ F ）
54、已知：int a(5),b(10); 表达式++a+b++有二义性。（ F ）
55、在不同类型操作数组成的表达式中，其表达式的类型一定是最高类型double型。（F ）
56、break语句也可以用于if体内，它可退出if语句。（ F ）
57、在一个被调用函数中，一个return语句可返回多个值给调用函数。（ F ）
58、在传值调用中，要求实参和形参的类型完全一致并且个数相等。（ F ）
59、for循环中，循环变量的作用域是该循环的循环体内。（ F ）
60、所谓私有成
员是指只有类中所提供的成员函数才能直接访问它们，任何类以外的函数对它们的访问都
是非法的。（
F ）
61、const char *p说明了p是指向字符串的常量指针。（ F ）
62、私有继承中，基类中所有成员对派生类的对象都是不可见的。（ F ）
50、已知：类A中一个成员函数说明如下：void Set(A&a)；其中A
&a的含意是将a的地给变量Set。
四、指出函数或程序的功能。
1、 template
void AC(Type &x , Type &y )
{
Type
a=x;
x=y
y=a
}
1.交换x和y；
2、int AB(int *a , int n)
{
int x=a[0];
for (int i=1; i
}
2.返回数组a[n]中元素的最小值
3． int AB(int *a , int n){
int
x=a[0];
for (int i=1; i
}
3.返回数组a[n]中元素的最小值
4. float fact(int n)
{float t=1;
for(int i=1;i<=n;i++)
t*=i;
return t;
}
#include
void main( )
{ float t;
int n=10;
cout<
4.输出10的阶乘
五、写出程序运行结果（每小题3分,共15分）
1、#include
int
a[]={2,4,6,8,10};
int &index(int i)
{
return a[i];
}
void main()
{
int i;
index(3)=12;
for
(i=0;i<=4;i++)
cout<
结果 2
4 6 12 10
2、#include
void
f(int *m,int n)
{
int temp;
temp=*m;
*m=n;
n=temp;
}
void main()
{
int a=5,b=10;
f(&a，b);
cout<
10 10
3、#include
int
i=15;
void main()
{
int i;
i=100;
∷i=i+1;
cout<<∷i<
101
4、#include
class toy
{
public:
toy(int q,
int p)
{
quan = q;
price = p;
}
int get_quan()
{
return quan;
}
int get_price()
{
return
price;
}
private:
int quan,
price;
};
main()
{
toy
op[3][2]={
toy(10,20),toy(30,48),
toy(50,68),toy(70,80),
toy(90,16),toy(11,120),
};
int i;
for (i=0;i<3;i++)
{
cout<
cout<
cout<<
return 0;
}
10,20
30,48
50,68
70,80
90,16
11,120
5、#include
class example
{
public:
example(int n)
{
i=n;
cout<<
}
~example()
{
cout
<<
}
int get_i()
{
return i;
}
private:
int i;
};
int sqr_it(example o)
{
return _i()* _i();
}
main()
{
example x(10);
cout<<_i()<
}
Constructing
10
Destructing
100
10
Destructing
6、#include
class Test
{
private:
int x;
public:
Test()
{
cout<<“构造函数被执行”<
}
~Test()
{cout<<“析构函数被执行”<
void
main()
{
Test obj1,obj2;
();
();
}
构造函数被执行
构造函数被执行
x=0
x=0
析构函数被执行
析构函数被执行
7、#include
class A
{
public:
A(int *s) {cout<
class B:public A
{
public:
B(char *s1,char *s2):A(s1)
{
cout<
};
class C:public A
{
public:
C(char *s1,char *s2):A(s1)
{
cout<
};
class D:public B,C
{
public:
D(char *s1,char *s2,char
*s3,char *s4):B(s1,s2),C(s3,s4)
{
cout<
};
void
main()
{
D d (“class A”,”class
B”,”class C”,”class D”);
}
class A
class B
class C
class D
class D
8、#include
class Base
{
public:
virtual void disp()
{cout<<”base class”<
class
Derivel:public Base
{
public:
void disp() {cout<<”derivel class”<
class Derive2:public Base
{
public:
void disp() {cout<<”derive2
class”<
void main()
{
Base *p;
Base b;
Derive1 d1;
Derive2 d2;
p=&b;
p->disp();
p=&d1;
p->disp();
p=&d2;
p->disp();
}
base class
derivel class
derive2 class
9、#include
class Sample
{
private:
int x;
static int y;
public:
Sample(int a);
void print();
};
Sample:: Sample(int a)
{
x=a;
y ++;
}
void
Sample::print()
{
cout<<”x=”<
int
Sample::y=25;
void main()
{
Sample s1(5);
Sample s2(10);
();
();
}
x=5,y=27
x=10,y=27
10、#include
class Sample
{
private:
int x;
public:
Sample () { }
Sample(int a) {x=a;}
void disp()
{cout<<”x=”<
};
Sample operator+( Sample &s1, Sample &s2)
{
return Sample(s1.x+s2.x);}
void main()
{
Sample obj1(10);
Sample
obj2(20);
Sample obj3;
obj3=obj1+obj2;
();
}
x=30
11、#include
class Test
{
private:
int x;
public:
Test()
{
cout<<“构造函数被执行” <
}
void print()
{
cout<<“x=”<
};
void main()
{
Test obj1,obj2;
();
();
}
构造函数被执行
构造函数被执行
x=0
x=0
12、#include
class A
{
protected:
int x;
public:
A(int x)
{
A::x=x;
cout<<”class A”<
};
class B
{
private:
A a1;
public:
B(int x):a1(x)
{
cout<<”class B”<
};
class C:public B
{
private:
A a2;
public:
C(int x):B(x),a2(x)
{
cout<<”class C”<
};
class D:public C
{
public:
D(int x):C(x)
{
cout<<”class D”<
};
void main()
{
D dobj(10);
}
class A
class B
class A
class C
class D
13、#include
class Point
{
private:
int x;
int y;
public:
Point (int a,int b)
{
x=a;
y=b;
}
virtual int area() {return 0;}
};
class Rectangle:public Point
{
private:
int length;
int
width;
public:
Rectangle(int
a,int b,int l,int w): Point(a,b)
{
length=l;
width=w;
}
virtual int area() { return length*width;}
};
void disp(Point &p)
{
cout<<“面积是：”<<()<
void
main()
{
Rectangle rect(3,5,7,9);
Disp(rect);
}
面积是：63
14、#include
class Sample
{
private:
int x;
static int y;
public:
Sample(int a);
void print();
};
Sample:: Sample(int a)
{
x=a;
y=x++;
}
void
Sample::print()
{cout<<”x=”<
void main()
{
Sample s1(5);
Sample s2(10);
();
();
}
x=6,y=10
x=11,y=10
15、#include
class Sample
{
private:
int x;
public:
Sample(){}
Sample (int a)
{
x=a;
}
void disp() {cout<<”x=”<
};
Sample Sample:: operator+( Sample &s)
{
return Sample(x+s.x);
}
void main()
{
Sample obj1(20);
Sample obj2(20);
Sample obj3;
obj3=obj1+obj2;
();
}
x=40
16、# include
class A {
int a , b
public :
A( ) { a=b=0; }
A( int aa ,
int bb ) : a(aa),b(bb) {
cout
<<”a=”<
~A(
){cout <<”Destructor!”<
void
main() {
A x , y(2 , 3);
}
a=2,b=3
Destructor!
Destructor!
17、 # include
int AD(int a[] , int n) {
int
x=1;
for (int i=0; i
return x;
}
void main() {
int
a[]={ 2, 8, 6, 5};
cout <
480
18、#include
class R
{
public:
R(int r1,int r2)
{R1=r1;R2=r2;}
void print();
void print()
const;
private:
int R1,R2;
};
void
R::print()
{
cout<
}
void R::print() const
{
cout<
void main()
{
R
a(5,4);
();
const R b(20,52);
();
}
5:4
20;52
19、#include
class A
{
public:
virtual void act1();
void act2() {act1();}
};
void A::act1()
{
cout<<
}
class B : public A
{
public:
void
act1();
};
void B::act1()
{
cout<<
}
void main()
{
B b;
2();
}
# include
void fun(int，int，int * )；
void main()
{
int x，y，z；
fun (2，3，&x)；
fun (4，x，&y)；
fun (x，y，&z)；
cout<
void fun(int a，int b，int * c )
{
b*=a；*c=b-a；}
B::act1() called.
20、#include
void main()
{
}
hello third
21、#include
int a[8]={1,2,3,4,5,6,7};
void fun(int b[
],int n);
void main( )
{ int m=8;
fun(a,m);
cout<
{
}
28
22、#include
class AA
{
public:
AA(int i,int j)
{A=i;B=j;cout<<
{A=obj.A+1;B=obj.B+2;cout<<
{cout<<
AA(AA &obj)
~AA()
void print()
{cout<<
for (int I=0;I
int x=3,y=3;
switch(x%2)
{
case 1: switch (y)
}
{ case 0:cout<<
}
default: cout<<
case
1:cout<<
case 2:cout<<
private:
int A,B;
};
void main()
{
AA a1(2,3);
AA a2(a1);
}
Constructor
Copy_Constructor
A=3,B=5
Constructor
A=5,B=6
Destructor
Destructor
Destructor
23、#include
void main()
{
int i(0);
while(++i)
{
if(i= =10)
break;
if(i%3!=1) continue;
cout<
}
1
4
7
24、#include
int a[8]={1,2,3,4,5,6,7};
void fun(int *pa,int n);
void main( )
{ int m=8;
fun(a,m);
cout<
void fun(int
*pa,int n)
{
}
for (int I=0;I
();
AA
*pa=new AA(5,6);
pa->print();
delete
pa;
28
25、#include
void ff(int x),ff(double x);
void main()
{ float a(88.18);
ff(a);
char
b('a');
ff(b);
}
void ff(int x)
{
{
cout<<
cout<<
void ff(double
x)
ff(double): 88.18
ff(int): 97
26、#include
class AA
{
public:
AA(int i,int j)
{A=i;B=j;cout<<
{A=obj.A+1;B=obj.B+2;cout<<
{cout<<
AA(AA
&obj)
~AA()
void print()
{cout<<
private:
int A,B;
};
void main()
{ AA a1(2,3);
AA
a2(a1);
}
Constructor
Copy_Constructor
A=3,B=5
Constructor
A=5,B=6
Destructor
Destructor
Destructor
();
AA *pa=new AA(5,6);
pa->print();
delete pa;
27、#include
void
main()
{
int a,b,c,d(5);
c=2,c+=10;
a =b=10;
a * = 2;
b
= 2;
c % = 2;
cout<
20,5,0
28、#include
void
main()
{
char flag='c'
switch(flag)
{
case 'a' :cout<<
case
'b' :cout<<
case 'c' : cout <<
default :
cout <<
}
}
3
4
29、#include
void main()
{
}
1
30
30、#include
void Swap( int
&a, int & b);
void main()
{
}
int x( 10 ), y( 7 );
cout<<
Swap( x , y );
cout<<
4 4 18
static int b[][3] = { {1,2,3},{4},{5,6} };
b[0][2]=12,b[1][2]=18;
cout <<
b[0][2]+b[1][2]+b[2][2]<< endl;
cout <<
**b<<
void Swap(int & a, int & b)
{
int temp; temp = a a=b b=temp }
x=10
y=7
x=7 y=10
31、#include
class A
{
public:
};
A::A()
{
a=b=10;cout<<
A::A(int i,int j)
{
a=i,b=j;cout<<
void A::print()
{cout<<
void main()
{
}
Default constructor.
Constructor.
a=10,b=10
a=15,b=18
Donstructor.
Donstructor
32、 program 1_
#include
void main()
{
int a,b,sum;
a=43;
b=37;
sum=a+b;
cout<<
cout<
The sum is80
A m,n(15,18);
();
();
A();
A(int i,int j);
~A(){cout<<
void print();
int a,b;
private:
33、#include
class Sample
{
int n;
static
int sum;
public:
Sample(int x){n=x;}
void add(){sum+=n;}
void disp()
{
cout<<
}
};
int Sample::sum=0;
void main()
{
Sample a(2),b(3),c(5);
();
();
();
();
();
();
}
n=2,sum=2
n=3,sum=5
n=5,sum=10
34、#include
class Sample
{
int x;
public:
Sample(){};
Sample(int a){x=a;}
Sample(Sample &a){x=a.x++ +10;}
void
disp(){cout<<
};
void main()
{
Sample s1(2),s2(s1);
();
();
}
x=3
x=12
35、 #include
class A
{
public:
A(char *s) { cout << s << endl; }
~A() {}
};
class B:public A
{
public:
B(char *sl,char *s2) :A(sl)
{
cout
<< s2 << endl;
}
};
class C:public
A
{
public:
C(char *sl,char *s2)
:A(sl)
{
cout << s2 << endl;
}
};
class D:public B,public C
{
public:
D(char *sl,char *s2,char *s3,char
*s4) :B(sl,s2),C(sl,s3)
{
cout << s4 <<
endl;
}
void main ()
{
D
d(
}
class A
class B
class A
class C
class D
36、 program 1_
#include
void main()
{
cout<<
();
}
Let's learn to
write a C++ Program.
37、#include
void main()
{ int i,n;
n=0;
for(i=1;i<=5;i++)
n=n+i;
cout<<
n=15
38、#include
class Sample
{
int n;
public:
Sample(int i){n=i;}
friend int add(Sample
&s1,Sample &s2);
};
int add(Sample
&s1,Sample &s2)
{
return s1.n+s2.n;
}
void main()
{
Sample
s1(10),s2(20);
cout<
30
39、#include
class
Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int
b){x=a;y=b;}
~Sample()
{
if(x==y)
cout<<
else
cout<<
}
void
disp()
{
cout<<
}
};
void main()
{
Sample s1(2,3);
();
}
x=2,y=3
x!=y
六、分别指出下面的p各是什么。
1、int *p； 2、int
*p[3]；
3、int (*p)[3]； 4、int *p( )；
5、int **p；
1. 指向整型变量的指针；
2.
指向整型一维数组的指针；
3.
指向整型变量的一维指针数组，既：数组里存放的是指向整型变量的指针；
4.
指向一个函数返回值为整形的函数指针；
5.指向整形变量的二次指针.
七、指出下列程序的错误，并说明为什么：
1、#include
class Student{
int sno;
int age;
void printStu();
void setSno(int d);
};
void printStu()
{
cout<<
cout<<
}
void setSno(int s)
{
sno=s;
}
void setAge(int a)
{
age=a;
}
void main()
{
Student lin;
(20021);
(20);
tu();
}
1)void printStu() 应该改为 void
Student::printStu()
2)void setSno(int s) 应该改为
void Student::setSno(int s)
3)Student的定义中应加入成员函数的声明语句 void setAge(int a);
4)void setAge(int a) 应该改为 void
Student::setAge(int a)
5)应将成员函数定义为public类型
在前面加 public:
2、
#include
class Point{
public:
int x,y;
private:
Point(){x=1;y=2;}
};
void main()
{
Point cpoint;
cpoint.x=2;
}
2.应将成员x定义为public
3、#include
void main( )
{
int x=0,y=5,z=3;
while(z>0 && ++x<3) y=y-1;
cout<
4、#include
void main()
{
int x=10;
int &y=x;
cout<<
x++;
cout<<
y++;
cout<<
}
5、#include
void main( )
{ int i,n=0;
for(i=2;i<10;i++)
{ if(i%3!=0) continue;
n++;
}
cout<
6、#include
class A
{
int *a;
public:
A(int x)
{
a=new int(x);
cout<<
}
};
void
main()
{
A x(3),*p;
p=new A(5);
delete p;
}
7、# include
class base
{
public:
virtual int
func () { return 0; }};
class derived: public
base
{
public:int func() { return 100; }
};
void main()
{
derived d;
base& b = d;
cout << () << endl;
cout
<< ::func() << endl;
}
8、#include
#define pi=3.1416;
const
float r=3.2;
void main()
{
float
s1,s2,c1,c2,r1;
c1=pi*r*r;
s1=2*pi*r;
r=2.8;
c2=pi*r*r;
s2=2*pi*r;
cout
1）#define pi=3.1416;
应改为 #define pi 3.1416
2) 修改了const类型的变量r 应改为
static float r=3.2;
3）cout
1、
class A
{
int * a;
int n;
public :
A(int
nn=0):n(nn)
{
if (n==0) a=0;
else a=__
a=(int *)malloc(n*sizeof(int));
_
分配长度为n的动态数组
}
void Seta(int * aa)
{
for (int i=0; i
_____~A();___ 定义析构造函数，释放动态数组空间
};
2、程序输出结果为
a转换为A
b转换为B
请将程序补充完整
#include
class Sample
{
char c1,c2;
public:
Sample （1）
void disp()
{
cout<
};
void main()
{
（2）
();
();
}
2.
1）
(char c)
{
}
2）
Sample a('a'),b('b');
3、下列程序的输出结果为：The
result is :5，请将程序补充完整
#include
#include
void main()
{ float
a=3,b=4;
cout<< （3）
（4）
}
3.
3）
4）
cout<
请将程序补充完整
#include
class c {
（5）
int x;
c(int px=10)
{x=px;}
void setx (int a) {x=a;}
（6）
};
（7）
{ cp(11); c*q;q=&p;
int p::c*cptr; int(c::*fptr)();
(8);
cptr=&c::x;
fptr=c::getx;
cout<
4.
5)
c1=c;
if(c1>='a'&&c1<='z')
c2=c1+'A'-'a';
public:
6)
int getx() {return x; }
7)
void main ()
5、下面程序是输出100内能被3整除且个位数是6的所有整数，请将程序补充完整
#include
void main()
{
int i,j;
for (i=0; ___（1）__;i++)
{
j=i*10+6;
if (___（2）__)
continue;
___（3）__;
cout<
}
5.
1)
i<10
2)
j%3
3)
else
6、 程序输出结果为counstructing object:x=1
请将程序补充完整
#include
class
Sample
{
int x;
public:
Sample(int a)
{
___（4）__
cout<<
}
};
void func(int n)
{
___（5）__
}
void main()
{
func(1);
func(10);
}
6.
4)
x=a;
5)
static Sample obj(n);
7、程序输出结果为：
A=2,B=7
A=5,B=7
请把程序补充完整
#include
class
Sample
{
int A;
static int B;
public:
Sample(int a){A=a,B+=a;}
static void func(Sample s);
};
void
Sample::func(Sample s)
{
___（6）__
}
int Sample::B=0;
void main()
{
Sample s1(2),s2(5);
___（7）__
Sample::func(s2);
}
7.
6)
cout<<
7)
Sample ::func(s1);
九、编程题：
1. 编写一个函数，实现两个数的交换。
#include
void Swap(int *x,int *y)
{
int a;
a=*x;
*x=*y;
*y=a;
}
int main()
{
int b,c;
cin>>b>>c;
cout<
cout<
2. 编写一个函数，返回三个整数形参中的最小值。
#include
void maxmin(int
a,int b,int c,int* max,int* min)
{
*max=a>b(a>ca:c):(b>cb:c);
*min=a
void main()
{
int a,b,c,max,min;
cin>>a>>b>>c;
maxmin(a,b,c,&max,&min);
cout<<
}
3. 编写一个类LEI，实现打印私有变量a的值。
class LET
{
public:
} 4、下面的函数统计子字符串substr在字符串str中出现的次数，如果substr在str中不出
现，则返回值
0。请完成该函数。
int str_count(char
*substr, char *str)
{
}
#include
int str_count(char *substr, char
*str)
{
int sum,len;
char * p;
len = strlen(substr);
display()
{
cin>>x;
cout<
int x;
private:
if(len<1)
return -1;
for(sum=0,p=str;;)
{
p = strstr(p,substr);
if(p!=NULL)
{
sum++;
p+=len;
}
else
break;
}
return sum;
}
5、定义个datetime类，使其对象可以显示当前系统时间和日期 。
#include
#include
class datetime
{
public:
int
year;
int month;
int day;
int hour;
int min;
int sec;
datetime()
{
struct tm* ptm;
time_t m;
time(&m);
ptm = localtime(&m);
year =
ptm->tm_year+1900;
month =
ptm->tm_mon+1;
day = ptm->tm_mday;
hour = ptm->tm_hour;
min =
ptm->tm_min;
sec = ptm->tm_sec;
}
void output()
{
printf(
}
};
void main(void)
{
datetime d;
();
}
6、
设计一个汽车类Vehicle，包含数据成员车轮数和车重，由它派生出类Car和类Truck，前者包含载
客
数，后者包含载重量。编写程序实现。
#include
class vehicle 定义汽车类
{
protected:
int wheels; 车轮数
float weight; 重量
public:
vehicle(int wheels,float weight);
int get_wheels();
float get_weight();
float wheel_load();
void show();
};
class car:public vehicle 定义小车类
{
int passenger_load; 载人数
public:
car(int wheels,float weight,int passengers=4);
int get_passengers();
void show();
};
class truck:public vehicle 定义卡车类
{
int passenger_load; 载人数
float
payload; 载重量
public:
truck(int
wheels,float weight,int passengers=2,float
max_load=24000.00);
int get_passengers();
float efficiency();
void show();
};
vehicle::vehicle(int wheels,float weight)
{
vehicle::wheels=wheels;
vehicle::weight=weight;
}
int
vehicle::get_wheels()
{
return wheels;
}
float vehicle::get_weight()
{
return weightwheels;
}
void
vehicle::show()
{
cout << 车轮:个
cout
<< 重量:公斤
}
car::car(int wheels, float
weight,
int passengers) :vehicle (wheels,
weight)
{
passenger_load=passengers;
}
int car::get_passengers ()
{
return passenger_load;
}
void car::show()
{
cout
<<车型:小车
vehicle::show();
cout <<
载人:人
cout << endl;
}
truck::
truck(int wheels, float weight,int passengers,
float max_load):vehicle(wheels,weight)
{
passenger_load=passengers;
payload=max_load;
}
int
truck::get_passengers()
{
return
passenger_load;
}
float
truck::efficiency()
{
return
payload(payload+weight);
}
void
truck::show()
{
cout
<<车型:卡车
vehicle:: show ();
cout <<
载人:人
cout << 效率:
cout << endl;
}
void main ()
{
car car1(4,2000,5);
truck tru1(10,8000,3,340000);
cout <<
输出结果
car1. show ();
tru1. show ();
}
7、设计一个点类Point，包含点的坐标x,y
两个数据成员，采用友元类的方式分别计算两点间的水平距离
和垂直距离。
#include
using namespace std;
class Point;先声明类型Point
int
horizontalDistance(const Point& first, const
Point& second);水平距离函数声明
int
verticalDistance(const Point& first, const Point&
second);垂直距离函数声明
class Point
{
private:
int x;横坐标
int y;纵坐标
public:
Point(int x=0, int y = 0)构造函数
{
this->x = x;
this->y = y;
}
friend int horizontalDistance(const Point&
first, const Point& second);
friend int
verticalDistance(const Point& first, const Point&
second);
};
水平距离函数定义
int
horizontalDistance(const Point& first, const
Point& second)
{
if(first.x -second.x
>=0)
return first.x-second.x;
else
return second.x-first.x;
}
垂直距离函数定义
int verticalDistance(const Point& first,
const Point& second)
{
if(first.y
-second.y >=0)
return first.y-second.y;
else
return second.y-first.y;
}
int
main()
{
Point a(1,2); 定义三个Point对象
Point b(0,0);
Point c(-1,-1);
测试
cout<< horizontalDistance(a,b) <
}
8、设计一个点类Point，包含横、纵两个坐标数据x,y，由它派生出圆类Circle,并添加
一个半径数据r，
求其面积area。
#include
上，控制输出精度
using namespace std;
#define PI 3.1415926
点类如下：
class Point
{
public:
Point()
{}
Point(float x1,float y1)
{
x=x1;
y=y1;
}
virtual
float area()=0;
virtual float perim()=0;周长
private:
float x;
float y;
};
class Circle:public Point
{
public:
Circle(float x1,float y1,float r1);
float area();
float perim();
private:
float r;
}; 竞选演讲-预备党员介绍人发言
世界名车标志及名称-党员公开承诺事项
十大名表排行-怀念母亲读后感
视频会议租用-毕业自荐书