12-4类与对象练习题面向对象.doc

类和对象

一、选择题

题1下列关于成员访问权限的描述中，不正确的是 ____________ °

A） 公冇数据成员和公冇函数成员都可以被类对象直接处理

B） 类的私有数据成员只能被同类的公有成员函数以及该类的友元类或友元函数访问 C） 只有类或派生类的成员函数和友元类或友元函数可以访问保护成员 D） 保护成员在派生类中可以被派生类的函数成员访问，而私有成员不可以

题2下列关于构造函数的描述中，错误的是 ___________ o

A） 构造函数可以设置默认参数 B） 构造函数在定义类变量时被自动执行 C） 构造函数可以对静态数据成员进行初始化 D） 构造函数可以重载

题3 —个类的友元函数或友元类能够访问该类的 __________ o （已出在第五章PPT）

A）私有成员 C）公有成员

B）保护成员

D）公有成员、保护成员和私有成员

题4下面对于静态成员的描述中，正确的是 ___________ c

A） 静态数据成员是类的所有对象共享的数据 B） 类的每个对象都有自己的静态数据成员 C） 类的不同对象有不同的静态数据成员值 D） 静态数据成员不能通过类的对象调用

题5对于下面的类Samp,在函数fun（）屮将p所指向的对象的成员m的值改为70的语旬 应该是

class Samp

{

public:

Samp (int x){n=x;}

void SetNum(int nl){n=nl;} private: int n; }; int f() {

Samp *ptr=new Samp (45);

B) SetNum(70); D) ptr->n=70;

题6 下面是类class_for_c6的定义，以下描述正确的是 ______________ 。

class Class_for_e6

A) Samp (70);

C) ptr->SetNum(70);

{

public:

void Class_for_e6（int a）{X=a;} //I int f（int a,int b） //2

{

X=a;

Y=b;

}

int f（int a,int b,int c=0） {

X=a; Y=b; Z=c;

}

static void g（）{ X= 10;} private:

int X,Y,Z;

//4

〃3

}；

A） 语句1是类Class_for_c6的构造函数的」F确定义

B） 语句2和语句3能实现类成员函数的重载 C） 语句4实现对类成员变量X的更新操作合法 D） 以上说法都不正确

题7

________ 不是构造函数的特征 A） 构造函数的函数名与类名相同 B） 构造函数可以重载 C） 构造函数可以设置默认参数 D） 构造两数必须指定返回类型说明

题8有关析构函数的说法不正确的是 ___________ o

A） 析构函数冇且只冇一个 B） 析构函数无任何返冋类型

C） 析构函数和构造函数一样可以有形参

D） 析构两数的作用是在对象被删除前进行一些需要的清理工作

题9

________ ,是析构函数的特征。 A） 一个类中只能定义一个析构函数 B） 析构函数名与类名相同

C） 析构函数的定义只能在类声明体内 D） 析构函数「J以有一个或多个参数

题10 下列的各类函数屮， ___________ 不是类的成员函数。

A）构造函数 B）析构函数

题11

C）友元函数 D）拷贝构造函数

下列静态数据成员的特性中， _________ 是错误的。

A） 说明静态数据成员时前边要加修饰符static B） 静态数据成员要在构造函数内进行初始化

C) 可以直接使用类名来访问静态数据成员，方法是在静态数据成员名前加v类名〉

和作用域限度符

D) 静态数据成员是所有对象所共用的

题13

已知Semple中的一个成员函数说明如下：

void set(Sample &a)

其中形参Sample &a的含义是 _________ 。 A) 指向类Sample的名为a的指针 B) 将a的地址赋给变量set

C) a是类Sample的对象引用，用来做函数set()的形参 D) 变聚Sample与a按位与的结果作为函数set()的参数

题14 Sample是一个类，下列定义中 __________ 是定义指向对象数组的指针p

A) Sample *p[5] B) Sample (*p)[5] C) (Sample*) p[5] D) Sample *Up

题15在下面定义屮，错误的语句是 _________ o

class Sample

{

public:

Sample(int val); //A 〜Sample(); //B private: int a=2; //C flaot f;

//D

}； 试卷二 一.选择题

1、 下列有关类的说法，( )是不正确的。

A、 类是一种用户自定义的数据类型

B、 只有类中的成员函数才能存取类中的私有数据 C、 在类中如果不作特别声明，所有数据成员均为私有类型 D、 在类中如果不作特别声明，所冇成员函数均为私冇类型 2、 下列关于类与対象的说法中，( )是不正确的。

A、 对象是类的一个实例

B、 任何一个对象只能属于某个的类 C、 一个类只能冇一个对象

D、 类与对象的关系和数据类型与变最的关系相似 3、 下列关于构造函数的描述中，错误的是( )o A、 构造函数可以设置默认参数 B、 构造函数在定义类对象时自动执行 C、 构造函数可以是内联函数 D、 构造函数不可以重载

4、下列冇关析构函数的说法中，（

）是错误的。

A、 一个类屮析构函数有且只冇一个 B、 析构函数无任何返回类型

C、 析构函数和构造函数一样可以有形参

D、 析构函数的作用是在对象被删除前进行一些清理工作。 6、 假定MyClass为一个类名，那么下列的函数说明屮，（

原型

）为该类的析构函数的

A、〜MyClass ； C、MyClass（）;

B、 -MyClass（int n）; D、〜MyClass（）;

7. 若有一个MyClass类，贝I」执行语句MyClass a, b（2）」p;后，口动调用该类的构造函数（）

次。

A）2 C）4 B）3 D）5

9. 下面关于友元函数的描述屮，（）是正确的。 A、 友元函数的实现必须在类的内部定义 B、 友元函数是类的成员函数

C、 友元函数破坏了类的封装性和隐藏性 D、 友元函数不能访问类的私冇成员 10. 在C++中，数据封装要解决的问题是（ A）数据的规范化 C ）避免数据丢失

）

B）便于数据转换

D）防止不同模块之间数据的非法访问

11、一个类的友元函数或友元类可以访问该类的（）。 A）私右成员 B）保护成员 C ）公有成员

D）所有成员

）c

12、在类中定义和实现的函数可以称为（ A）静态成员函数 B）内联函数 C）常成员函数

D）虚函数

）是错误的。 B）成员函数可以重载 D）成员函数可以是静态的

13、下列关于成员函数特征的描述中，（ A）成员函数一定是内联函数 C）成员函数可以设置参数的默认值

14. C++中对于结构中定义的成员，其默认的访问权限为（ ）o A）public

B）protected C）private D） static

15. 为了使类中的成员不被类的对彖通过成员操作符来访问，则不能把该成员的访问权限设

置为（

）o

A） public B）protected C） private D） static 16. 下面对静态数据成员的描述中，( )是正确的。

A) 静态数据成员可以在类体内进行初始化 B) 静态数据成员不可以被类的对象來访问 C) 静态数据成员不能设置为protected D) 静态数据成员可以肓接用类名来访问

17. 对丁•下面定义的类MyClass,在函数f()中将对彖成员n的值修改为50的语句应该是 ()。 class MyClass {public:

Myclass(int x){n=x;)

void SctValuc(int nl)(n=nl;) private:

int n;

}；

int f()

{

MyClass *ptr=new MyClass(45); 〃対象的 n 的值为 45

}

A) MyClass(50)

B)SetValue(50) C) ptr->SetValue(50) D) ptr->n=5()

18、 类MyClass的定义如下: class MyClass { public:

MyClass( ){value=();}

sctVariablc(int i) {valuc=i;} private:

int value;

}；

则以下各项对如下语句序列的描述中，(

)是正确的。

Myclass *pjny; p=&my;

A) 语句p=&my;是把对象my赋值给指针变量P

B) 语句MyClass *p,my;会调川两次类MyClass的构造函数 C) 语句 *p.SetVariable(5);是合法的

D) 语句 p・>SetVariable⑸与语句 my. SctVariablc(5 )等价 19. 类aClass的定义如下: class aClass { public:

aClass(){ } aClass(int i)

{ value=new int(i); } int *value;

};

则下面的赋值语句中( )是正确的0

A) aClass my; my.value=10; B) aClass my; my.*value=O; C) aClass my; *(my.value)= 10; D) aClass my(10); 20. { int i=0; public:

void MyClass();

〜MyClass(int Value);

下面类的定义，有( )处错误 class myclass

}; A) 1 C)3

21. 若有以下程序：

B)2 D)4

#include class point { int x,y; public:

point(int xl,int x2=0){x=x 1 ;y=x2;} void setpoint(int xl Jnt yl) { x=xl; y=yl; } void dispoint()

{

n

cout«x«/'«y«endl;

}

}；

void main()

{ point *p=new point(l 2); p->setpoint(5J2); p->dispoint(); }

程序运行后的输出结果是( A) 12,12

B) 12,0

)

C) 12,5

D) 5,12

22. 若有以下程序： #include class sample { int n; public:

sample(int i){ n=i;}

void add(){s+=n;} static int s; void dis() {

cout«s«endl; }

};

int sample::s=0; void main(){

sample a(2),b(5),c(a); a. add (); b. add (); c. dis (); }

程序执行后的输出结果是： A) 2

B)5

C)7

D)9

23. 有如下程序： #include class sample { int x, y; public:

sample(int i.int j){x=i;y=j;}

void disp(){cout«H

displ\"«endl;}

void disp() const{ cout«H

disp2H«endl; } }; int main()

{ const sample a(l,2);

a.disp(); return 0; }

该程序运行后的输出结果是( )o

A) displ

B) disp2

C) displ disp2

24. 若有以下程序： #include class sample { int i；

public:

void setvalue(int m){i=m;} void fun(int m){i+=m;} void disp() {cout«i«endl;} };

void main() { sample *ps;

ps=new sample;

ps->setvalue(20); ps->fun(5); ps->disp();

D）程序编译时出错

}

程序运行后，输出的结果是( A) 15

B)20

C) 25

)

D) 30

25。 有以下程序:

#include #include class point { double x;

double y; public:

point(double a,double b) { x=a;

y=b; }

friend double distance(point appoint b);

};

double distance(point appoint b) {

return sqrt((a・x・b・x)*(a.x・b・x)+(a・y・b・y)*(a.y・b・y)); }

void main() { point pl(1,2);

point p2(5,2); cout«distance(p I ,p2)«endl; }

程序运行后的输出结果是( ) A) 1

B)5

C)4

D)6

26. 若有以下程序： #include class sample { int n; public:

sample(){ }

sample(int m){ n=m; } void addvalue(int m) { sample s;

s.n=n+m;

*this=s;

}

void disp()

{ cout« \"n=H«n«endl;

} }；

void main()

{ sample s(10);

s.addvalue(5); s.dispO;

}

程序运行后的输出结果是()。

A) n=10 B)n=5 C)n=15

D) n=20

二、写出以下程序段的输出结果。

1 • #include

class Test {public:

Test(int a); ~Tes((); private: int x;

};

Test::Test(int a) { x=a;

cou t« \"Constructor of\"«x«cndl; }

Test::〜Test() {

cout«'fDustructor ofM«x«endl; }

void fun() {

Test FunObject(l); static Test StaticObject(2); }

Test GlobalObject(3); int main()

Test MainObject(4); fun(); return 0;

2. #include

# include class person

{

private:

int no;

char name[20];

public:

void setvalue(const int no,const char named)

{

this->no=no;

strcpy(this->name,name); }

int getno() {return no;}

char *getname() {return name;} };

void main() {

person *p; p=new person;

,,

p-> setvalue( 1「zhang”)； cout«p->getno()«':'«(*p).getname()«end];

}

3 ・

#include # include class Student {

private:

char number[5]; char name[18]; float score;

static int counte;

public:

Student(char *num,char *name,float s)

{

strcpy (n umber,num); strcpy(this->name,name); score=s; counte++;

}

int get_counte() {return counte;} };

int Student::counte=0; void main()

Student si(”2012Talan”,67),s2(”2030TafiT,75); cout«s 1 •get_counte()«endl; cout«s2 .get_counte()«endl; } J

4. #include class A {

private:

int x; public:

A(int a){x=a;} friend class B;

};

class B

{

public:

void print 1 (A a) {

H

a.x—;cout«x=n«a.x«cndl;

}

void print2(A a) {

n

a.x++;cout«x=n«a.x«endl;

}

}；

void main() {

Aa(10); Bb;

b.printl(a); b.print2(a); }

5 • # include

class X {

private:

int a; int b; public:

X(){a=0;b=0;}

X(int ajnt b){X::a=a; X::b=b;}

,,,,

void disp(){cout«a=\"«a«,b=,,«b;} }； class Y

{

private:

X x; int y; public:

Y(){y=0;}

Y(int a,int b,int c):x(a,b){y=c;} void disp()

{

x.dispO; cout«\y«endl; } }；

void main() {

Y object 1;

Y object2(l,2,3)； object l.disp(); object2.disp(); }

6. #include

class Sample

{ private: int x; int y; public:

void get(int a,int b) { J

x=a;

y=b；

}

,,,,

void disp(){cout«x=\"«x«,y=,,« «endl;} }； 一 void main() {

Sample objectl,object2; object l.get(l 0,20); object 1 .disp();

object2=objectl; object2.disp(); Sample object3(object2); object? JispO; }

7 •

# include class Class_for_el2 { public: int a; int b;

void show()

{ cout«\"a=H«a«endl; cout«\"b=n«b«endl;

} }；

void main() {

int Class_for_el2::*p; Class_for_el2 obj; p二&Class_for_e 12::a; obj.*p=100; p=&Class_for_e 12::b; obj.*p=200; obj.show(); }

8 ・

#include class ClassOne {public:

ClassOne();

ClassOne(int value); 〜ClassOne(); void Print(); private: int i; }；

class ClassTwo { public:

ClassTwo();

ClassTwo(int value);

〜ClassTwo();

void Print(); private:

int i;

}；

ClassOne: :ClassOne()

{

n

coul«Constructor of ClassOne!n«endl; i=0;

}

ClassOne::ClassOne(int value) {

n

coul«Constructor of ClassOne!n«endl; i=value;

}

ClassOne::〜ClassOne() {

cout«\"Desturctor of ClassOne!\"«endl; }

void ClassOne::Print() {

cout«\"The i of ClassOne isr'«i«endl; }

ClassTwo::ClassTwo() {

cout«\"Constructor of ClassTwo!\"«endl; i=0; }

ClassTwo::ClassTwo(int value) {

cout«\"Constructor of ClassTwo!\"«endl; i=value; }

ClassTwo::-ClassTwo() {

n

cout«Desturctor of ClassT wo! H«endl;

}

void ClassTwo::Print() {

n

cout«The i of ClassTwo isn«i«endl;

int main()

ClassTwo classobj(lO); classobj.PrintO; return 0;

9.

# include class Myclass {

public:

Myclass(); 〜Myclass(); void setValue(int val); private:

int i;

}；

Myclass: :Myclass() {

i=0;

cout«\"This is a constructor! i=\"«i«endl; } Myclass::〜Myclass() {

cout«\"This is a destructor! i=u«i«endl; }

void Myclass:: setValue(int val) {

i=val; cout«\"i=\"«i«endl; }

int main() {

int k;

Myclass my[3],*p; P=my;

for(k=0;k<3 ;k++) {

p->set V alue(k+1); P++； }

return 0; }

#include

class Class_for_el5

{

public:

Class_for_el5(int m); -Class_for_el5();

void SetValue(int val); private:

int i;

}；

Class_for_e 15::Class_for_e 15(int m) {

n

i=rn; cout«This is a constructor! i=n«i«endl;

}

Class_for_e 15::-Class_for_e 15() {

n

cout«This is a destructor! i=H«i«cndl;

}

void Class_for_e 15::SetValue(int val) {

i=val; cout«\"i=\"«i«endl;

}

int main() {

Class_for_el5 *my[3]; int k;

for(k=0;kv3;k++)

my[k]=new Class_for_e 15(k+1); for(k=0;kv3;k++)

delete my [kJ;

}

11 • #include

class Sample

{

private:

int x;

static int y; public:

Sample(int a)

\\—cl,

y++;

nl

void print(){cout«x=n«x«\\y=ll«y«endl;} }; 一 int Sample::y=5; void main()

{

Sample si(20); Sample s2(30); sl.print(); s2.print();

12 •

}

#include

class CSample

{

private:

int n;

static int k; public:

CSample(int i) {n=i;k++;} void disp();

};

void CSample::disp() {

M

cout«n=\"«n«\n«k«endl;

}

int CSample::k=0;

void main()

{

CSample a(10),b(20),c(30); a. dispO; b. disp(); c. dispO;