类和对象

1 下面有关构造函数的描述中，正确的是（ b）。
A. 构造函数可以带有返回值 B. 构造函数的名字与类名完全相同
C. 构造函数必须带有参数 D. 构造函数必须定义，不能缺省
2 在声明类时，下面的说法正确的是（ c ）。
A. 可以在类的声明中给数据成员赋初值
B. 数据成员的数据类型可以是register
C. private，public，protected可以按任意顺序出现
D. 没有用private，public，protected定义的数据成员是公有成员
3 在下面有关析构函数特征的描述中，正确的是（c ）。
A. 一个类可以有多个析构函数 B. 析构函数与类名完全相同
C. 析构函数不能指定返回类型 D. 析构函数可以有一个或多个参数
4 构造函数是在（ b）时被执行的。
A. 程序编译 B. 创建对象 C. 创建类 D. 程序装入内存
5 下面有关静态成员函数的描述中，正确的是（ b ）
A. 在静态成员函数中可以使用this指针
B. 在建立对象前，就可以为静态数据成员赋值
C. 静态成员函数在类外定义是，要用static前缀
D. 静态成员函数只能在类外定义
6 下面有关友员函数的描述中，真确的说法是（ a ）
A. 友员函数是独立于当前类的外部函数
B. 一个友员函数不可以同时定义为两个类的友员函数
C. 友员函数必须在类的外部进行定义
D. 在类的外部定义友员函数时必须加上friend关键字
7 友员的作用之一是（ a ）
A. 提高程序的运行效率 B. 加强类的封装
C. 实现数据的隐蔽性 D. 增加成员函数的种类
8 类中定义的成员默认为（b ）访问属性。
A. public B. private C. protected D. friend
9 下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ a ）合适。
A. 内联函数; B. 重载函数; C. 递归调用； D. 嵌套调用。
10 C++对C语言作了很多改进，下列描述中（d ）使得C语言发生了质变，从面向过程变成了面向对象。
A. 增加了一些新的运算符； B. 允许函数重载，并允许设置缺省参数；
C. 规定函数说明必须用原型； D. 引进了类和对象的概念；
11 下列各种函数中，（ c ）不是类的成员函数。
A 构造函数 B 析构函数 C 友元函数 D 拷贝构造函数
12 通常,拷贝构造函数的形参是(c)
A.某个对象的值 B.某个对象的成员名
C.某个对象的引用名 D.某个对象的指针名
13 下面对静态数据成员的描述中,正确的是(c )
A 类的不同对象有不同

的静态数据成员值
B 类的每个对象都有自己的静态数据成员
C静态数据成员是类的所有对象共享的数据
D 静态数据成员不能通过类的对象调用
14 假定AB为一个类,则执行AB x;语句时将自动调用该类的(b )
A.有参构造函数 B.无参构造函数 C.拷贝构造函数 D.赋值构造函数
15 假定AB为一个类，则( c )为该类的拷贝构造函数的原型说明。
A. AB(AB x); B. AB(int x); C. AB(const AB& x); D. void AB(AB& x);
16 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是( a)。
A.类 B.对象 C.函数体 D.数据块
17假定一个类的构造函数为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
18关于成员函数特征的下列描述中，（a）是错误的。
A、成员函数一定是内联函数； B、成员函数可以重载；
C、成员函数可以设置缺省参数值； D、成员函数可以是静态的；
19 下列静态数据成员的特性中，（c）是错误的。
A） 说明静态数据成员时前边要加修饰符static
B） 静态数据成员要在类体外进行初始化
C） 静态数据成员不是所有对象所共用的
D）引用静态数据成员时，要在其名称前加<类名>和作用域运算符
20 f1(int)是类A的公有成员函数，p是指向成员函数f1()的指针，采用（b ）是正确的。
A. p=f1 B. p=A::f1 C. p=A::f1() D. p=f1()
21 ．关于静态成员的描述中，（ b ）是错误的。
A． 静态成员可分为静态数据成员和静态成员函数。
B． 静态数据成员定义后必须在类体内进行初始化。
C． 静态数据成员初始化不使用其构造函数。
D． 静态数据成员函数中不能直接引用非静态成员。
22 ．下列关于构造函数的描述中，错误的是（ d）。
A．构造函数可以设置默认的参数 B．构造函数在定义类对象的自动执行
C．构造函数可以是内联函数 D．构造函数不可以重载
23 如果类A被说明成类B的友元，则（ d ）。
A.类A的成员即类B的成员。
B.类B的成员即类A的成员。
C.类A的成员函数不得访问类B的成员 。
D.类B不一定是类A的友元。
24 声明友元的关键字是（c）
A．static B．mutable C．friend D．friends
25 面向对象程序设计的三大特性不包括（ d ）
A．封装性 B．继承性 C．多态性 D．健壮性
26 声明易变的成员变量，需要使用关键字（ a ）
A．mutable B．typename C．virtual D．template
27 类B的对象是类A的成员变量，定义A的对象A1，调用构造函数和析构函数的顺序是 （ d

）
A．A的构造函数、B的构造函数、B的析造函数、A的析构函数
B．A的构造函数、B的构造函数、A的析构函数、B的析造函数
C．B的构造函数、A的构造函数、B的析造函数、A的析构函数
D．B的构造函数、A的构造函数、A的析构函数、B的析造函数
28 类B是类A的子类，A有整型成员变量a，B也有整型成员变量a，B的对象b如何分别访问两个成员变量（ a）
A b.a和b.A::a B B::b. a和b.A::a C b.a和A::b.a D b.B::a和A::b.a
29 自定义类型中的哪种成员的访问不受限制（a ）
A．public B．protected C．private D．以上都不是
30 将自定义类型的成员函数的实现书写在该类型的定义内时，该成员函数默认是（ d ）
A．递归函数 B．常成员函数 C．虚函数 D．内联函数
31 struct中成员，在没有访问修饰的情况下，默认访问方式是（ c ）
A private B protected C public D 不一定
32 构造函数初始化列表不能初始（ c ）
A const成员变量 B 引用成员变量 C static成员变量 D 普通成员变量
33 下列关于static成员函数，说法错误的是 ( c )
A. static成员函数只能访问同类中的static成员
B．static调用时不传递this指针
C． static成员函数只能通过对象调用
D． static成员函数与对象无关
34 下列关于this指针的正确选项是（ c ）
A该指针需要我们在使用时自己定义 B this指针可以被重新赋值
C this指针用来存放该类对象的地址 D this指针指向的数据类型是int型
35 整型变量t是类W的公有静态成员变量，下列程序的运行结果为（ d ）
W w1,w2; w2.t =5; w1.t =10; w1.t +=20;
cout<A 30和15 B 5和20 C 30和5 D 30和30
36 下列说法正确的是 ( b )
A.类的成员函数的实现不能访问类的private类型的成员变量；
B.类的对象可以调用它的public类型的成员变量；
C.类的对象可以调用它的任何类型的成员变量；
D.类的对象可以调用它的public和protected类型的成员变量；
37 设有类的定义如下：
class AAA
{
int x;
char s[12];
} ob;
则在VC++环境下，变量ob所占内存空间字节数是（ C ）字节
（A）14 （B）15 （C）16 （D）17
38 （ A ）只能访问静态成员变量
（A）静态成员函数 （B）虚函数 （C）构造函数 （D）析构函数
39 面向对象程序设计中的数据隐藏指的是 d
A．输入数据必须输入保密口令
B．数据经过加密处理
C. 对象内部数据结构上建有防火墙
D．对象内部数据结构的不可访问性
40 拷贝构造函数的作用是 参考答案为:C
A．进行数据类型的

转换
B．用对象调用成员函数
C．用对象初始化对象
D．用一般类型的数据初始化对象
41 下面对结构或类中成员的访问中，不正确的访问是 A
A．*pointer.salary; （其中pointer为指向类对象的指针）
B．pointer->salary;
C．x=worker.salary; （其中worker为具有类类型的对象）
D．Location &rA=A1;int x=rA．GetX(); （Location为已定义的类，A为对象）
42 在C++语言中，数据封装要解决的问题是( D )
A. 数据的规范化 B. 便于数据转换
C. 避免数据丢失 D. 防止不同模块之间数据的非法访问
43 对类的构造函数和析构函数描述正确的是（ A ）
A. 构造函数可以重载，析构函数不能重载
B. 构造函数不能重载，析构函数可以重载
C. 构造函数可以重载，析构函数也可以重载
D. 构造函数不能重载，析构函数也不能重载
44 析构函数被调用的时间点是（　Ｂ）
A．对象被创建时 B．对象被销毁时
C．不会被调用 D．主函数被调用时
45 对象的构造函数调用顺序取决于（　B　）
A．对象成员在初始化列表中给出的顺序
B．对象成员在类中声明的顺序
C．对象成员与在初始化列表中顺序和类中声明顺序均有关
D．随机顺序
46 下列对静态成员函数描述正确的是（　B　）
A．静态成员函数中可使用1个this指针
B．静态成员函数中不能使用this指针
C．静态成员函数中可使用多个this指针
D．静态成员函数中只可使用1个that指针
47 友元的声明可出现在（ D ）
A．类的私有部分 B．类的公有部分
C．类的保护部分 D．类的任何部分
48 假设Sample是个类，则语句“Sample a［2］,*p［3］;”调用构造函数的次数为（　b）
A.0 B.2 C.3 D.5
49 关于面向对象的程序设计方法，下列说法正确的是d
A)“封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
B)“多态性”指的是对象的状态会根据运行时要求自动变化
C)基类的私有成员在派生类的对象中不可访问，也不占内存空间
D)在面向对象的程序设计中，结构化程序设计方法仍有着重要作用
50 有以下类定义
class MyClass
{
public:
MyClass(){cout<<1;}
};
则执行语句MyClass a, b[2], *p[2];后，程序的输出结果是 b
A)11 B)111 C)1111 D)11111
51 关于友元，下列说法错误的是 a
A)如果类A是类B的友元，那么类B也是类A的友元
B)如果函数fun()被说明为类A的友元，那么在fun()中可以访问类A的私有成员
C)友元关系不能被继承
D)如果类A是类B的友元，那么类A的所有成员函数都是类B的友元
52
有以下程序
#include
using namespace std;
class MyClass
{
public:
MyClass(int n){number = n;}
//拷贝构造函数

MyClass(const MyClass &other){ number=other.number;}
~MyClass(){}
private:
int number;
};
MyClass fun(MyClass p)
{
MyClass temp(p);
return temp;
}
int main()
{
MyClass obj1(10), obj2(0);
MyClass obj3(obj1);
obj2=fun(obj3);
return 0;
}
程序执行时，MyClass类的拷贝构造函数被调用的次数是 b
A)5 B)4 C)3 D)2
53 有以下类定义
class Point {
public:
Point(int x = 0, int y = 0) { _x = x; _y = y; }
void Move(int xOff, int yOff)
{ _x += xOff; _y += yOff; }
void Print() const
{ cout << '(' << _x << ',' << _y << ')' << endl; }
private:
int _x, _y;
};
下列语句中会发生编译错误的是 d
A) Point pt; pt.Print();
B) const Point pt; pt.Print();
C) Point pt; pt.Move(l, 2);
D) const Point pt; pt.Move(l, 2);
54 有以下类定义
class MyClass
{
private:
int id;
char gender,
char *phone;
public:
MyClass():id(0),gender('#'),phone(NULL) { }
MyClass(int no, char ge='#', char *ph= NULL)
{ id=no;gende=ge;phone=ph; }
};
下列类对象定义语句中错误的是b
A) MyClass myObj;
B) MyClass myObj(11, "133********");
C) MyClass myObj(12, 'm');
D) MyClass myObj(12);
55有以下程序
#include
using namespace std;
class Complex
{
public:
Complex(double r =0, double i =0):re(r), im(i) { }
double real() const { return re; }
double imag() const { return im;}
Complex operator +(Complex c) const
{ return Complex(re+c.re, im+c.im); }
private:
double re, im;
};
int main()
{
Complex a = Complex(1, 1) + Complex(5);
cout << a.real() << '+' << a.imag() <<'i' << endl;
return 0;
}
程序执行后的输出结果是b
A) 6+6i B) 6+1i C) 1+6i D) 1+1i
56 若定义类CA：
class CA{
public：
CA(int x=0)；
…
}；
执行语句”CA a(4)，b[3]，* p[2]；”，则自动调用该类的构造函数的次数为 b 。
A．6 B．4 C．3 D．1
57 下列关于类定义的说法中，正确的是（ a ）。
A）类定义中包括数据成员和函数成员的声明
B）类成员的缺省访问权限是保护的
C） 数据成员必须被声明为私有的
D）成员函数只能在类体外进行定义
58 在语句cin>>data;中，cin是（c）。
A）C++的关键字 B）类名
C）对象名 D）函数名
59 #include
using namespace std;
class test {
private:
int a;
　public:
test（）{cout<<”constructor”< test（int a）{cout< test（const test &test）{
a=test.a;
cout<<”copy constructor”< ~test（）{cout<<”destructor”<};
int main（）
{ test A（3）;
return 0;
}
运行时输出的结果是（ d ）
A）3
B）constructor
destruclor
C）copy constructor
destructor
D）3
destruclor
60 有如下程序：
#include
using

namespace std;
class point {
public:
static int number;
　public:
point（）{number++;}
～point（）{number--;}
};
imt point::number=0;
void main（）{
point*ptr;
point A,B;
{
point *ptr_point=new point[3];
ptr=ptr_point;
}
point C;
cout<delete[]ptr;
}
运行时输出的结果是（ c ）
A）3 B）4 C）6 D）7
61 在 C++中，编译系统自动为一个类生成缺省构造函数的条件是（C）。
A）该类没有定义任何有参构造函数
B）该类没有定义任何无参构造函数
C）该类没有定义任何构造函数
D）该类没有定义任何成员函数
62 有如下程序：
#include
using namespace std;
class Sample{
public:
Sample(){}
~Sample(){cout<<'*';}
};
int main(){
Sample temp[2], *pTemp[2];
return 0;
}
执行这个程序输出星号（*）的个数为（B）。
A）1 B）2 C）3 D）4
63在语句“cout<<'A';”中，cout 是（B）。
A）类名 B)对象名
C）函数名 D)C++的关键字
64 有如下程序：
#include
using namespace std；
class MyClass{
public:
MyClass(int i=0){cout<<1;}
MyClass(const MyClass&x){cout<<2;}
MyClass& operator=(const MyClass&x)
{cout<<3; return*this;}
~MyClass(){cout<<4;}
};
int main(){
MyClass obj1(1),obj2(2),obj3(obj1);
return 0:
}
运行时的输出结果是（A）。
A）112444 B）11114444
C）121444 D）11314444
65 有如下程序：
#include
using namespace std;
class MyClass{
public:
MyClass(int x):val(x){}
void Set(int x){val=x;}
void Print()const{cout<<"val="<private:
int val;
};
int main(){
const MyClass obj1(10);
MyClass obj2(20);
obj1.Print(); //语句 1
obj2.Print(); //语句 2
obj1.Set(20); //语句 3
obj2.Set(30); //语句 4
return 0;
}
其主函数中错误的语句是（C）。
A）语句 1 B）语句 2
C）语句 3 D）语句 4
66 设已定义了一个类名为MyClass的类：
MyClass s1，*s2，**s3，*s4[2]；
当该语句执行后，调用该类的构造函数的次数是 (A) 。
A．1 B．2 C．3 D．5
67