c++面向对象程序设计语言重点难点复习题及答案.doc

资料内容仅供您学习参考，如有不当或者侵权，请联系改正或者删除。
1、 数据共享与保护
一、 选择题:
1、 在下面存储类中, ( C ) 对象的可见性与生存期不一致。
A. 外部类 B. 自动类 C. 内部静态类 D. 寄存器类
2、 在下面存储类中, ( A ) 的对象不是局部变量。
A. 外部静态类 B. 自动类 C. 函数形参 D. 寄存器类
3、 关于局部变量, 下面说法正确的是( C )。
A. 定义该变量的程序文件中的函数都能够访问
B. 定义该变量的函数中的定义处以下的任何语句都能够访问
C. 定义该变量的复合语句中的定义处以下的任何语句都能够访问
D. 定义该变量的函数中的定义处以上的任何语句都能够访问
4、 一个类的静态数据成员所表示属性 ( C )。
A. 是类的或对象的属性 B. 只是对象的属性
C. 只是类的属性 D. 类和友元的属性
5、 类的静态成员的访问控制( D ) 。
A. 只允许被定义为private
B. 只允许被定义为private或protected
C. 只允许被定义为public
D. 可允许被定义为private、 protected或public
6、 静态成员函数对类的数据成员访问( B ) 。
A. 是不允许的 B. 只允许是静态数据成员
C. 只允许是非静态数据成员 D. 可允许是静态数据成员或非静态数据成员
7、 被非静态成员函数访问的类的数据成员( A )。
A. 能够是非静态数据成员或静态数据成员 B. 不可能是类的静态数据成员
C. 只能是类的非静态数据成员 D. 只能是类的静态数据成员
8、 静态数据成员的初始化是在( D ) 中进行的。
A. 构造函数 B. 任何成员函数
C. 所属类 D. 全局区
9、 当将一个类A或函数f()说明为另一个类B的友元后, 类A或函数f()能够直接访问类B的( D ) 。
A. 只能是公有成员 B. 只能是保护成员
C. 只能是除私有成员之外的任何成员 D. 具有任何权限的成员
10、 引入友元的主要目的是为了( C ) 。
A. 增强数据安全性 B. 提高程序的可靠性
C. 提高程序的效率和灵活性 D. 保证类的封装性
11、 一个类的成员函数也能够成为另一个类的友元函数, 这时的友元说明( A ) 。
A. 需加上类域的限定 B. 不需加上类域的限定
C. 类域的限定可加可不加 D. 不需要任何限定
二、 判断题
1、 类的静态数据成员需要在定义每个类的对象时进行初始化。F
2、 当将一个类S定义为另一个类A的友元类时, 类S的所有成员函数都能够直接访问类A的所有成员。T
3、 静态数据成员必须在类外定义和初始化。T
4、 静态成员函数能够引用属于该类的任何函数成员F。
5、 友元函数是在类声明中由关键字friend修饰说明的类的成员函数。F
6、 友元函数访问对象中的成员能够不经过对象名F
三、 填空题:
1、 若”double x=100;”是文件F1.CPP中的一个全局变量定义语句, 若文件F2.CPP中的某个函数需要访问此x , 则应在文件F2.CPP中添加对x的声明语句为Extern double x;
2、 如果一个函数定义中使用了static修饰, 则该函数不允许被其它文件中的函数调用。
3、 定义外部变量时, 不用存储类说明符Extern, 而声明外部变量时用它。
4、 调用系统函数时, 要先使用#include命令包含该系统函数的原型语句所在的头文件。
5、 C++程序运行时的内存空间能够分成全局数据区, 堆区, 栈区和代码区。
6、 局部变量具有局部生存期, 存放在内存的栈区中。
7、 对类中对象成员的初始化是经过在构造函数中给出的初始化表来实现的。
8、 对类中常量成员的初始化是经过在构造函数中给出的初始化表来实现的。
9、 对类中引用成员的初始化只能经过在构造函数中给出的初始化表来实现。
10、 对类中一般数据成员的初始化既能够经过在构造函数中给出的初始化表来实现, 也能够经过构造函数中的函数体来实现。
11、 假定要把aa定义为AB类中的一个常量整数型数据成员, 则定义语句const int aa。
12、 假定要把aa定义为AB类中的一个引用整数型数据成员, 则定义语句为int &aa。
13、 假定AB类中只包含一个整型数据成员a, 而且它是一个常量成员, 若利用参数aa对其进行初始化, 则该类的构造函数的定义为AB (int aa){a=aa; }。
14、 假定AB类中只包含一个整型数据成员a, 而且它是一个引用成员, 若利用引用参数aa对其进行初始化, 则该类的构造函数的定义为AB(int &aa){a=aa; }。
15、 静态成员函数能够直接访问类的静态数据成员, 只能经过对象名访问类的非静态数据成员。
16、 静态数据成员必须在所有函数的定义体外进行初始化。
17、 一个类的成员函数也能够成为另一个类的友元函数, 这时的友元说明必须在函数名前加上类域的限定。
四、 修改程序题:
下列程序段中, A_class的成员函数Variance()可求出两数的平方差, 请改写该程序段, 把Variance()函数从A_class类中分离出来, 用友元函数来实现该函数的功能。
class A_class {
private:
int x,y,t;
public:
A_class(int i,int j):x(i),y(j) {
if(y>x){t=x;x=y;y=t;}
}
int Variance(){return x*x-y*y;}
//其它函数从略
};
void main() {
A_class A_obj(3,5);
cout<<"Result:"<<A_obj.Variance()<<endl;}
修改后的源程序:
class A_class {
private:
int x,y,t;
public:
A_class(int i,int j):x(i),y(j) {
if(y>x){t=x;x=y;y=t;}
}
friend int Variance();
//其它函数从略
};
int variance (){
return x*x-y*y;
}
void main() {
A_class A_obj(3,5);
cout<<"Result:"<<A_obj.Variance()<<endl;

2、 数组、 指针与字符串
一、
1、 在下面的一维数组定义中, 哪一个有语法错误。( C )
A. int a[]={1,2,3}; B. int a[10]={0};
C. int a[]; D. int a[5];
2、 在下面的字符数组定义中, 哪一个有语法错误。( D ) 。
A. char a[20]=”abcdefg”; B. char a[]=”x+y=55.”;
C. char a[15]; D. char a[10]=’5’;
3、 在下面的二维数组定义中, 正确的是( C )。
A. int a[5][]; B. int a[][5];
C. int a[][3]={{1,3,5},{2}}; D. int a[](10);
4、 假定一个二维数组的定义语句为”int a[3][4]={{3,4},{2,8,6}};”, 则元素a[1][2]的值为( C ) 。
A. 2 B. 4 C. 6 D. 8
5、 假定一个二维数组的定义语句为”int a[3][4]={{3,4},{2,8,6}};”, 则元素a[2][1]的值为( A ) 。
A. 0 B. 4 C. 8 D. 6
6、 若定义了函数 double *function(), 则函数function的返回值为( B ) 。
A. 实数型 B.实数的地址 C.指向函数的指针 D.函数的地址
7、 以下函数的返回结果是( A ) 。
int function(char *x) {
char *p=x; while(*p++); return(p-x-1);
}
A. 求字符串的长度 B.将字符串x连接到字符串p后面
C. 将字符串x复制到字符串p中 D.将字符串x反向存放
8、 设有如下函数定义
int f(char *s) {
char *p=s;
while(*p!=’\0’) p++;
return(p-s);
}
在主函数中用cout<<f(”good”)调用上述函数, 则输出结果为( B ) 。
A. 3 B. 4 C. 5 D. 6
9、 假定变量m定义为”int m=7;”, 则定义变量p的正确语句为( B ) 。
A. int p=&m; B. int *p=&m; C. int &p=*m; D. int *p=m;
10、 变量s的定义为”char *s=”Hello world!”;”, 要使变量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、 假定一条定义语句为”int a[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、 假定有定义”int b[10]; int *pb;”, 则不正确的赋值语句为( D ) 。
A. pb=b; B. pb=&b[0]; C. *pb=new int; D. pb=b[5];
14、 假定p是具有double类型的指针变量, 则表示式++p使p的值( 以字节为单位) 增加( C ) 。
A. 1 B. 4 C. sizeof(double) D. sizeof(p)
15、 假定p指向的字符串为”string”, 则cout<<p+3的输出结果为( C ) 。
A. string B. ring C. ing D. i
16、 假定p指向的字符串为”string”, 若要输出这个字符串的地址值, 则使用( D ) 。
A. cout<<*s; B. cout<<s; C. cout<<&s; D. cout<<(void *)s;
17、 定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为( A ) 。
A. int *p=new int[30]; B. int *p=new int(30);
C. int *p=new [30]; D. *p=new int[30];
18、 假定p是具有int**类型的指针变量, 则给p赋值的正确语句为( B ) 。
A. p=new int; B. p=new int*; C. p=new int**; D. p=new int[10];
19、 要使语句”p=new int[10][20];”能够正常执行, p应被事先定义为( D ) 。
A. int *p; B. int **p; C. int *p[20]; D. int(*p)[20];
20、 假定变量a和pa定义为”double a[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定义为”int b[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=new int(100);”, 要释放p所指向的动态内存, 应使用语句( A ) 。
A. delete p; B. delete *p; C. delete &p; D. delete []p;
23、 假定指针变量p定义为”int *p=new int[30];”, 要释放p所指向的动态内存, 应使用语句( D ) 。
A. delete p; B. delete *p; C. delete &p; D. delete []p;
24、 当类中一个字符指针成员指向具有n个字节的存储空间时, 它所能存储字符串的最大长度为( C )。
A. n B. n+1 C. n-1 D. n-2

25、 在一个用链表实现的队列类中, 假定每个结点包含的值域用elem表示, 包含的指针域用next表示, 链队的队首指针用elemHead表示, 队尾指针用elemTail表示, 若链队非空, 则进行插入时必须把新结点的地址赋给( D )。
A. elemHead B. elemTail
C. elemHead->next和elemHead D. elemTail->next和elemTail
26、 在一个用链表实现的队列类中, 假定每个结点包含的值域用elem表示, 包含的指针域用next表示, 链队的队首指针用elemHead表示, 队尾指针用elemTail表示, 若链队为空, 则进行插入时必须把新结点的地址赋给( C )。
A. elemHead B. elemTail
C. elemHead和elemTail D. elemHead或elemTail
27、 当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时, 它最多能够存储( A )个整数。
A. n B. n+1 C. n-1 D. 1
28、 假定AB为一个类, 则执行 ”AB *px=new AB[n];”语句时将( A )。
A. 动态分配一个数组 B. 动态分配一个对象
C. 静态分配一个数组 D. 静态分配一个对象
29、 设px是指向一个类对象的指针变量, 则执行 ”delete px;”语句时, 将自动调用该类的( C )。
A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 拷贝构造函数
30、 当一个类对象离开它的作用域时, 系统自动调用该类的( D )。
A. 无参构造函数 B. 带参构造函数 C. 拷贝构造函数 D. 析构函数
31、 假定一个类对象数组为A[n], 当离开它定义的作用域时, 系统自动调用该类析构函数的次数为( C )。
A. 0 B. 1 C. n D. n-1
32、 假定AB为一个类, 则执行 ”AB a[10];”语句时调用该类无参构造函数的次数为( D )。
A. 0 B. 1 C. 9 D. 10
33、 假定AB为一个类, 则执行 ”AB *px=new AB[n];”语句时调用该类无参构造函数的次数为( A )。
A. n B. n-1 C. 1 D. 0
34、 假定AB为一个类, 则执行 ”AB a, b(3), *p;”语句时共调用该类构造函数的次数为( A )。
A. 2 B. 3 C. 4 D. 5
35、 假定AB为一个类, 则执行 ”AB a(2), b[3], *p[4];”语句时共调用该类构造函数的次数为( B )。
A. 3 B. 4 C. 5 D. 9
36、 假定AB为一个类, 则执行”AB a, b(2), c[3], *p=&a;”语句时共调用该类无参构造函数的次数为( D )
A. 5 B. 6 C. 3 D. 4
37、 假定AB为一个类, 则执行”AB *p=new AB(1,2);”语句时共调用该类构造函数的次数为( B )。
A. 0 B. 1 C. 2 D. 3
38、 假定AB为一个类, px为指向该类的一个含有n个对象的动态数组的指针, 则执行”delete []px;”语句时共调用该类析构函数的次数为( C )。
A. 0 B. 1 C. n D. 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 *p=new 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<<p;”的输出是”Hello!”, 则语句”cout<<*p;”输出的是__H________。
42、 . 已知语句”cout<<s;”的输出是”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 x, a[]={6,10,12}, *pa=a;”, 在执行”x=*++pa;”语句后, *pa的值是_10_______。
49、 已知有定义”int x, a[]={15,17,19}, *pa=a;”, 在执行”x=*pa++;”后, *pa的值是__17______。
50、 若采用p->abc(y)表示式调用一个成员函数, 在成员函数中使用的__this_就代表了类外的p指针。 
51、 在一个用数组实现的队列类中, 包含有两个数据成员, 一个指明队首元素位置, 另一个指明___队列长度_________。
52、 在一个用数组实现的队列类中, 包含有两个数据成员, 一个指明队列长度, 另一个指明___队首_______元素的位置。
53、 在一个用数组实现的队列类中, 假定数组长度为MS, 队首元素位置为first, 队列长度为length, 则插入一个新元素的位置为___(first+length)MS_______。
54、 在一个用数组实现的队列类中, 假定数组长度为MS, 队首元素位置为first, 队列长度为length, 则删除一个元素后队首的位置为__( first+1) MS ________。
55、 定义类动态对象数组时, 其元素只能靠自动调用该类的__无参构造函数__________来进行初始化。
56、 为了释放类对象中指针成员所指向的动态存储空间, 则需要为该类定义____析构函数________。
57、 假定 AB为一个类, 则执行”AB a[10];”语句时, 系统自动调用该类构造函数的次数为__10______。
58、 假定一个类对象数组为A[N], 当离开它的作用域时, 系统自动调用该类析构函数的次数为_N_______。
60、 假定指针p指向一个动态分配的类对象, 则当执行”delete p;”语句时, 在释放p所指向的动态存储空间之前将自动调用该类的___析构函数_________。
61、 假定AB为一个类, 该类中含有一个指向动态数组空间的指针成员pa, 则在该类的析构函数中应该包含有一条__delete[]pa;____________语句。

三、 程序填空题:
1、 采用指针访问方式从键盘给数组a[N]输入数据, 然后对元素值重新按逆序存放并输出。
#include <iostream.h>
const int N=8;
void main()
{
int a[N],*p,*q;
for(p=a; p<a+N; p++) cin>>*p;
p=a;q=a+N-1;
while(p<q) {
int r=*p; *p=*q; *q=r;
p++; q++;
}
for(p=a;p<a+N; p++)
cout<<*p<<' ';
cout<<endl;
}

1、 (1) cin>>*p (2) p++ (或++p) (3) q-- (或--q)
2、 假定有定义为”struct NODE{int data; NODE* next;};”, 下面算法根据table数组中的n个元素建立一个表头指针为L的链表, 链表中结点值的顺序与数组元素值的顺序正好相反。
void f6(NODE*& L, int table[], int n)
{
L=NULL;
if(n<=0) return;
int i=0;
NODE* p;
while(__ (1)___) {
p=new NODE;
p->data=__ _(2)___;
p->next=L;
___(3)___;
i++;
}
}

2、 (1) i<n (2) table[i] (3) L=p

3、 已知一维数组类ARRAY的定义如下, 构造函数的作用是把参数n的值赋给s, 给v动态分配长度为n的数组空间, 接着利用数组参数a初始化v所指向的数组。
class ARRAY{
int *v; //指向存放数组数据的空间
int s; //数组大小
public:
ARRAY(int a[], int n);
~ ARRAY(){delete []v;}
int size(){ return s;}
int& operator[](int n);
};
___(1)___ ARRAY(int a[], int n)
{
if(n<=0) {v=NULL;s=0;return;}
s=n;
v=__ (2)___;
for(int i=0; i<n; i++) _ _(3)___;
}

3、 (1) ARRAY:: (2) new int[n] (3) v[i]=a[i]

4、 下面是一维数组类ARRAY的定义, ARRAY与普通一维数组区别是: (a)用()而不是[]进行下标访问, (2)下标从1而不是从0开始, (c)要对下标是否越界进行检查。
class {
int *v; //指向存放数组数据的空间
int s; //数组大小
public:
ARRAY(int a[], int n);
~ ARRAY(){delete []v;}
int size(){ return s;}
int& operator()(int n);
}; ___(1)___ operator()(int n)
{ // ()的运算符函数定义
if(___(2)___) {cerr<<"下标越界! "; exit(1);}
return ___(3)___;
}

4、 (1) int& ARRAY:: (2) n<1 || n>s (3) v[n-1] (或*(v+n-1))
5、 已知一个类的定义如下:
#include<iostream.h>
class AA {
int a[10];
int n;
public:
void SetA(int aa[], int nn); //用数组aa初始化数据成员a,
//用nn初始化数据成员n
int MaxA(); //从数组a中前n个元素中查找最大值
void SortA(); //采用选择排序的方法对数组a中前n个元素
//进行从小到大排序
void InsertA();//采用插入排序的方法对数组a中前n个元素进行从小到大排序
void PrintA(); //依次输出数组a中的前n个元素
};

该类中MaxA()函数的实现如下, 请在标号位置补充适当的内容。
int _ __(1)_____
{
int x=a[0];
for(int i=1; i<n; i++)
if(a[i]>x) _ _(2)___;
___(3) ___;
}

5、 (1) AA::MaxA() (2) x=a[i] (3) return x

6、 已知一个类的定义如下:
#include<iostream.h>
class AA {
int a[10];
int n;
public:
void SetA(int aa[], int nn); //用数组aa初始化数据成员a,