C++清考资料类和对象

一、单项选择题 ( 在每小题的四个备选答案中，选出一个正确答案，并将正确答案的序号填在题干的括号内。共 15题 )

1. 在类中说明的成员可以使用关键字( )进行修饰。 a. private b. extern c. auto d. register

2. 如果类 a 被说明成类 b 的友元，则( )。 a. 类 a 的成员即类 b 的成员 b. 类 b 的成员即类 a 的成员

c. 类 a 的成员函数不得访问类 b 的成员 d. 类 b 不一定是类 a 的友元

3. 定义析构函数时，应该注意( )。 a. 其名与类名完全相同 b. 返回类型是 void 类型 c. 无形参，也不可重载

d. 函数体中必须有 delete 语句

4. 假定一个类的构造函数为 a(int aa,int bb){a=aa++;b=a*bb++;} ，则执行 a x(4,5); 语句后， x.a 和 x.b 的值分别为( )。 a. 4 和 5 b. 5 和 4 c. 4 和 20 d. 20 和 5

5. 假定 ab 为一个类，则执行 ab x ；语句时将自动调用该类的( )。 a. 有参构造函数 b. 无参构造函数 c. 拷贝构造函数 d. 赋值构造函数

6. 如果 class 类中的所有成员在定义时都没有使用关键字 pubilc,private,protected ，则所有成员缺省定义为：( )。 a. public b. protected c. private d. static

7. 类的指针成员的初始化是通过函数完成的，这个函数通常是( )。 a. 析构函数 b. 构造函数 c. 其它成员函数 d. 友元函数

8. 在 c++ 中实现封装是借助于( )。 a. 枚举 b. 类 c. 数组 d. 函数

9. c++对c语言作了很多改进，即从面向过程变成为面向对象的主要原因是( )。 a. 增加了一些新的运算符

b. 允许函数重载，并允许设置缺省参数 c. 规定函数说明符必须用原型 d. 引进了类和对象的概念

10. 下列不是描述类的成员函数的是( )。 a. 构造函数 b. 析构函数 c. 友元函数

d. 拷贝构造函数

11. 下面有关类说法不正确的是( )。 a. 一个类可以有多个构造函数 b. 一个类只有一个析构函数 c. 析构函数需要指定参数

d. 在一个类中可以说明具有类类型的数据成员

12. 下列不能作为类的成员的是( )。 a. 自身类对象的指针 b. 自身类对象

c. 自身类对象的引用 d. 另一个类的对象

13. 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是( )。 a. 类 b. 对象 c. 函数体 d. 数据块

14. 类的构造函数被自动调用执行的情况是在定义该类的( )。 a. 成员函数时 b. 数据成员时 c. 对象时

d. 友元函数时

15. 已知类 a 是类 b 的友元，类 b 是类 c 的友元，则( )。 a. 类 a 一定是类 c 的友元 b. 类 c 一定是类 a 的友元

c. 类 c 的成员函数可以访问类 b 的对象的任何成员 d. 类 a 的成员函数可以访问类 b 的对象的任何成员

二、程序分析题，请给出如下程序的执行结果 #include using namespace std;

class Clock {

private: int hour, minute, second; public:

Clock(int h=0, int m=0, int s=0) { hour=h; minute=m; second=s; } Clock(Clock &ck) { hour=ck.hour; minute=ck.minute; second=ck.second; cout <<\ cout <

void func(Clock ckp) { ckp.Settime(8,15,23); }

void main() { Clock ck1; int h=0, m=0, s=0; func(ck1); ck1.Gettime(h,m,s); cout <<\ Clock ck2(ck1); h=m=s=0; ck2.Gettime(h,m,s); cout <<\}

三、程序设计题

已知在point.h文件中有如下Point类的声明，请在point.cpp文件中完成类的定义，并在main.cpp文件中设计主函数测试Point类的功能。分别写出point.cpp文件和main.cpp文件的内容。

//point.h文件

#include using namespace std;

class Point { public: Point(int=0, int=0);//构造函数

~Point(); //析构函数 int GetX(); //获得点的x坐标 int GetY(); //获得点的y坐标 void SetPt(int, int); //重新设置点的x、y坐标 void OffsetPt(int, int);//在原来的坐标的基础上增加偏移量 private: int xVal, yVal; };

参考答案： 一、单项选择题 1-5 a d c c b 6-10 c b b d c 11-15 c c a c d

二、程序分析题

Copy constructor: 0:0:0 Time: 0:0:0

Copy constructor: 0:0:0 Time: 0:0:0

三、程序设计题 1.

point.cpp文件 #include \

Point::Point(int x, int y) :xVal(x),yVal(y) {}

Point::~Point() { }

void Point::SetPt (int x, int y) { xVal = x; yVal = y; }

void Point::OffsetPt (int x, int y) { xVal += x; yVal += y; }

int Point:: GetX () { return xVal; }

int Point:: GetY () { return yVal; }

main.cpp文件

#include #include \

int main() { Point p1,p2; p1.SetPt(0,0); p1.OffsetPt(-2,3); cout <<\ p2.SetPt(2,5); cout <<\ return 0; }

X1:-2 Y1:3 X2:2 Y2:5

一、单项选择题 ( 在每小题的四个备选答案中，选出一个正确答案，并将正确答案的序号填在题干的括号内。共 15题 )

1. 下列说法中正确的是( )。

a. 类定义中只能说明函数成员的函数头，不能定义函数体 b. 类中的函数成员可以在类体中定义，也可以在类体之外定义 c. 类中的函数成员在类体之外定义时必须要与类声明在同一文件中 d. 在类体之外定义的函数成员不能操作该类的私有数据成员

2. 重载函数在调用时选择的依据中，错误的是( )。 a. 函数的参数 b. 参数的类型 c. 函数的名字 d. 函数的类型

3. 构造函数不具备的特征的是( )。 a. 构造函数的函数名与类名相同 b. 构造函数可以重载

c. 构造函数可以设置默认参数 d. 构造函数必须指定类型说明

4. 通常，拷贝构造函数的参数是( )。 a. 某个对象名

b. 某个对象的成员名 c. 某个对象的引用名 d. 某个对象的指针名

5. 类的析构函数的作用是( )。 a. 一般成员函数 b. 类的初始化 c. 对象的初始化

d. 在撤销对象占用的内存之前完成清理工作

6. 类的析构函数是在( )调用的。 a. 类创建时 b. 创建对象时 c. 删除对象时 d. 不自动调用

7. 在 c++ 中，函数原型不能标识( )。 a. 函数的返回类型 b. 函数参数的个数 c. 函数参数类型 d. 函数的功能

8. 在 c++ 程序中，对象之间的相互通信通过( )。 a. 继承实现

b. 调用成员函数实现 c. 封装实现

d. 函数重载实现

9. 对于任意一个类，析构函数的个数最多为( )。 a. 0 b. 1 c. 2 d. 3

10. 友元关系不能( )。 a. 继承

b. 是类与类的关系

c. 是一个类的成员函数与另一个类的关系 d. 提高程序的运行效率

11. 考虑函数原型void test(int a,int b=7, char=\，下面的函数调用中，属于不合法调用的是( )。 a. test(5); b. test(5,8); c. test(6,\d. test(0,0,\

12. 下面有关重载函数的说法中正确的是( )。

a. 重载函数必须具有不同的返回值类型； b. 重载函数形参个数必须不同；

c. 重载函数必须有不同的形参列表； d. 重载函数名可以不同； 

13. 下列关于构造函数的描述中，错误的是( )。 a. 构造函数可以设置默认参数；

b. 构造函数在定义类对象时自动执行； c. 构造函数可以是内联函数； d. 构造函数不可以重载；

14. 下面对于友元函数描述正确的是( )。 a. 友元函数的实现必须在类的内部定义 b. 友元函数是类的成员函数

c. 友元函数破坏了类的封装性和隐藏性 d. 友元函数不能访问类的私有成员

15. 对类成员访问权限的控制，是通过设置成员的访问控制属性实现的，下列不是访问控制属性的是( )。 a. 公有类型 b. 私有类型 c. 保护类型 d. 友元类型

二、程序分析题，给出如下程序的运行结果 #include #include using namespace std; class Student {

public: Student(int n, string nam, char s) { num=n; name=nam; sex=s; cout <<\ } ~Student() { cout <<\ void display( ) {

cout <<\ cout <<\ cout <<\ } private: int num; string name; char sex; };

int main( ) { Student stud1(10010,\ stud1.display( ); Student stud2(10011,\ stud2.display( ); return 0; }

三、程序设计题

根据题目提供的主函数和程序的运行结果思考Time类至少应该具有哪些数据成员和成员函数，特别是成员函数应该具有什么功能，并将该类设计出来。 主函数为： int main() { Time t1(12,0,0); t1.Reset(23,59,59); Time t2(t1); cout <<\<

该主函数运行后的输出为： constructor! 12:0:0 after reset, 23:59:59

copy constructor! 23:59:59 t2 23:59:59

after reset, 11:21:23 destructor! 11:21:23 destructor! 23:59:59

请根据主函数及程序的输出，完整的设计出Time类。

参考答案：

一、单项选择题 1-5 b d d c d 6-10 c d b b a 11-15 c c d c d

二、程序分析题

Constructor called. num:10010 name:Wang_li sex:f

Constructor called. num:10011

name:Zhang_fun sex:m

Destructor called.Zhang_fun Destructor called.Wang_li

三、程序设计题

#include using namespace std;

class Time {

public: Time(int h=0, int m=0, int s=0):hour(h),minute(m),second(s) { cout <<\ cout <

{ hour=h; minute=m; second=s; cout <<\ cout <

类和对象单元练习

一、单选题

1.对于任意一个类，析构函数的个数最多为( )

A.0 B.1 C.2 D.3 2.下面说法正确的是( )

A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方 B.内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方 C.类的内联函数必须在类体内定义

D.类的内联函数必须在类体外通过加关键字inline定义 3.友元关系不能( ) A.继承

B.是类与类的关系

C.是一个类的成员函数与另一个类的关系 D.提高程序的运行效率

4.在C++程序中，对象之间的相互通信通过( )

A.继承实现 B.调用成员函数实现 C.封装实现 D.函数重载实现

5.所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是( )

A.类 B.对象 C.函数体 D.数据块 6.面向对象的程序设计语言必须具备的关键要素是( )

A.抽象和封装 B.抽象和多态性

C.抽象、封装、继承和多态性 D.抽象、封装和继承性 7.类的构造函数被自动调用执行的情况是在定义该类的( ) A.成员函数时 B.数据成员时 C.对象时 D.友元函数时 8.已知类A是类B的友元，类B是类C的友元，则( ) A.类A一定是类C的友元 B.类C一定是类A的友元

C.类C的成员函数可以访问类B的对象的任何成员

D.类A的成员函数可以访问类B的对象的任何成员 9.下列说法中正确的是( )

A.类定义中只能说明函数成员的函数头，不能定义函数体 B.类中的函数成员可以在类体中定义，也可以在类体之外定义 C.类中的函数成员在类体之外定义时必须要与类声明在同一文件中 D.在类体之外定义的函数成员不能操作该类的私有数据成员 10.在C++中实现封装是借助于( ) A.枚举 B.类

C.数组 D.函数

11.假定AB为一个类，则执行 “AB a(2), b［3］, *p［4］;”语句时共调用该类构造函数的次数为( ) A. 3 B. 4 C. 5 D. 9 12.假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete ［］px;”语句时共调用该类析构函数的次数为( ) A. 0 B. 1 C. n D. n+1

13.假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “Ax(4,5);”语句后，x.a和x.b的值分别为( ) A. 4和5 B. 5和4 C. 4和20 D. 20和5 14.构造函数不具备的特征是 ( ) A.构造函数的函数名与类名相同 B.构造函数可以重载

C.构造函数可以设置默认参数 D.构造函数必须指定类型说明

15.C++ 对 C 语言作了很多改进，即从面向过程变成为面向对象的主要原因是( ) A.增加了一些新的运算符

B.允许函数重载，并允许设置缺省参数 C.规定函数说明符必须用原型 D.引进了类和对象的概念

16.对于任一个类，用户所能定义的构造函数的个数至多为（ ） A.0 C．2

B．1 D．任意个

17.假定AA为一个类，a()为该类公有的函数成员，x为指向该类对象的指针，则访问x对象中函数成员a()的格式为（ ） A.x.a C．x->a

18.若Sample类中的一个成员函数说明如下：

void set(Sample& a)，则Sample& a的含义是（ ） A.指向类Sample的名为a的指针

B.a是类Sample的对象引用，用来作函数Set（）的形参 C.将a的地址赋给变量Set

D. 将Sample的对象a作为函数Set（）的形参

B．x.a() D．x->a()

19.类MyA的拷贝初始化构造函数是 ( ) A. MyA()

B. MyA(MyA*)

C. MyA(MyA&) D. MyA(MyA) 20.定义析构函数时，应该注意( )。

A.其名与类名完全相同 B.返回类型是void类型

C.无形参，也不可重载 D.函数体中必须有delete语句

二、填空题

1.类是用户定义的类型，具有类类型的变量称作_______。 2.当建立_______，程序自动调用该类的构造函数。 4. 每个对象都是所属类的一个____________

3.定义重载构造函数时，应在_______上有所不同。

5.当一个成员函数被调用时，该成员函数的_______指向调用它的对象。 6.拷贝构造函数通过_______使用引用来初始化创建中的对象。 7.类的私有成员只能被它的成员函数和_________访问。

8.通过C++语言中的_________机制，可以从现存类中构建其子类。

9.封装要求一个对象应具备明确的功能，并具有_________以便和其它对象相互作用。 10.在删除一个动态对象时，将自动调用该动态对象所属类的_________函数。

11.假定用户没有给一个名为AB的类定义析构函数，则系统自动给出的缺省析构函数定义为___________

12、局部对象、静态局部对象和全局对象中，在同一程序中________生存期最短；this指针始终指向当前正在发出成员函数调用命令的________。

三、程序填空

1.在下面程序的底画线处填上适当的字句，使该程序执行结果为10。 #include class base {

int X; public：

①________∥为X置值 ②________∥取X值

};

void main() {

base test; test.init(3);

cout<

2.在下列程序的底画线处填上适当的字句，完成类中成员函数的定义。 #include class line; class box { private: int color; int upx,upy; int lowx,lowy; public:

①________ int same_color(line a,box b); void set_color(int c){color=c;}

void define_box(int x1,int y1,int x2,int y2){upx=x1;upy=y1;} };

class line {

private:

int color;int startx,starty;int len; public:

②________ int same_color(line a,box b); void set_color(int c){color=c;}

void define_line(int x,int y){startx=x;} };

int same_color(line a,box b) {

if(a.color==b.color) return 1; return 0; }

int main() {

line L; box B;

L.set_color(2); B.set_color(3);

cout<

3.在下面程序段横线处填上适当的内容。 class A{

_①_______ int n; public:

A(int nn=0):n(nn){ if(n==0)a=0;

else a=new int［n］; }

②________//定义析构函数，释放动态数组空间 };

4、在下面的横线处填上适当内容，使程序完整。 # include # include class loc{

private:

float x,y; public:

loc(_①_______) {

x=x1; y=y1; }

float getx( ){return x;} float gety( ){return y;}

②________ float dis(loc&,loc&); };

float dis(loc&a,loc&b) {

float dx=a.x-b.x; float dy=a.y-b.y;

return sqrt(dx*dx+dy*dy); }

void main( ) {

loc p1(3.5,4.5),p2(5.5,6.5); float d=dis(p1,p2);

cout<<\ }

四、程序阅读，写出下列程序的运行结果

1、# include class Location{ int X,Y; public:

void init(int=0,int=0); void valueX(int val){X=val;} int valueX( ){return X;} void valueY(int val){Y=val;} int valueY( ){return Y;} };

void Location::init(int initX,int initY) {

X=initX; Y=initY; }

void main( ) {

Location A,B; A.init( );

cout<

cout<

cout<

2、#include class My Class { public:

int number; void set(int i); };

int number=3;

void MyClass::set (int i)

{

number=i; }

void main() {

MyClass my1; int number=10; my1.set(5);

cout<

cout<

#include class A { private: double X,Y; public:

A(double xx=0, double yy=0) { X=xx; Y=yy;

cout<<″构造函数被调用(″<

A(A &p) { X=p.X; Y=p.Y; } }; A f() { A a(1,2);

return a; }

void main()

{ A a(4,5); A b(a);

b = f();

} 4、

#include class A {

private:

int X,Y; public:

A() { X=Y=0;

cout<<\ }

A(int xx,int yy) {

X=xx;Y=yy;

cout<< \ }

~A() {

cout<<\ }

};

void main() {

A *p1=new A; delete p1; p1=new A(1,2); delete p1; }

参考答案： 一、 1、A 2、B 3、A 4、B 5、B 6、C 7、C 8、D 9、B 10、B 11、B 12、C 13、C 14、D 15、D 16、D 17、D 18、B 19、C 20、C 二、

1、对象 2、对象 3、参数类型或参数个数 4、实例 5、this 6、形参 7、友元 8、继承 9、外部接口 10、析构 11、～AB() 12、局部对象、对象 三、 1、

#include class base { int X; public: void init(int y){X=y+7;}//为X置值 int Getnum() {return X;}// 取X值 };

void main() { base test; test.init(3); cout<

#include class line; class box { private: int color; int upx,upy; int lowx,lowy; public: friend int same_color(line a,box b); void set_color(int c){color=c;} void define_box(int x1,int y1,int x2,int y2){upx=x1;upy=y1;} };

class line

{

private: int color;int startx,starty;int len; public: friend int same_color(line a,box b); void set_color(int c){color=c;} void define_line(int x,int y){startx=x;} };

int same_color(line a,box b) {

if(a.color==b.color) return 1; return 0; }

int main() { line L; box B; L.set_color(2); B.set_color(3); cout<

int *a; int n; public:

A(int nn=0):n(nn){ if(n==0)a=0;

else a=new int[n]; }

~A() {delete []a;}//定义析构函数，释放动态数组空间 }; 4、

# include # include class loc{

private:

float x,y; public:

loc(float x1,float y1) {

x=x1; y=y1; }

float getx( ){return x;} float gety( ){return y;} friend float dis(loc&,loc&); };

float dis(loc&a,loc&b) {

float dx=a.x-b.x; float dy=a.y-b.y;

return sqrt(dx*dx+dy*dy);

}

void main( ) {

loc p1(3.5,4.5),p2(5.5,6.5); float d=dis(p1,p2);

cout<<\ } 四、 1、

0 5 0 6 4 2、 5 10 3 3、

构造函数被调用(4,5) 构造函数被调用(1,2) 4、

Default Constructor called. Destructor called. Constructor called. Destructor called.

本文来源：https://www.bwwdw.com/article/vq13.html