c面向对象程序设计语言重点难点复习题模拟自测题及答案Word文档格式.docx
《c面向对象程序设计语言重点难点复习题模拟自测题及答案Word文档格式.docx》由会员分享，可在线阅读，更多相关《c面向对象程序设计语言重点难点复习题模拟自测题及答案Word文档格式.docx（168页珍藏版）》请在冰点文库上搜索。
C.提高程序的效率和灵活性D.保证类的封装性
11、一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（A）。
A.需加上类域的限定B.不需加上类域的限定
C.类域的限定可加可不加D.不需要任何限定
二、判断题
1、类的静态数据成员需要在定义每个类的对象时进行初始化。
F
2、当将一个类S定义为另一个类A的友元类时，类S的所有成员函数都可以直接访问类A的所有成员。
T
3、静态数据成员必须在类外定义和初始化。
4、静态成员函数可以引用属于该类的任何函数成员F。
5、友元函数是在类声明中由关键字friend修饰说明的类的成员函数。
6、友元函数访问对象中的成员可以不通过对象名F
三、填空题：
1、若“double
x=100;
”是文件F1.CPP中的一个全局变量定义语句，若文件F2.CPP中的某个函数需要访问此x
则应在文件F2.CPP中添加对x的声明语句为Externdoublex;
2、如果一个函数定义中使用了static修饰，则该函数不允许被其它文件中的函数调用。
3、定义外部变量时，不用存储类说明符Extern，而声明外部变量时用它。
4、调用系统函数时，要先使用#include命令包含该系统函数的原型语句所在的头文件。
5、C++程序运行时的内存空间可以分成全局数据区，堆区，栈区和代码区。
6、局部变量具有局部生存期，存放在内存的栈区中。
7、对类中对象成员的初始化是通过在构造函数中给出的初始化表来实现的。
8、对类中常量成员的初始化是通过在构造函数中给出的初始化表来实现的。
9、对类中引用成员的初始化只能通过在构造函数中给出的初始化表来实现。
10、对类中一般数据成员的初始化既可以通过在构造函数中给出的初始化表来实现，也可以通过构造函数中的函数体来实现。
11、假定要把aa定义为AB类中的一个常量整数型数据成员，则定义语句constintaa。
12、假定要把aa定义为AB类中的一个引用整数型数据成员，则定义语句为int&
aa。
13、假定AB类中只包含一个整型数据成员a，并且它是一个常量成员，若利用参数aa对其进行初始化，则该类的构造函数的定义为AB（intaa）{a=aa；
}。
14、假定AB类中只包含一个整型数据成员a，并且它是一个引用成员，若利用引用参数aa对其进行初始化，则该类的构造函数的定义为AB（int&
aa）{a=aa；
15、静态成员函数能够直接访问类的静态数据成员，只能通过对象名访问类的非静态数据成员。
16、静态数据成员必须在所有函数的定义体外进行初始化。
17、一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明必须在函数名前加上类域的限定。
四、修改程序题：
下列程序段中，A_class的成员函数Variance（）可求出两数的平方差，请改写该程序段，把Variance（）函数从A_class类中分离出来，用友元函数来实现该函数的功能。
classA_class{
private:
intx,y,t;
public:
A_class（inti,intj）:
x（i）,y（j）{
if（y>
x）{t=x;
x=y;
y=t;
}
}
intVariance（）{returnx*x-y*y;
}
//其它函数从略
};
voidmain（）{
A_classA_obj（3,5）;
cout<
<
"
Result:
A_obj.Variance（）<
endl;
修改后的源程序：
friendintVariance（）;
intvariance（）{
returnx*x-y*y;
2、数组、指针与字符串
1、在下面的一维数组定义中，哪一个有语法错误。
（C）
A.inta[]={1,2,3};
B.inta[10]={0};
C.inta[];
D.inta[5];
2、在下面的字符数组定义中，哪一个有语法错误。
（D）。
A.chara[20]=”abcdefg”;
B.chara[]=”x+y=55.”;
C.chara[15];
D.chara[10]=’5’;
3、在下面的二维数组定义中，正确的是（C）。
A.inta[5][];
B.inta[][5];
C.inta[][3]={{1,3,5},{2}};
D.inta[]（10）;
4、假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8,6}};
”，则元素a[1][2]的值为（C）。
A.2B.4C.6D.8
5、假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8,6}};
”，则元素a[2][1]的值为（A）。
A.0B.4C.8D.6
6、若定义了函数double*function（）,则函数function的返回值为（B）。
A.实数型B.实数的地址C.指向函数的指针D.函数的地址
7、以下函数的返回结果是（A）。
intfunction（char*x）{
char*p=x;
while（*p++）;
return（p-x-1）;
A.求字符串的长度B.将字符串x连接到字符串p后面
C.将字符串x复制到字符串p中D.将字符串x反向存放
8、设有如下函数定义
intf（char*s）{
char*p=s;
while（*p!
=’\0’）p++;
return（p-s）;
在主函数中用cout<
f（“good”）调用上述函数,则输出结果为（B）。
A.3B.4C.5D.6
9、假定变量m定义为“intm=7;
”，则定义变量p的正确语句为（B）。
A.intp=&
m;
B.int*p=&
C.int&
p=*m;
D.int*p=m;
10、变量s的定义为“char*s=”Helloworld!
”;
”，要使变量p指向s所指向的同一个字符串，则应选取（A）。
A.char*p=s;
B.char*p=&
s;
C.char*p;
p=*s;
D.char*p;
p=&
s
11、关于void指针，下列说法正确的是（C）。
A.void指针就是未指向任何数据的指针
B.void指针就是已定义而未初始化的指针
C.指向任何类型数据的指针可直接赋值给一个void指针
D.void指针值可直接赋给一个非void指针
12、假定一条定义语句为“inta[10],x,*pa=a;
”，若要把数组a中下标为3的元素值赋给x，则不正确的语句为（D）。
A.x=pa[3];
B.x=*（a+3）;
C.x=a[3];
D.x=*pa+3;
13、假定有定义“intb[10];
int*pb;
”，则不正确的赋值语句为（D）。
A.pb=b;
B.pb=&
b[0];
C.*pb=newint;
D.pb=b[5];
14、假定p是具有double类型的指针变量，则表达式++p使p的值（以字节为单位）增加（C）。
A.1B.4C.sizeof（double）D.sizeof（p）
15、假定p指向的字符串为”string”，则cout<
p+3的输出结果为（C）。
A.stringB.ringC.ingD.i
16、假定p指向的字符串为”string”，若要输出这个字符串的地址值，则使用（D）。
A.cout<
*s;
B.cout<
C.cout<
&
D.cout<
（void*）s;
17、定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为（A）。
A.int*p=newint[30];
B.int*p=newint（30）;
C.int*p=new[30];
D.*p=newint[30];
18、假定p是具有int**类型的指针变量，则给p赋值的正确语句为（B）。
A.p=newint;
B.p=newint*;
C.p=newint**;
D.p=newint[10];
19、要使语句“p=newint[10][20];
”能够正常执行，p应被事先定义为（D）。
A.int*p;
B.int**p;
C.int*p[20];
D.int（*p）[20];
20、假定变量a和pa定义为“doublea[10],*pa=a;
”，要将12.35赋值给a中的下标为5的元素，不正确的语句是（D）。
A.pa[5]=12.35;
B.a[5]=12.35;
C.*（pa+5）=12.35;
D.*（a[0]+5）=12.35;
21、假定变量b和pb定义为“intb[10],*pb=b;
”，要将24赋值给b[1]元素中，不正确的语句是（C）。
A.*（pb+1）=24;
B.*（b+1）=24;
C.*++b=24;
D.*++pb=24;
22、假定指针变量p定义为“int*p=newint（100）;
”，要释放p所指向的动态内存，应使用语句（A）。
A.deletep;
B.delete*p;
C.delete&
p;
D.delete[]p;
23、假定指针变量p定义为“int*p=newint[30];
”，要释放p所指向的动态内存，应使用语句（D）。
24、当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为（C）。
A.nB.n+1C.n-1D.n-2
25、在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队非空，则进行插入时必须把新结点的地址赋给（D）。
A.elemHeadB.elemTail
C.elemHead->
next和elemHeadD.elemTail->
next和elemTail
26、在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队为空，则进行插入时必须把新结点的地址赋给（C）。
C.elemHead和elemTailD.elemHead或elemTail
27、当类中的一个整型指针成员指向一块具有n*sizeof（int）大小的存储空间时，它最多能够存储（A）个整数。
A.nB.n+1C.n-1D.1
28、假定AB为一个类，则执行“AB*px=newAB[n];
”语句时将（A）。
A.动态分配一个数组B.动态分配一个对象
C.静态分配一个数组D.静态分配一个对象
29、设px是指向一个类对象的指针变量，则执行“deletepx;
”语句时，将自动调用该类的（C）。
A.无参构造函数B.带参构造函数C.析构函数D.拷贝构造函数
30、当一个类对象离开它的作用域时，系统自动调用该类的（D）。
A.无参构造函数B.带参构造函数C.拷贝构造函数D.析构函数
31、假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为（C）。
A.0B.1C.nD.n-1
32、假定AB为一个类，则执行“ABa[10];
”语句时调用该类无参构造函数的次数为（D）。
A.0B.1C.9D.10
33、假定AB为一个类，则执行“AB*px=newAB[n];
”语句时调用该类无参构造函数的次数为（A）。
A.nB.n-1C.1D.0
34、假定AB为一个类，则执行“ABa,b（3）,*p;
”语句时共调用该类构造函数的次数为（A）。
A.2B.3C.4D.5
35、假定AB为一个类，则执行“ABa
（2）,b[3],*p[4];
”语句时共调用该类构造函数的次数为（B）。
A.3B.4C.5D.9
36、假定AB为一个类，则执行“ABa,b
（2）,c[3],*p=&
a;
”语句时共调用该类无参构造函数的次数为（D）
A.5B.6C.3D.4
37、假定AB为一个类，则执行“AB*p=newAB（1,2）;
”语句时共调用该类构造函数的次数为（B）。
A.0B.1C.2D.3
38、假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete[]px;
”语句时共调用该类析构函数的次数为（C）。
A.0B.1C.nD.n+1
二、填空题：
1、用于存储一个长度为n的字符串的字符数组的长度至少为_n+1_______。
2、若a是一个字符数组，则从键盘上向该数组输入一个字符串的表达式为_getline（cin,a）;
_________。
3、若a是一个字符数组，则向屏幕输出a中所存字符串的表达式为_cout<
a_______。
4、一个二维字符数组a[10][20]能够存储__10______个字符串，每个字符串的长度至多为__19______。
5、对一个二维字符数组a进行初始化的数据为{”123”,”456”,”789”}，则a[1]元素对应的字符串为__”456”________。
6、strlen（”apple”）的值为__5______，strcmp（”a”,”A”）的值为_1_______。
7、假定对数组a[]进行初始化的数据为{2,7,9,6,5,7,10}，则a[2]和a[5]分别被初始化为__9______和___7_____。
8、假定对二维数组a[3][4]进行初始化的数据为{{3,5,6},{2,8},{7}}，则a[1][1]和a[2][3]分别被初始化为___8____和___0_____。
9、若二维数组a有m列，设a[0][0]位于数组的第一个位置上，则计算任一元素a[i][j]在数组中位置序号的公式为_i*m+j+1__________。
10、
若有定义“double
a[3][5];
”，则a
数组中行下标和列下标的最大值分别为___2_____和___4_____。
11、一个指针类型的对象占用内存的___4_____个字节的存储空间。
12、
一个指针指向一个数据对象，它保存着该数据对象的_地址_______，若数据对象为DataType类型，则相应的指针类型为___Datatype*_______。
13、
若要把一个整型指针p转换为字符指针，则采用的强制转换表达式为_（char*）p_______。
14、假定一个数据对象为int*类型，则指向该对象的指针类型为_int**______。
15、假定p是一个指向整数对象的指针，则用__*P______表示该整数对象，用_____P___表示指针变量p的地址。
16、
假定p是一个指针，则*p++运算首先访问__*p____，然后使p_的值增1。
17、假定p是一个指针，则（*p）++运算首先访问_*p__，然后使__*p______的值增1。
18、
假定p所指对象的值为25，p+1所指对象的值为42，则*p++的值为__25______。
19、假定p所指对象的值为25，p+1所指对象的值为42，则*++p的值为_42_______。
20、假定p所指对象的值为25，p+1所指对象的值为42，则执行（*p）++运算后，p所指对象的值为___26_____。
21、假定p所指对象的值为25，p+1所指对象的值为42，则执行*（p++）或*p++运算后，p所指对象的值为___42_____。
22、假定a是一个一维指针数组，则a+i所指对象的地址比a大__4*i______字节。
23、
假定a是一个一维数组，则a[i]的指针访问方式为__*（a+i）______。
24、假定a是一个一维数组，则a[i]对应的存储地址（以字节为单位）为__a+i*sizeof（a[i]）__________。
25、
一个数组的数组名实际上是指向该数组____首____元素的指针，并且在任何时候都不允许____修改____它。
26、假定指向一维数组b[10]中元素b[4]的指针为p，则p+3所指向的元素为__b[7]_____，p-2所指向的元素为_b[2]_______。
27、若要定义整型指针p并初始指向x，则所使用的定义语句为_int*p=&
x_______。
28、
若p指向x，则___*p_____与x的表示是等价的。
29、在一个二维数组int
a[m][n]中，包含的一维元素a[i]的类型为__int[n]______，访问a[i]时返回值的类型为__int*______。
30、假定一个二维数组为c[5][8]，则c[3]的值为二维元素c[3][0]________的地址，c[3]+2的值为二维元素_c[3][2]_______的地址。
31、假定p为指向二维数组int
d[4][6]的指针，则p的类型为_int（*）[6]______。
32、假定a是一个二维数组，则a[i][j]的指针访问方式为__*（*（a+i）+j）__________。
33、执行int
p=new
int操作得到的一个动态分配的整型对象为__*p______。
34、执行int
*p=new
int[10]操作，使p指向动态分配的数组中下标为0的元素，该元素可表示为_*p______或__p[0]______。
35、
执行char
char（’a’）操作后，p所指向的数据对象的值为__a______。
36、
执行new
char[m][n]操作时的返回值的类型为__char（*）[n]______。
37、执行_delete_p______操作将释放由p所指向的动态分配的数据空间。
38、执行_delete[]p_______操作将释放由p所指向的动态分配的数组空间。
39、
NULL是一个符号常量，通常作为空指针值，它的具体值为___0_____。
40、变量v定义为“double
v=23.4;
”，要使指针pv指向v，则定义pv的语句为___double*pv=&
v___________。
41、
已知语句“cout<
”的输出是“Hello!
”，则语句“cout<
*p;
”输出的是__H________。
42、.
”的输出是“apple”，则执行语句“cout<
s+2;
”的输出结果为__ple________。
43、
指针变量pv和pc定义为“void
*pv
=”Hello,
word!
char
*pc;
”，要将pv值赋给pc，则正确的赋值语句是_strcpy（pc，pv）；
pc=char（*）pv______________。
44、
数组b定义为“int
b[20][100];
”，要使p[j][k]
与b[j][k]
等效，则指针p应定义为__int（*p）[100]=b______________。
45、
与结构成员访问表达式p->
name等价的表达式是__（*p）.name__________。
46、
与结构成员访问表达式（*fp）.score等价的表达式是__fp->
score__________。
47、已知有定义“int
x,
a[]={5,7,9},
*pa=a;
”，在执行“x=++*pa;
”语句后，x的值是____6____。
48、已知有定义“int
a[]={6,10,12},
”，在执行“
升级会员 