眯式虱窗村袜那瞧眠瘫握茫嚏
第1章 面向对象程序设计（4周） 第1章测验1（类和对象）
1、 为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（ ）。
答案: public
2、 下列程序中说明的公有成员是( ).class Location{
int X;
public:
void init(int,init X,int init Y);
private:
int Y;
public:
int GetX();
int GetY();
};
答案: init(int init X,int init Y),GetX(),GetY()都是
3、 下列关于成员函数的描述中，错误的是（ ）。
答案: 成员函数的定义必须在类体外
4、 下列关于创建一个int型变量的引用，正确的是（ ）。
答案: int a(3),&ra=a;
5、 p是指向类A数据成员x的指针，a是类A的一个对象。在给x成员赋值为5的下列表达式中，正确的是（ ）。
答案: a.*p=5
6、 下列关于对象的描述中，错误的是（ ）。
答案: 对象就是C语言中的结构变量
7、 下列关于对象的描述中，错误的是（ ）。
答案: 一个类所能创建对象的个数是有限制的
8、 下列关于类的描述中，错误的是（ ）。
答案: 类就是C语言中的结构类型
9、 下列关于类的权限的描述错误的是（ ）
答案: 类本身的成员函数只能访问自身的私有成员
10、 下列关于类和对象的叙述中，错误的是（ ）。
答案: 一个类只能有一个对象
11、 下列关于面向对象概念的描述中，错误的是（ ）。
答案: 面向对象方法替代了结构化程序设计方法
12、 下列关于设置函数默认的参数值的描述中，错误的是（ ）。
答案: 设置函数参数默认值应从左向右设置
13、 下列关于引用概念的描述中，错误的是（ ）。
答案: 引用是变量，它具有值和地址值
14、 下列哪个不是面向对象的特征（ ）
答案: 结构性
15、 下列设置函数参数默认值的说明语句中，错误的是（ ）。其中，a和b是已定义过具有有效值的变量。
答案: int fun(int x=5, int y);
16、 下列说法正确的是（ ）
答案: 类中的函数成员可以在类体内定义,也可以在类体外定义
17、 void Set( &a);是类中一个成员函数的说明，其中&a的含义是（ ）。
答案: 类A的对象引用a作该函数的参数
18、 下列选择重载函数的不同实现的判断条件中，错误的是（ ）。
答案: 函数返回值不同
19、 下面（ ）是函数重载。
答案: void play(int) 和void play(float)
20、 在函数的引用调用中，函数的实参和形参分别应是（ ）。
答案: 变量名和引用
21、 在类外定义类的成员函数时，应当使用（ ）来标识该函数为特定类的成员。
答案: ：：
22、 假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（ ）。
答案: x.a()
23、 假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（ ）。
答案: px->a
24、 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ ）。
答案: x.GetValue()
25、 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。
答案: int A答案: 成员函数一定是内联函数
27、 已知类A中的一个成员函数的说明如下:void Set(A &a);则该函数的参数”A &a”的含义是（ ）
答案: 类A对象引用a用作函数的形参
28、 在类定义的外部，可以被访问的成员有（ ）
答案: public的类成员
29、 关于封装，下列说法中不正确的是（ ）。
答案: 通过封装，对象的属性都是不可见的
30、 下面关于对象概念的描述中，（ ）是错误的。
答案: 对象就是C语言中的结构变量
31、 下面关于类概念的描述中，（ ）是错误的。
答案: 类就是C语言中的结构类型
32、 关于对象和类的关系，说法不正确的是（ ）。
答案: 同一类的不同对象，其具有的操作可不同，具体的操作也不同
33、 类的实例化是指（ ）
答案: 创建类对象
34、 类的私有成员可在何处被访问？( )
答案: 本类的成员函数中
35、 （ ）是不可以作为该类的成员的。
答案: 自身类的对象
36、 下述程序中语句完全不正确的一组语句是（）class automover ｛
int wheels;
float weight;
public:
void initialize(int, float);
int get_wheels();
float get_weight()｛return weight;｝
｝;
void automover::initialize(int in_wheels, float in_weight)
｛ wheels=in_wheels; weight=in_weight;｝
int automover::get_wheels(void)｛ return wheels; ｝
void main()
｛ automover car;
automover.initialize(4, 3000.0); //①
car.wheels=4; //②
car.weight=3000.0; //③
car.initialize(4, 3000.0); //④
cout<<“The car has “<<car.wheels<<” wheels.”; //⑤
cout<<“The car weighs “<<car.weight<<” pounds.”; //⑥
cout<<“The car has “<<car.get_wheels()<<” wheels.”; //⑦
cout<<“The car weighs “<<car.get_weight()<<” pounds.”; //⑧
｝
答案: ①、②、③、⑤、⑥
37、 设有以下类和对象的定义:class A
{public:
int k;
};
A x1,x2,p1,p2;则下面针对成员变量k的引用，正确的是（ ）。
答案: x2.k=2;
38、 设有以下类的定义：class Ex
{ int x;
public:
void setx(int t=0);
};若在类外定义成员函数setx(),以下定义形式中正确的是（ ）。
答案: void Ex::setx(int t) {…}
39、 有如下类声明： class TestClass
{
int i;
private:
int j;
protected:
int k;
public:
int m,n;
};其中，私有成员的数量为( )
答案: 2
40、 在C++中，一个函数为void f(int, char ch=’a’)，另一个函数void f(int)，则它们（ ）。
答案: 可以在同一程序中定义并可重载
41、 关于类的成员函数，下列说法正确的是（ ）。
答案: 可以设置参数的缺省值
42、 C++语言支持封装性和继承性，不支持多态性。
答案: 错误
43、 成员函数与一般函数一样可以重载、内联和设置参数的默认值。
答案: 正确
44、 定义对象引用时，可以对其引用进行初始化，也可以不进行初始化。
答案: 错误
45、 定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。
答案: 正确
46、 定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。
答案: 错误
47、 类的公有成员函数是类与外界的接口。
答案: 正确
48、 类中的成员函数都是公有的，数据成员都是私有的。
答案: 错误
49、 类中的数据成员不能为指针类型。
答案: 错误
50、 使用class定义的类，其默认的访问权限是公有的，使用struct定义的类，其默认的访问权限是私有的。
答案: 错误
51、 一个类只能有一个对象。
答案: 错误
52、 已知：类A中一个成员函数说明如下：void Set(A&a)；其中A &a的含意是将a的地址给变量Set。
答案: 错误
53、 已知:m是类A的对象，n是类A的公有数据成员，p是指向类A中n成员的指针。下述两种表示是等价的：m.n和m.*p
答案: 正确
54、 对象引用作为函数参数比用对象指针更方便些。
答案: 正确
55、 在C++中，定义函数时应该给出函数的返回类型。
答案: 正确
56、 自身类对象的引用不可以作为该类的成员。
答案: 错误
57、 函数的参数个数和类型都相同，只是返回值不同,这不是重载函数。
答案: 正确
58、 使用内联函数是以增大空间开销为代价的。
答案: 正确
59、 在类的定义中，必须包含private、public、protected三种存取方式对应的部分。
答案: 错误
60、 在用class定义一个类时,数椐成员和成员函数默认的访问权限是public。
答案: 错误
61、 面向对象方法具有封装性、继承性和多态性。
答案: 正确
62、 类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。
答案: 错误
第1章 面向对象程序设计（4周） 第1章测验2（构造析构和类的组合）
小提示:本节包含奇怪的同名章节内容
1、 假定一个类的构造函数为B(int x,int y){a=x–;b=a*y–;},则执行B x(3,5); 语句后，x.a和x.b的值分别为（ ）
答案: 3和15
2、 （ ）是析构函数的特征。
答案: 一个类中只能定义一个析构函数
3、 下列( )不是构造函数的特征。
答案: 构造函数必须指定类型说明
4、 下列关于构造函数的描述中，错误的是（ ）。
答案: 构造函数不可以重载
5、 下面的哪一个构造函数头格式不正确（ ）。
答案: AA(int a＝0,int b)
6、 下列关于析构函数的描述中，错误的是（ ）。
答案: 析构函数的函数体都为空
7、 下列关于析构函数描述正确的是( )
答案: 不能指定返回类型
8、 下列关于子对象(内嵌对象成员)的描述中，错误的是（ ）。
答案: 一个类中只能有一个子对象
9、 下面（ ）项是对构造函数和析构函数的正确定义。
答案: X::X(参数), X::~X()
10、 下面说法中正确的是（ ）
答案: 一个类只能定义一个析构函数，但可以定义多个构造函数
11、 下面有关构造函数的描述中，正确的是（ ）。
答案: 构造函数的名字与类名完全相同
12、 形如X::X(X&)的构造函数称为( )
答案: 复制构造函数
13、 一个类可包含析构函数的个数是（ ）
答案: 1个
14、 一个类拥有多个构造函数，则这些构造函数之间为（ ）
答案: 重载关系
15、 定义析构函数时，正确的是（ ） 。
答案: 无形参，也没有返回值
16、 一个类中一个无参数构造函数和一个全部都是默认参数的构造函数共存是否存在二义性（ ）
答案: 存在
17、 已知X类.则当程序执行到语句X array[3];时,调用了( )次构造函数.
答案: 3
18、 已知AA是一个类，则执行语句AA a;后（ ）
答案: 自动调用无参构造函数
19、 已知example是已定义的类,则程序结束前,共存在( )个对象.#include<iostream.h>
class example
{ int y;
public:
example(int a){y=a;cout<<“constructor”<<endl;}
void print(){cout<<“y=”<<y<<endl;}
};
void main()
{
example x(5);
example arr[2]={1,2};
x=10;
x.print();
}
答案: 3
20、 在下列函数原型中，可以作为类AA构造函数的是（ ）。
答案: AA(int);
21、 执行下列说明语句，其调用构造函数的次数为（ ）。A a[5]，*p[2];其中，A是一个类名
答案: 5
22、 下列对类的构造函数和析构函数的叙述，正确的是（ ）
答案: 构造函数可以重载，析构函数不能重载
23、 对于复制构造函数point::point(point& p)，下列说明正确的是（ ）
答案: 该函数可以访问p的私有和公有成员
24、 一个类的析构函数是在（ ）时被自动调用。
答案: 该类对象撤消
25、 下列关于对象数组的描述中，（ ）是错误的。
答案: 对象数组只能赋初值，而不能被赋值
26、 复制构造函数的作用是（ ）
答案: 用对象初始化对象
27、 在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为（ ）指针。
答案: this
28、 一个类的构造函数通常被定义为该类的（ ）成员。
答案: 公有
29、 一个类的析构函数通常被定义为该类的（ ）成员。
答案: 公有
30、 假定AB 为一个类，则执行“AB x;”语句时将自动调用该类的（ ）。
答案: 无参构造函数
31、 假定AB 为一个类，则执行“AB x(a,5);”语句时将自动调用该类的（ ）。
答案: 带参构造函数
32、 假定AB 为一个类，则执行“AB r1=r2;”语句时将自动调用该类的（ ）。
答案: 拷贝构造函数
33、 假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A x(4,5);”语句后，x.a和x.b的值分别为（ ）。
答案: 4和20
34、 假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 “A x(4);”语句后，x.a和x.b的值分别为（ ）。
答案: 4和0
35、 假定AB 为一个类，则（ ）为该类的复制构造函数的原型说明。
答案: AB (AB &x);
36、 假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为。
答案: 3
37、 假定一个类AB 只含有一个整型数据成员a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为（ ）。
答案: AB (){}
38、 假定一个类AB 只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为（ ）。
答案: AB (int aa=0){a=aa;}
39、 假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为（ ）。
答案: n
40、 假定AB 为一个类，则执行“AB a(2),b[3],*p[4];”语句时共调用该类构造函数的次数为（ ）。
答案: 4
41、 假定AB 为一个类，则执行“AB a,b(3),*p;”语句时共调用该类构造函数的次数为（ ）。
答案: 2
42、 假定AB 为一个类，则执行“AB a,b(2),c[3],*p=&a;”语句时共调用该类无参构造函数的次数为（ ）。
答案: 4
43、 对类对象成员的初始化是通过构造函数中给出的（ ）实现的。
答案: 初始化表
44、 下列函数中，（ ）不能重载。
答案: 析构函数
45、 关于对象成员的构造函数的调用顺序，说法正确的是( )。
答案: 与他们在类中说明顺序相同
46、 关于下面程度段说法正确的是( ).class X
{
private:
int n;
punblic:
X(X&);
}
X::X(X&x){n=x.n}
X obj1,obj2;
obj2(obj1);
答案: 语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2
47、 假定A 为一个类,则执行A x;语句时将自动调用该类的( )
答案: 无参构造函数
48、 假定AB为一个类，则( )为该类的复制构造函数的原型说明。
答案: AB(AB& x);
49、 假定AB为一个类，则执行 “AB r1=r2;” 语句时将自动调用该类的（ ）。
答案: 复制构造函数
50、 假定Mylass为一个类，则该类的复制构造函数的声明语句为（ ）
答案: MyClass(MyClass &x)；
51、 复制构造函数具有的下列特点中，（ ）是错误的。
答案: 复制构造函数的名字不能用类名
52、 类AB的缺省构造函数和析构函数是（ ）
答案: AB( )和~AB( )
53、 类的构造函数的作用是（ ）
答案: 对象的初始化
54、 类的析构函数的作用是（ ）
答案: 删除类创建的对象
55、 缺省析构函数的函数体是（ ）
答案: 空的
56、 如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（ ）
答案: 编译器总是自动创建一个不带参数的构造函数
57、 设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（ ）
答案: 成员构造函数先执行
58、 假定AA是一个类，“AA& abc();”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc()调用该成员函数后，x的值（ ）。
答案: 已经被改变
59、 有如下程序：# include <iostream>
using namespace std;
class Name
{
char name[20];
public:
Name( )
{ strcpy(name, “”); cout<<‘?’; }
Name(char *fname)
{ strcpy(name,fname); cout<<‘?’; }
};
int main( )
{
Name names[3]={Name(“张三”), Name(“李四”)};
return 0;
}运行此程序输出符号?的个数是（ ）。
答案: 3
60、 有如下两个类定义：class AA{};
class BB
{
AA v1,v2;
BB v3;
int v4;
};其中有一个成员变量的定义是错误的，这个变量是( )。
答案: v3
61、 在C++中，编译系统自动为一个类生成缺省构造函数的条件是（ ）。
答案: 该类没有定义任何构造函数
62、 下面类的定义，有（ ）处错误。class MyClass{
private:
int i=0;
public:
void MyClass();
~MyClass(int Value);
};
答案: 3
63、 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，正确的是（ ）
答案: A1.*p=5;
64、 类的构造函数被自动调用执行的情况是在定义该类的（ ）
答案: 对象时
65、 若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（ ）
答案: a是类Sample的对象引用，用来作函数Set()的形参
66、 假定有类AB，有相应的构造函数定义，能正确执行 “AB a(4),b(5), c[3] , *p[2]={&a,&b}；”语句，请问执行完此语句后共调用该类析构函数的次数为（ ）
答案: 5
67、 对于复制构造函数，正确的描述是（ ）。
答案: 在C++语言中，如果不自定义类的复制构造函数，则每个类都有默认的复制构造函数
68、 有如下程序：#include<iostream>
using namespace std;
class ONE {
int c;
public:
ONE(): c(0) { cout<<1; }
ONE(int n): c(n) { cout<<2; }
};
class TWO {
ONE onel;
ONE one2;
public:
TWO(int m) : one2(m) { cout<<3; }
};
int main() {
TWO t(4);
return 0;
}运行时的输出结果是（ ）
答案: 123
69、 下面表述错误的是（ ）。
答案: this指针是字符指针
70、 C++如果某函数的返回值是个对象，则该函数被调用时，返回的对象（）
答案: 是通过复制构造函数初始化的
71、 下列程序的运行结果为#include<iostream.h>
int i=0;
class A{
public:
A(){i++;}
};
void main()
{
A a;
A b[3],*c;
c=b;
cout<<i<<endl;
}
答案: 4
72、 有如下程序：#include<iostream>
using namespace std;
class test{
private:
int a;
public:
test(){cout<<“constructor”<<endl;}
test(int t ):a(t) {cout<<a<<endl;}
test(const test &_test)
{
a=_test.a;
cout<<“copy constructor”<<endl;
}
~test(){cout<<“destructor”<<endl;}
};
int main()
{
test A(3);
return 0;
}运行时的输出结果是( )。
答案: 3 destructor
73、 若有如下类声明class MyClass{
public:
MyClass(){cout<<1;}
};执行下列语句MyClass a,b[2],*p[2];以后，程序的输出结果是( )
答案: 111
74、 复数类及对象的定义如下：class Complex
{
double real,image;
public:
Complex(double r=0, double i=0) {real=r; image=i; }
Complex(Complex &c) {real=c.real; image=c.image; }
};
Complex c1; //A
Complex c2(3,5); //B
Complex c3(c2); //C
c2=c1; //D下述说法中正确的是（ ）。
答案: C行调用了复制构造函数
75、 下列描述中，（ ）不是构造函数的特征。
答案: 必须显式的为类定义一个构造函数
76、 下列有关析构函数的描述中，正确的是（ ）。
答案: 析构函数在撤消对象时，系统自动调用
77、 #include <iostream.h>
class A
{
int x,y;
public:
A(int a,int b):x(a),y(b){}
void set(int a,int b){ x=a; y=b; }
void show(){ cout<<x<<”,”<<y<<endl; }
};
void main()
{ A obj;
obj.set(3,5);
obj.show();
}对上述程序段，下述说法中正确的是（ ）。
答案: 在编译时报错，程序无法运行
78、 有如下程序：#include<iostream>
using namespace std;
class Test{
public:
Test(){}
~Test(){cout<<‘#’;}
};
int main(){
Test temp[2], *pTemp[2];
return 0;
}执行这个程序输出星号（#）的个数为（ ）。
答案: 2
79、 类TM和类TN是两个独立的类，那么类TM中哪种形式的数据成员一定是不允许的?( )
答案: TM a;
80、 对于如下的类（） class Animal
{ float weight;
int feet;
public:
Animal(float w,int f=4)
{weight=w; feet=f;}
}; 定义其对象完全正确的一组语句是（）
答案: Animal a1(3.6, 8); Animal a2(67.9);
81、 已知一个类Complex，有下述两行：Complex c; //A
Complex c();//B以下描述中，错误的是（ ）。
答案: B行定义了一个对象，并调用缺省构造函数
82、 设有定义：class person
{ int num;
char name[10];
public:
void init(int n, char *m);
//…
};
person std[30];则以下叙述不正确的是( )。
答案: std数组中的每一个元素都有各自的成员函数init
83、 下列关于this指针的描述中，错误的是（ ）。
答案: this指针只能隐含使用，不能显式使用
84、 this指针是系统生成的指向当前被某个成员函数操作对象的指针。
答案: 正确
85、 创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。
答案: 正确
86、 定义对象指针时也要调用构造函数。
答案: 错误
87、 定义或说明对象时，系统会自动调用构造函数为创建的对象初始化。如果类中没有定义任何构造函数时，就无法给定义的对象初始化。
答案: 错误
88、 对象引用可以用一个同类对象的地址值对它赋值。
答案: 错误
89、 对象指针成员表示与对象引用相同。
答案: 错误
90、 对象指针可用同类对象的地址值给它赋值。
答案: 正确
91、 对象指针数组可以使用不同类的对象的地址值进行初始化。
答案: 错误
92、 给对象数组元素赋值时都要创建临时对象。
答案: 错误
93、 构造函数的功能是对对象进行初始化。
答案: 正确
94、 构造函数和析构函数都可以重载，因为它们都是成员函数。
答案: 错误
95、 构造函数和析构函数都可以重载。
答案: 错误
96、 构造函数和析构函数都是系统自动调用的成员函数。
答案: 正确
97、 构造函数可以设置默认参数。
答案: 正确
98、 构造函数没有函数返回类型。
答案: 正确
99、 构造函数是一个其名与类名相同的特殊的成员函数。
答案: 正确
100、 假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为1次。
答案: 错误
101、 类的析构函数的作用是对象的初始化。
答案: 错误
102、 析构函数不指定参数，而构造函数可以指定参数。
答案: 正确
103、 析构函数可以有形参。
答案: 错误
104、 一个类中只能定义一个析构函数。
答案: 正确
105、 在程序中可以显式调用构造函数。
答案: 正确
106、 指向对象的常指针的地址值是可以改变的。
答案: 错误
107、 子对象的初始化要在构造函数的成员初始化列表中进行。
答案: 正确
108、 自身类对象可作该类的子对象。
答案: 错误
109、 构造函数和析构函数都不能重载。
答案: 错误
110、 对象数组的元素可以是不同类的对象.
答案: 错误
111、 指向对象数组的指针不一定必须指向数组的首元素.
答案: 正确
112、 一维对象指针数组的每个元素应该是某个类的对象的地址值.
答案: 正确
113、 通常的复制构造函数的参数是某个对象的指针名。
答案: 错误
114、 复制构造函数的参数可以是某类的对象名。
答案: 错误
115、 如果在类声明中没有定义复制构造函数，就不能用一个对象去初始化另一个对象。
答案: 错误
116、 如果程序中未声明构造函数，则系统自动产生出一个默认形式的构造函数。
答案: 正确
117、 如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。
答案: 正确
118、 类中的成员数据可以是另一个类的对象。
答案: 正确
119、 一个类的构造函数中可以不包含对其内嵌对象的初始化.
答案: 错误
120、 构造函数和析构函数都可以带参数。
答案: 错误
121、 重载函数可以带默认值参数，但要注意二义性。
答案: 正确
122、 下列关于对象数组的描述中，（ ）是错误的。
答案: 对象数组只能赋初值，而不能被赋值
第1章 面向对象程序设计（4周） 第1章测验3（静态和友元）
1、 （ ）的功能是对对象进行初始化。
答案: 构造函数
2、 （ ）只能访问静态成员变量。
答案: 静态成员函数
3、 下列访问公有静态成员的方式，错误的是（ ）
答案: 对象指针.静态成员名
4、 下列关于静态成员的描述中，错误的是（ ）。
答案: 静态成员只可以用类名加作用域运算符来引用，不可用对象引用
5、 下列关于静态数据成员的说法，不正确的是（ ）。
答案: 静态数据成员不是所有对象所共用的
6、 下列关于友元的描述错误的是（ ）
答案: 成员函数不可作友元
7、 下列关于友元函数的描述中，错误的是（ ）。
答案: 友元函数只可访问类的私有成员
8、 下面对静态数据成员的描述中，正确的是（ ）
答案: 静态数据成员可以直接用类名调用
9、 下面对于友元函数描述正确的是（ ）
答案: 友元函数从表面上看破坏了类的封装性和隐藏性
10、 下面关于静态成员函数的叙述中错误的是（ ）。
答案: this指针可以指向静态成员函数
11、 下面关于友元的描述中，错误的是（ ）。
答案: 类与类之间的友元关系可以传递
12、 下面有关静态成员函数的描述中，正确的是（ ）
答案: 在建立对象前，就可以为静态数据成员赋值
13、 下面有关友元函数的描述中，正确的说法是（ ）
答案: 友元函数是独立于当前类的外部函数
14、 一个类的所有对象共享的是（ ）。
答案: 静态数据成员
15、 一个类的友元函数或友元类能够通过成员操作符访问该类的（ ）
答案: 公有成员、保护成员和私有成员
16、 已知类A是类B的友元，类B是类C的友元，则（ ）
答案: 类A的成员函数可以访问类B的对象的任何成员
17、 由于数据隐藏的需要，静态数据成员通常被说明为（ ）。
答案: 私有的
18、 友元访问类的对象的成员时使用（ ）
答案: “对象名.成员名”的形式
19、 友元关系不能（ ）
答案: 继承
20、 友元的作用之一是（ ）
答案: 提高程序的运行效率
21、 已定义类A： class A{public: int x; static int y;};int 答案: A.x = 1; A.y = 1;
22、 静态成员函数没有（ ）
答案: this 指针
23、 若类X是类Y的友元类，则下列访问关系中（ ）是正确的
答案: 类X的成员可以访问类Y的私有成员
24、 对于友元描述正确的是（ ）
答案: 友元不是本类的成员函数
25、 非静态成员函数都会有一个隐含指针，它是（ ）
答案: this指针
26、 一个类的静态数据成员所表示属性（ ）。
答案: 只是类的属性
27、 类的静态成员的访问控制（ ）。
答案: 可允许被定义为private、protected或public
28、 静态成员函数对类的数据成员直接访问（ ）。
答案: 只允许是静态数据成员
29、 被非静态成员函数访问的类的数据成员（ ）。
答案: 可以是非静态数据成员或静态数据成员
30、 静态数据成员的初始化是在（ ）中进行的。
答案: 全局区
31、 当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的（ ）。
答案: 具有任何权限的成员
32、 引入友元的主要目的是为了（ ）。
答案: 提高程序的效率和灵活性
33、 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（ ）。
答案: 需加上类域的限定
34、 一个类的友元不是该类的成员，与该类的关系密切，所以它（ ）。
答案: 没有this指针，也就没有默认操作的对象
35、 关于this指针的说法错误的是（ ）
答案: this指针必须显示说明
36、 对静态成员的不正确描述是（ ）
答案: 调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针
37、 下列静态数据成员的特性中（ ）是错误的。
答案: 静态数据成员不是所有对象所共用的
38、 关于静态成员的描述中，（ ）是错误的。
答案: 静态数据成员定义后必须在类体内进行初始化
39、 关于类的静态成员函数描述错误的是( )
答案: 在创建对象前不存在
40、 关于友元的描述中，（ ）是错误的。
答案: 友元函数是成员函数，它被说明在类体内
41、 静态成员遵循类的其他成员所遵循的访问限制，除了（ ）
答案: 静态数据成员初始化
42、 类A是类B的友元,类B是类C的友元,则( )是正确的.
答案: 以上都不对
43、 如果类 B 被说明成类 A 的友元，则（ ）。
答案: 类 B 的成员函数可以访问类 A 的成员
44、 如果类A被声明成类B的友元，则( )
答案: 类B不一定是类A的友元
45、 如果在类外有函数调用CPoint::func()；则函数func()是类CPoint的（ ）。
答案: 公有静态成员函数
46、 设类Test中存在成员static int x，则下列哪种初始化方式是正确的（ ）
答案: int Test::x=25；
47、 声明友元使用下列哪个关键字（ ）
答案: friend
48、 下面对友元的错误描述是（）
答案: 友元函数通过this指针访问对象成员
49、 下列关于静态数据成员的描述中，正确的是（ ）。
答案: 静态数据成员是类的所有对象所共有的
50、 以下关于this指针的叙述中正确的是：（ ）
答案: 类的非静态成员函数才有this指针
51、 有如下程序：# include <iostream>
class Toy
{
public:
Toy(char _n)
{ strcpy(name, _n); count++; }
~Toy( ) { count–; }
char GetName( )
{ return name; }
static int getCount( )
{ return count; }
private:
char name[10];
static int count;
};
int Toy::count=0;
int main( )
{
Toy t1(“Snoopy”), t2(“Mickey”), t3(“Barbie”);
cout<<t1.getCount( )<<endl;
return 0;
}运行时的输出结果是( )。
答案: 3
52、 关于友元，下列说法正确的是（ ）。
答案: A 类为 B 类的友元类，则A 类中的所有函数就可以访问 B 类中的所有成员
53、 （ ）是类的所用对象共享的成员，而不是某个对象的成员。
答案: 静态成员
54、 若要把函数void f()定义为类aClass的友元函数，则应该在类aClass定义中加入的语句是（）。
答案: friend void f()
55、 已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明（ ）
答案: f1是静态函数，f2不是静态函数
56、 下面关于友元的描述中，错误的是：（ ）
答案: 友元关系不能被继承，是双向可交换的。
57、 一个类的友元函数或友元类能够通过成员操作符访问该类的（ ）。
答案: 所有成员
58、 下面对静态数据成员的描述中，正确的是（ ）。
答案: 静态数据成员是类的所有对象共享的数据
59、 下面程序的结果为( )#include<iostream.h>
int c;
class A
{
private:
int a;
static int b;
public:
A(){a=0; c=0;}
void seta(){a++;}
void setb(){b++;}
void setc(){c++;}
void display(){cout << a << ” ” << b << ” ” << c;}
};
int 答案: 1 2 2
60、 下面程序的运行结果为( ) #include <iostream>
using namespace std;
class A
{
static int n;
public：
A(){n=1;}
A(int num){n=num;}
void print(){cout<<n;}
};
int 答案: 33
61、 有如下程序：#include<iostream>
using namespace std;
class A{
public:
static int a;
void init(){a=1;}
A(int a=2){init();a++;}
};
int 答案: 1
62、 有如下程序：#include <iostream>
using namespace std;
class Sample
{
friend int fun(Sample s);
public:
Sample(int a ) {x=a;}
private:
int x;
};
int fun(Sample s)
{
if(s.x<2) return 1;
return s.x*fun(Sample(s.x -1));
}
int main()
{
int sum=0;
for(int i=0;i<6;i++)
sum+=fun(Sample(i));
cout<<sum;
return 0;
}运行时输出的结果是( )
答案: 154
63、 在成员函数中访问对象的数据成员时，可以直接用数据成员名，而在友元函数中访问对象的数据成员时，必须指明是哪个对象的数据成员。
答案: 正确
64、 静态成员变量是整个类的所有对象共用的。
答案: 正确
65、 公有的静态成员可以使用类名加作用域运算符的方法来引用。
答案: 正确
66、 静态成员函数中引用静态数据成员和非静态数据成员的方式是相同的。
答案: 错误
67、 静态数据成员必须在构造函数的成员初始化列表中进行初始化。
答案: 错误
68、 可以把一个一般函数说明为某类的友元函数，也可以将某类的成员函数说明为另类的友元函数。
答案: 正确
69、 友元本身就是类的成员。
答案: 错误
70、 友元函数是类的成员函数，所以可以存取或修改该类中的私有成员。
答案: 错误
71、 友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。
答案: 正确
72、 友元类中的所有成员函数都是友元函数。
答案: 正确
73、 在一个类的对象空间里不包含静态成员的空间。
答案: 正确
74、 在一个类的对象空间里已经包含了静态成员的空间。
答案: 错误
75、 可以在类的构造函数中对静态数据成员进行初始化.
答案: 错误
76、 友元类的声明可以放在类定义中的任何地方。
答案: 正确
77、 类的公有静态成员既可以用类的对象访问，也可以用作用域运算符通过类名访问。
答案: 正确
78、 如果一个成员函数只存取类的静态数据成员，则可将该成员函数说明为静态成员函数。
答案: 正确
79、 C＋＋允许使用友元，但是友元会破坏封装性。
答案: 正确
80、 静态变量在整个程序的运行过程中始终都是存在着的。
答案: 正确
81、 类的静态数据成员需要在定义每个类的对象时进行初始化。
答案: 错误
82、 当将一个类S定义为另一个类A的友元类时，类S的所有成员函数都可以访问类A的所有成员。
答案: 正确
83、 静态数据成员必须在类外初始化。
答案: 正确
84、 静态成员函数可以引用属于该类的任何函数成员。
答案: 错误
85、 友元函数是在类声明中由关键字friend修饰说明的类的成员函数。
答案: 错误
86、 友元函数访问对象中的成员可以不通过对象名
答案: 错误
87、 某类中的友元类的所有成员函数可以存取或修改该类中的私有成员.
答案: 正确
第1章 面向对象程序设计（4周） 第1章测验4（常类型和动态内存分配）
1、 关于new运算符的下列描述中，（ ）是错误的。
答案: 使用它创建对象数组时必须指定初始值
2、 下列关于常成员的描述中，错误的是（ ）。
答案: 常数据成员的初始化是在类体内定义它时进行的
3、 下列关于运算符delete的描述中，错误的是（ ）。
答案: 使用该运算符可以释放所有对象
4、 下列关于运算符new的描述中，错误的是（ ）。
答案: 用它创建的对象可以不用delete运算符释放
5、 下列关于指针概念的描述中，错误的是（ ）。
答案: 指针的类型是它所存放的数值的类型
6、 定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为（ ）。
答案: int *p=new int[30];
7、 对使用关键字new所开辟的动态存储空间，释放时必须使用（ ）
答案: delete
8、 运算符delete删除一个动态对象时（ ）
答案: 首先为该动态对象调用析构函数,在释放其占用的内存
9、 对于常成员函数，下列描述正确的是（ ）
答案: 常成员函数不能修改任何数据成员
10、 对于动态分配内存空间描述正确的是（ ）
答案: delete运算符只能释放由new分配的动态存储空间
11、 已知:print()函数是一个类的常成员函数，它无返回值，下列表示中，（ ）是正确的。
答案: void print() const;
12、 关于new运算符的下列描述中，（ ）是错误的。
答案: 使用它创建对象数组时必须指定初始值
13、 关于delete运算符的下列描述中，（ ）是错误的。
答案: 对一个指针可以使用多次该运算符
14、 对于下面定义的类A在函数f()中将对象成员n的值修改为60的语句应该是（ ）class A
{
public:
A(int x){n=x;}
void SetNum(int n1){n=n1;}
private：
int n;
};
int f()
{
A *ptr=new A(60);
}
答案: Ptr->SetNum(60)
15、 若需要使类中的一个指针成员指向一块动态存储空间，则通常在（ ）函数中完成。
答案: 构造
16、 假定AB 为一个类，则执行“AB *px=new AB [n];”语句时将（ ）。
答案: 动态分配一个数组
17、 设px是指向一个类对象的指针变量，则执行“delete px;”语句时，将自动调用该类的（ ）。
答案: 析构函数
18、 假定AB 为一个类，则执行“AB *p=new AB (1,2);”语句时共调用该类构造函数的次数为（ ）。
答案: 1
19、 假定AB 为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为（ ）。
答案: n
20、 用new 运算符创建一个含10个元素的一维整型数组的正确语句是（ ）。
答案: int *p=new int [10];
21、 下面程序的输出结果是（ ）#include <iostream.h>
class example
{
int a;
public:
example(int b){a=b++;}
void print(){a=a+1;cout<< a<<” “;}
void print()const{cout<<a ; }
};
void main()
{
example x(3);
const example y(2);
x.print();
y.print();
}
答案: 4 2
22、 关于常成员的描述中，错误的是（ ）
答案: 常数据成员必须是公有的
23、 关于成员函数特征的描述中，不正确的是（ ） 。
答案: 成员函数不可以是静态的，只有数据成员可以是静态的
24、 关于类中数据成员的生存期的说法正确的是（ ）
答案: 由对象的生存期决定
25、 可以被对象之外访问的成员是（ ）
答案: 公有成员函数
26、 类MyClass的定义如下：class MyClass
{
public：
MyClass(){}
MyClass(int i){value=new int(i);}
int value；
}； 若要对value赋值，则下面语句正确的是（ ）
答案: MyClass my(10)；
27、 使用delete[]删除对象数组时，描述正确的是（ ）
答案: 数组中各元素都调用析构函数
28、 下列程序的执行结果是（） #include<iostream.h>
include<string.h>
class ABC
{
char str;
int max_len;
public:
ABC(int i, char s);
~ABC();
};
ABC::ABC(int i, char s)
{ max_len=i+1;
str=new char[max_len];
strcpy(str, s);
}
ABC::~ABC()
{ cout<<str;
delete str;
}
void main()
{ char ss=”Hello, C++ !”;
ABC sd(strlen(ss), ss);
cout<<“Main end.”;
}
答案: Main end.Hello, C++ !
29、 有如下程序：执行后的输出结果应该是：（ ）#include<iostream.h>
class cla{
static int n;
public:
cla(){n++;}
~cla(){n–;}
static int get_n(){return n;}
};
int cla::n=0;
int main()
{
cla *p=new cla;
delete p;
cout<<“n=”<<cla::get_n()<<endl;
return 0;
}
答案: n=0
30、 创建动态对象，需要使用操作符（ ）
答案: new
31、 删除动态对象，需要使用操作符（ ）
答案: delete
32、 关于const关键字说法错误的是（ ）
答案: const可以用于说明类
33、 执行如下程序后的输出结果是：（ ）#include<iostream.h>
class test{
static int count;
public:
test(){count++;}
~test(){count–;}
static int getCount(){return count;}
}；
int test::count=0;
int main()
{
test p=new test;
test q=new test;
delete p;
cout<<“count=”<<test::getCount()<<endl;
return 0;
}
答案: count=1
34、 当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为（ ）。
答案: n-1
35、 当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时，它最多能够存储（ ）个整数。
答案: n
36、 对类中常量成员的初始化是通过构造函数中给出的( )实现的。
答案: 初始化表
37、 已知类MyClass 声明如下： class MyClass {
int n;
public:
MyClass(int k) : n(k) {}
int getValue()const { return n; }
};在下列数组定义中正确的是 （）
答案: MyClass *x[2];
38、 有如下类定义：class A
{
char a;
public:
A( ) : a(0){}
A(char aa)
{ //把aa所指字符串拷贝到a所指向的存储空间
a=?;
strcpy(a,aa);
}
~A( ) (delete []a;}
};?处应填写的表达式是( )。
答案: new char[strlen(aa)+1]
39、 有如下程序：#include<iostream.h>
include<string.h>
class XCF
{
int a;
public:
XCF (int aa=0) : a(aa) { cout<<“1”; }
XCF(XCF & x)
{
a=x.a;
cout<<“2”;
}
~XCF( ) { cout<<a; }
int Geta( ) { return a; }
};
void main( )
{
XCF d1(5),d2(d1);
XCF *pd=new XCF(8);
cout<<pd->Geta( );
delete pd;
}运行时的输出结果是（ ）。
答案: 1218855
40、 下面对于常数据成员的描述正确的是( )
答案: 常数据成员必须初始化，并且不能更新。
41、 要使语句“p=new int[10][20];”能够正常执行，p应被事先定义为（ D ）。
答案: int(p)[20];
42、 假定指针变量p定义为“int p=new int(100);”，要释放p所指向的动态内存，应使用语句（ ）。
答案: delete p;
43、 假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（ ）。
答案: 不变
44、 假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为（ ）。
答案: n
45、 对类中引用成员的初始化是通过构造函数中给出的（ ）实现的。
答案: 初始化表
46、 对下列语句正确的描述是（ ）。 const int x； //① int const x； //②
答案: 语句②的含义是指针变量x不能更改
47、 关于new运算符的错误的描述是（ ）
答案: 使用运算符new创建对象数组时必须定义初始值
48、 类MyClass的定义如下：class MyClass
{
public:
MyClass() { value = 0;}
SetVariable(int i) { value = i; }
private:
int value;
}; 则对下列语句序列正确的描述是（ ）。 MyClass p，my； p=&my；
答案: 语句p->SetVariable(5)与语句my.SetVariable(5)等价
49、 有如下程序：#include <iostream>
using namespace std;
class Test {
public:
Test( ) { n+=2; }
~Test( ) { n-=3; }
static int getNum( ) { return n; }
private:
static int n;
};
int Test::n = 1;
int main( )
{
Test* p = new Test;
delete p;
cout << “n=” << Test::getNum( ) << endl;
return 0;
}执行后的输出结果是（ ）。
答案: n=0
50、 有如下程序：#include <iostream>
using namespace std;
class AA{
int n;
public:
AA(int k):n(k){ }
int get( ){ return n;}
int get( )const{ return n+1;}
};
int main( )
{
AA a(5);
const AA b(6);
cout<<a.get( )<<b.get( );
return 0;
}执行后的输出结果是（ ）
答案: 57
51、 下面各个程序中哪些是不正确的是（ ）。
答案: int i;int * const pi = NULL ;pi = &i;
52、 有如下程序：#include<iostream>
using namespace std;
class Point{
public:
static int number;
public:
Point(){number++;}
~Point(){number–;}
};
int Point::number=0;
void main(){
Point ptr;
Point A,B;
Point ptr_point=new Point[3];
ptr=ptr_point;
Point C;
cout<<Point::number<<endl;
delete[]ptr;
}运行时输出的结果是（ ）
答案: 6
53、 有如下程序 #include<iostream>
include<iomanip>
using namespace std;
class MyClass{
public:
MyClass(){cout<<‘A’;}
MyClass(char c ){cout<<c;}
~MyClass(){cout<<‘B’;}
};
void main()
{
MyClass p1,*p2;
p2=new MyClass(‘X’);
delete p2;
} 执行这个程序幕上将显示输出（ ）。
答案: AXBB
54、 下面表述中不正确的是（ ）。
答案: 如果#if后的常量表达值为真，则不编译这部分，否则就编译该部分
55、 在以下new和delete运算符使用中,错误的是().
答案: char *p=new int[10]; delete p;
56、 常成员指的是类体内使用const关键字说明的常数据成员和常成员函数。
答案: 正确
57、 常对象的数据成员都是常数据成员。
答案: 错误
58、 常对象可以调用任意成员函数。
答案: 错误
59、 常对象需要引用常成员函数，而不能引用非常成员函数。
答案: 正确
60、 常对象只能调用常成员函数。
答案: 正确
61、 常类型指针有两种，一种是指针的地址值是常量，另一种是指针所指向的变量或对象是常量。
答案: 正确
62、 常数据成员在常成员函数中的值是不允许改变的，而在非常成员函数中是允许改变的。
答案: 错误
63、 任何对象都可以使用delete运算符来释放。
答案: 错误
64、 使用new运算符创建的对象数组其元素都具有默认值。
答案: 错误
65、 使用new运算符创建数组时，可以为该数组指定初始值。
答案: 错误
66、 运算符new可以创建变量或对象，也可以创建数组。
答案: 正确
67、 在C++中，动态分配内存是通过new来实现的。
答案: 正确
68、 只有常成员函数才可以操作常对象。
答案: 正确
69、 定义指向常对象的指针后，指针所指向的对象是可以改变的。
答案: 错误
70、 const对象不能随意被修改，但const成员函数可以修改const对象。
答案: 错误
71、 用new动态申请的内存空间，必须用delete来释放 。
答案: 正确
72、 常引用做形参，在函数中不能更新所引用的对象。
答案: 正确
73、 成员函数定义返回的是对象的引用，最后可以返回函数内部的局部对象。
答案: 错误
74、 返回对象的引用时，不能用局部对象做为返回值。
答案: 正确
75、 返回值为本类对象的引用，不需初始化内存临时对象，返回值是对象自身，即*this。
答案: 正确
76、 如果类的构造函数中有动态申请的存储空间，在析构函数中应释放该空间。
答案: 正确
77、 若对象有动态分配的存储空间，就必须定义复制构造函数。
答案: 正确
第2章 继承性（2周） 第2章测验1（继承和继承方式）
1、 下列关于成员访问权限的描述中，不正确的是（ ）
答案: 类的私有数据成员只能被公有成员函数以及该类的任何友元类或友元函数访问
2、 this指针存在的目的是（ ）
答案: 保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码
3、 应在下列程序划线处填入的正确语句是（ ）。 class Base
{ public:
void fun(){cout<<“Base::fun”<<endl;} };
class Derived:public Base
{ void fun()
{ ___//显示调用基类的函数fun()
cout<<“Derived::fun”<<endl; } };
答案: Base::fun();
4、 有如下程序：#include<iostream>
using namespace std;
class AA
{
int k;
protected:
int n;
void setK(int k){ this->k=k; }
public:
void setN(int n){ this->n=n; }
};
class BB: public AA
{ /类体略/ };
int main( )
{
BB x;
x.n=l; //1#
x.setN(2); //2#
x.k=3; //3#
x.setK(4); //4#
return 0;
}在标注号码的四条语句中正确的是( )。
答案: 2
5、 有如下类声明，则类MyDERIVED中保护的数据成员和成员函数的个数是（ ）。class MyBASE
{private:
int k;
protected:
int x;
public:
void set(int m,int n){ k=m;x=n;}
int get( )const{ return k;}
};
class MyDERIVED: protected MyBASE
{
protected:
int j;
public:
void set(int m, int n,int p){ MyBASE::set(m,n); j=p;}
int get( ) const { return MyBASE::get( )+j; }
};
答案: 4
6、 在 C++中的类有两种方法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过( )， 派生出新的类。
答案: 继承
7、 多重继承是（ ）。
答案: 派生类有多个直接基类
8、 在公有继承的情况下，基类的私有成员在派生类中的访问权限是（ ） 。
答案: 不可访问
9、 在公有继承的情况下，基类的私有成员在派生类中的访问权限是（ ） 。
答案: 不可访问
10、 以下四个关于类的访问控制的描述哪一个是错误的（ ）
答案: 类的成员函数不能访问类中的私有数据
11、 从一个基类派生出的各个类的对象之间（ ）。
答案: 不共享任何数据成员，但每个对象还包含基类的所有属性
12、 C++的继承性允许派生类继承基类的（ ）。
答案: 所有特性，并允许增加新的特性或重定义基类的特性
13、 派生类的成员函数可以直接访问基类的（ ）成员。
答案: 公有和保护
14、 对于公有继承，基类的公有和保护成员在派生类中将（ ）成员。
答案: 仍然相应保持为公有和保护
15、 对于公有继承，基类中的私有成员在派生类中将（ ）。
答案: 仍然是基类的私有成员
16、 当保护继承时，基类的（ ）在派生类中成为保护成员，在类作用域外不能够通过派生类的对象来直接访问该成员。
答案: 公有成员和保护成员
17、 在定义一个派生类时，若不使用保留字显式地规定采用何种继承方式，则默认为（ ）方式。
答案: 私有继承
18、 下列对派生类的描述中错误的说法是（ ）。
答案: 派生类所继承的基类成员的访问权限保持不变
19、 派生类的对象对其基类中（ ）可直接访问。
答案: 公有继承的公有成员
20、 下列关于类的继承描述中，（ ）是错误的
答案: 派生类可以访问基类的所有数据成员，也能调用基类的所有成员函数
21、 当一个派生类仅私有继承一个基类时，基类中的所有公有成员成为派生类的（ ）
答案: private成员
22、 不论派生类以何种方法继承基类，都不能使用基类的（ ）
答案: private成员
23、 假定类A已经定义，对于以A为基类的单一继承类B，以下定义中正确的是:（ ）
答案: class B:public A{//…};
24、 C++类体系中，不能被派生类继承的有（ ）。
答案: 构造函数
25、 在C++中，对于基类的protected成员，当以protected方式派生一个新类时，该成员将成为派生类的（ ）成员。
答案: protected
26、 对于多重继承，有（ ）
答案: 一个派生类可有多个基类
27、 在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（ ）
答案: 保持不变
28、 关于保护成员的说法正确的是（ ）
答案: 具有私有成员和公有成员的双重角色
29、 关于保护继承的说法正确的是（ ）。
答案: 基类的公有成员、私有成员可被子类继承下来，公有成员性质改变为保护成员，私有成员不能被派生类直接访问。
30、 基类private成员，通过public派生，其在派生类中为（ ）
答案: 不可访问
31、 基类和派生类可以分别称为（ ）。
答案: “父类”和“子类”
32、 基类中的protected成员，通过public派生，其在派生类中的可见性为（ ）
答案: protected
33、 继承机制的作用是（ ）
答案: 派生新类
34、 假设已经定义好了类student，现在要定义类derived，它是从student私有派生的，则定义类derived的正确写法是（ ）
答案: class derived:student{ //………….}
35、 建造新的派生类是（ ）的实质。
答案: 继承
36、 派生类的对象可以访问以下那种情况继承的基类成员( )
答案: 公有继承的公有成员
37、 若类A和类B的定义如下：class A
{
int i,j;
public:
void get();
file://…
};
class B:A//默认为私有派生
{
int k;
public;
void make();
file://…
};
void B:: make()
{ k=ij;}则上述定义中，( )是非法的表达式。
答案: k=i*j;
38、 若派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（ ）
答案: 私有成员
39、 使用派生类的主要原因是（ ）
答案: 提高代码的可重用性
40、 下列对派生类的描述中，错误的是（ ）
答案: 派生类只继承了基类的公有成员和保护成员
41、 下列关于基类和派生类的描述中，错误的是（ ）。
答案: 基类中成员访问权限继承到派生类中不变
42、 下列关于继承的描述中，错误的是（ ）。
答案: C++语言只支持单重继承和双重继承
43、 下列描述中，错误的是（ ）。
答案: 基类public成员在protected派生类中仍是public成员
44、 下列说法中错误的是（ ）
答案: 私有继承时基类中的public成员在派生类中是protected的
45、 下面程序段中，说法正确的是（ ）class location{
public :
int GetX();
};
class rectangle:private location {
public:
int GetW();
};
答案: viod f( ) {Rectangle r;int X=r .GetX( );}其中int X = r .GetX( );是非法语句
46、 下面描述中，表达错误的是（ ）
答案: 公有继承时基类中的private成员在派生类中仍是private的
47、 下面叙述不正确的是（ ）
答案: 基类的保护成员在派生类中是保护的
48、 不论派生类以何种方法继承基类，都不能使用基类的（ ）
答案: private成员
49、 设W是U的公有派生类，U中的保护性数据成员a,被继承到W中后其访问属性是( )
答案: 保护的
50、 在保护继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（ ）
答案: 受保护
51、 通过派生类的对象可直接访问其 （ ）
答案: 公有继承基类的公有成员
52、 以下关于私有和保护成员的叙述中，不正确的是 （ ）
答案: 私有成员不能被外界引用，保护成员可以
53、 以下关于派生机制的描述中，不正确的是（ ）
答案: 采用私有继承，派生类只能得到基类的公有成员
54、 若要用派生类的对象访问基类的保护成员，以下观点正确的是（ ）
答案: 不能直接访问
55、 派生类由public方式继承基类成员，则 （ ）
答案: 基类中的公有成员可以被派生类的成员函数访问。
56、 派生类由protected方式继承基类成员，则 （ ）
答案: 基类中的公有成员成为派生类中的保护成员。
57、 有以下定义的派生类：class 答案: A类中的成员函数可以访问B类中的public数据成员。
58、 继承与派生可以给软件开发带来很多好处，下述中不正确的是（ ）
答案: 软件的执行效率大大提高
59、 设有基类定义：class cBase{
private:
int a;
protected:
int b;
public:
int c;
};派生类采用何种继承方式可以使成员变量b成为自己的私有成员（ ）。
答案: 私有继承
60、 有以下定义的类及变量：class B{
public:
B(){b=0;};
protected::
int b;
};
class 答案: a=cA.get();
61、 设有如下定义的基类与派生类：class cBase{
public:
int x;
protected:
int y;
private:
int z;
};
class cDerived:protected cBase{
public:
void sety(int a){y=a;};
};实例化对象：cDerived cc;则下面哪条语句是正确的（ ）
答案: cc.sety(4);
62、 下面关于基类与派生类的访问控制规则的叙述，错误的是（ ）
答案: 当通过private继承时，基类中的protected成员数据不能被派生类的成员函数访问。
63、 下面叙述正确的是( )。
答案: 派生类可以有自己的构造函数
64、 下面关于继承的描述中，错误的是( )。
答案: 静态成员不可以被继承
65、 派生类的成员函数不能访问基类的（ ）。
答案: 私有成员
66、 下面关于继承的描述中错误的是（ ）
答案: 派生类中继承的基类成员的访问权限到派生类保持不变
67、 类的成员若能被本类的成员函数所访问,也能被该类的派生类直接访问，但不能被外界直接访问（友元除外），则这样的类成员是（ ）
答案: 保护（protected:）成员
68、 对于下述程序，如果将第①句中的“protected:”去掉，则编译时（） #include<iostream.h>
class Base
｛ protected: //①
int Base_pro;
public:
void set(int i)
｛ Base_pro=i; ｝
｝;
class Derived : public Base //②
｛
int Drv_pri;
public:
void DrvSet(int i,int j)
｛ Drv_pri=i;
set(j); //③
｝
void display()
｛ cout<<“”Drv_pri = “”<< Drv_pri;
cout<<“”Base_pro = “”<< Base_pro; //④
｝
｝;
void main()
｛ Derived d;
d.DrvSet(3,6);
d.display();
｝
答案: 第③句对，第④句出错
69、 在公有派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（ ）
答案: 私有成员
70、 在main函数中可以用p.a的形式访问派生类对象p的基类成员a，其中a是（ ）
答案: 公有继承的公有成员
71、 以下有关继承的叙述正确的是 （ ）
答案: 派生类对象能访问自己的公有成员，不能访问基类的私有和保护成员
72、 C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过（ ）_派生出新的类。
答案: 继承
73、 下列关于继承的描述中，错误的是（ ）。
答案: 派生类中继承的基类成员的访问权限到派生类保持不变
74、 下面叙述错误的是（ ）。
答案: 基类的protected成员在派生类中仍然是protected的
75、 下列说法错误的是（ ）。
答案: 公有继承的基类中的private成员在派生类中仍是private的
76、 设有基类定义： class base
{ private:
int a;
protected:
int b;
public:
int c;
};派生类采用何种继承方式可以使成员变量c能被派生类的对象访问( )。
答案: 公有继承
77、 设有如下程序：#include<iostream.h>
class A
{ public:
int i;
display() { cout<<”class A”; }
};
class B
{ public:
int i;
display() { cout<<”class B”; }
};
class C: public: A, public B
{ int j;
public:
int i;
show() {j=i*i; display();}
};
void main()
{ C demo;
demo.show();
}主程序运行时将( )。
答案: 因类定义的语法错而不能运行
上方为免费预览版答案，如需购买完整答案，请点击下方红字
点关注，不迷路，微信扫一扫下方二维码
关注我们的公众号：阿布查查 随时查看答案，网课轻松过
为了方便下次阅读，建议在浏览器添加书签收藏本网页
电脑浏览器添加/查看书签方法
1.按键盘的ctrl键+D键，收藏本页面
2.下次如何查看收藏的网页？
点击浏览器右上角-【工具】或者【收藏夹】查看收藏的网页
手机浏览器添加/查看书签方法
一、百度APP添加/查看书签方法
1.点击底部五角星收藏本网页
2.下次如何查看收藏的网页？
点击右上角【┇】-再点击【收藏中心】查看
二、其他手机浏览器添加/查看书签方法
1.点击【设置】-【添加书签】收藏本网页
2.下次如何查看收藏的网页？
点击【设置】-【书签/历史】查看收藏的网页
蹦叙欧掀锋沮酿巢抡缸朝皮茄