02328面向对象程序设计资料整理(1004长大)

面向对象程序设计复习资料

(2328)

一、单项选择题

1．假设P是指针，声明指针s引用指针p正确方法是（）

A．int* s&=p B．int &*s=p C．int *&s=p D．int s* &=p

2．在C+ +中，可以为类的所有成员共享的是（）

A、枚举成员

B、公有数据成员

C、私有函数成员

D、公有函数成员

3．C+ +中，下列哪个关键字不能提供封装。（）

A、struct

B、union

C、class

D、case

4．下而关于类的复制构造函数的说法正确的是（）

A.一个类只能有一个复制构造函数

B.可以为void类型

C.不能有返回类型

D.不能使用缺省参数

5．下面叙述正确的是：（）

A.派生类不可以使用私有派生

B.保护派生时，基类的保护成员在派生类中是公有的

C.对基类成员的访问可以允许两义性

D.赋值兼容规则也适用于多重继承的组合

6．定义虚函数使用关键字（）

A．：： B.virtual C.& D.->

7．在下面几项中，运算符在C++中能被重载的是（）

A .= B.? : C.sizeof D. : :

A．结构B．类C．继承D．引用

8．在执行下面程序语句之后，num的值为（）

int num = 500;

int& ref= num;

ref = = ref -50;

A．450 B．500 C．-50 D．无法确定

9．所有在函数外面定义的变量，连同形式参数，都属于（）

A、局部变量

B、全局变量

C、静态变量

D、寄存器变量

10．面向对象的程序中，哪项不是对象的特点。（）

A、多态性

B、抽象性和封装性

C、中断

D、继承性

11．下面在半初始化说法正确的是（）

A.初始化列表可以初始化任何类

B.初始化列表也也可以初始化具有私有成员的类

C.初始化列表只能初始化公有数据成员

D.初始化列表可以初始化所有数据成员

12．产生编译时的多态性的必要条件是使用（）

A．静态成员 B.友元函数 C.重载成员函数D.虚函数

13．operator经常和C++的一个运算符连用,构成一个运算符函数名.运算符函数的返回类型不能是（）

A.void

B.char

C.int

D.f loat

14．下面是对C++运算符的叙述，正确的叙述是（）

A．只有类运算符 B.只有友元运算符

C．同时具有类运算符和友元运算符D.同一个运算符只能重载一次

15．在面向对象的设计中,一切都是围绕着什么展开的（）

A．类B．结构C．数据类型D．对象

16．下面哪项不能算是面向对象程序设计所具有的显著特点（）

A.封装

B.继承

C.抽象

D.递归

17．下面选项中哪一项不是结构和类的共同特性（）

A．对象可以用作数组的元素 B.在缺省情况下，成员是私有的

C．对象之间可以相互赋值 D.可以说明指向对象的指针和引用

18．下面有关类性质说法错误的是（）

A.一个类可以有多个构造函数,但只有一个析构函数

B.析构函数和构造函数都不能有返回类型

C.不可以给析构函数指定参数

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

19．下面叙述不正确的是（）

A.成员的访问能力取决于派生方式

B.基类的私有成员在公有派生类中不可访问

C.对象可以访问所有成员

D.公有基类成员在保护派生中保护的

20．成为抽象类的一个条件是这个类（）

A．至少有一个纯虚函数 B.至少有一个虚函数

C．只含有一个纯虚函数 D.只含有一个虚函数

21．下列叙述正确的是（）

A．有1个运算符不能被重载 B.有2个运算符不能被重载

C．有3个运算符不能被重载 D.有4个运算符不能被重载

22．在以下选项中，不属于模板特点的选项是（）

A．处理数据时，处理的是不同类型的相同操作

B．声明不需要给出数据类型

C．对于相同的数据类型产生不同的实例

D.对于不同的数据类型能够产生不同的实例

23．通过什么建立类树（）

A．类B．虚函数C．多重继承D．单一继承

24．C++使用新的分配动态内存的函数是（）

A . malloc ( ) B. f ree( ) C. delete D. new

25．以下关于C+ +对象特点叙述不正确的是（）

A、对象可以进行四则运算 C、对象可以用作数组的元素

C、对象可以用作函数参数

D、对象之间可以相互赋值

26．有关复制构造函数说法错误的是（）

A.复制构造函数不能使用初始化列表

B. 复制构造函数不能有返回值

C. 复制构造函数名与类名相同并可以有多个复制构造函数

D. 复制构造函数的参数可以为引用对象

27．对友元函数描述正确的是（）

A.一个类的友元函数是该类的一个特殊成员函数

B.一个类的友元函数可以访问类的所有数据成员

C.友元函数只允许访问该类对象的私有成员

D.友元函数只允许访问该类的公有成员

28．进行文件操作时需要包含的头问家是（）

A．iostream.h B. f stream.h C.stdio.h D. stdlib.h

29．下面关于类模板叙述不正确的是（）

Ａ.声明类模板“；”号结束Ｂ.不能重载运算符

Ｃ.可以使用友元函数Ｄ.能使用虚函数

30．系统不会为类自动建立什么成员函数（）

A．默认构造函数B．默认析构函数C．默认虚析构函数D．默认赋值运算赋二、填空题：

1．函数int * f unc(void)的返回类型是__ _ __.

2．C+ +中，关键字用作联合.

3．关键字virtual可以用来声明类.

4．抽象类至少要含有一个,这种函数属于虚函数

5．成员函数“void print( )const;”是类的函数，它只能被const对象调用。

6．声明double的转换函数是。

7．模板分为模板和类模板。

8．类群是由一些彼此互不相关的组成。

9．类的作用于限定符是。

10．.Base(Base&)是类Base的_ __函数的原型声明,它的等效形式为Base(const Base&)。

11．要想取消动态联编,可以使用,它的另一个基本用途是避免两义性.

12．声明double的转换函数是。

13．根据类对其成员的要求，可把类分为模板和无约束模板。

14．在面向对象程序设计时，函数一定既提供了接口也提供了实现。

15．函数f unc(int &a)里面使用return；语句，则函数的返回值类型为_ _.

16．一般使用类中的函数供类内部的成员函数使用，可以实现更好的封装性。

17．成员名限定的符号是_ _,它可以在引用成员时避免两义性.

18．对类的构造函数而言,析构函数可以为虚函数, 不可以为虚函数.

19．指向类成员的指针引入了新的运算符和->*.

20．使用友元重载提取符函数时，它的第2个参数必需使用形式。

21．一个模板声明可以列出多个参数，多个参数之间必须使用隔开。

20．设计类的基本原则应该是。

22．语句int * x=new int(58);使*x .

23．如果要为其他对象提供相互作用的接口，可以通时函数实现。

24．空类Empty的声明形式为。

25．只有继承的情况下，基类的派生类之间才有赋值兼容性规则。

26．产生多态性要求类之间的继承关系满足。

27．使用友元重载提取符函数时，它的第2个参数必需使用形式。

28．类群是由一些彼此互不相关的组成。

三、改错题

1．指出下面程序段中的错误。

const int R= 15;

R=3 *R;

int m =50-R;

cout << m <

2．找出以下程序中的错误,并说明原因。

# include < iostream.h>

class base

{

int m, n；

public：

base(int a, int b)：m(b)，n(a)

void Disp( ){cout<

}；

3．找出以下程序中的错误，并说明错在何处。

# include

class base

{

int m;

public:

base(int a):m(a){};

int Getx(){retum m;}

};

class derived : private base

{

int n;

public:

derived(int a, int b):m(a){n=b;};

};

4．改正下面程序段中的错误，使其能正确输出数组第五项的内容。

# include

void main()

{

int *p , a[5] = {1,2,3,4,5} ;

p =&a[5];

cout <

}

5．找出类定义中的错误并说明理由。

class base

｛

private：

int x，y；

void setxy(int a，int b)｝｛x=a；y=b｝

public：

void show (base * p)

｛cout<x<<”，”<y；

｝

6．找出以下程序中的错误,并说明原因。

＃include < iosteream．h>

class base

{

int p；

public：

base(int a){p=new int(a)；}

int Getx( ){return m；}

~ base( ){delete p}

}；

7．仔细阅读下面程序，其中有一个成员函数定义不正确，找出并改正错误。

#include

class A

{

int a;

public:

A(int m):a(m){}

A(A&t):a(t){}

};

class B:public A

{

int b;

public:

B(int m, int n){a=m;b=n;}

};

8．指出下面程序中的错误。

# include < iostream.h>

void main( )

{

int * pa;

int * &pb= pa;

int x = 386;

pb =&x;

cout<<*pb<

cout<<*pa<

delete pb;

}

9．找出下面程序中的错误并给出正确的运行结果。

# include

class base

｛

private：

int x，y；

public：

void setxy(int a，int b) ｛x=a；=b｝

void show(base ＆b)

｛cout<

｝；

void main( )

｛

base a；

a.setxy(28，59)

a.show(＆a);

｝

10．下面是使用类Ａ的主函数，改正其中的错误。

void main( )

{

A p[2]={ (new A)，（new A）}

f or( int i=0；i<2；i+ +)

delete A[i]；

｝

11．指出下面程序段中的错误。

const int R= 15;

R=3 *R;

int m =50-R;

cout << m <

12．下面是使用类Ａ的主函数，改正其中的错误。

void main( )

{

A p[2]={ (new A)，（new A）}

f or( int i=0；i<2；i+ +)

delete A[i]；

｝

13．仔细阅读下面程序，其中有一个成员函数定义不正确，找出并改正错误。

#include

class A

{

int a;

public:

A(int m):a(m){}

A(A&t):a(t){}

};

class B:public A{

int b;

public:

B(int m, int n){a=m;b=n;}

};

14．给出类声明中的转换函数的定义。

Class number{

private:

int val;

public:

number( int I ) { val =I;}

operator int();

};

四、完成程序题

1．在下面程序中的下划线处填上内联f un函数的原型声明、返回类型和调和调用语句。

# include

void main()

﹛

int a=5;

int b=8;

cout<

cout<

﹜

inline void f un(int& m,int& n)

﹛

int temp=m;

m=m+n;

n=temp-n;

﹜

2．在下面的主程序中只允许显式地使用一次set成员函数，在下划线处填上适当的程序，使程序的输出为：589589 #include

class base

{

private:

int x;

public:

void set(int a){x=a;}

void show()

{

______ ______}

};

void main()

{

base a,b;

a.set(589);

a.show();

__

b.show;

}

3．完成下面程序，使其输出为：

－2.589000e +001

＋2.589000e +001

程序如下：

# include

void main()

{

cout.setf(ios::scientif ic | ios::lef t | ios::showpos);

cout <<－25.89F << endl;

cout<< 25.89f << endl;

}

4．使用内联函数重新定义下面求两个整数最小值的宏定义。

#def ine MAX(a,b)(a

解：

inline int MAX(int a，int b)

{

return a

}

5．下面是类test的两个成员函数的定义，根据它们的定义，给出最小的类声明形式，其

中数据成员为私有，成员函数使用原型声明。

test::tese(int a,int b)

{m=a;n=b}

void test::show()

{cout<

6．给出类声明中的转换函数的定义。

class number{

private:

int val;

public:

number( int i ) { val =i;}

operator int();

};

7．完成一面程序，使其输出“56 56”，并在退出运行时正确释放分配给指针的存储空间。所给程序如下：# include

void main ( )

{

int *a=int new(56);

int

cout<<*a<<＂＂<<*p<

}

8．在下面程序的下划线处填上正确的语句，使类的数据成员i的值为20，输出为35。

#include

class sum

{

public:

void disp( ){cout <

};

void main( )

{

Sum a= ；

a.disp( );

}

9．根据下面的主程序，补上所缺类说明文件的最小形式（成员函数使用原型声明）。

# include(iostream h)

# include “base.h”

void main()

{

base obj(1,2,3);

base obj2(obj1);

}

10．在主函中的下划线处填上正确的语句使程序输出并说明理由。

A place.

Here is B place .

Here is B place.

程序如下：

class B: public A

{

public:

void display(char*b){cout<<”Here is”<

};

void main()

{ A a,*pa;

display(__ _ _ );

B b;

b.display(B place );

pa=_ ____;

pa->display(B place );

}

11．完成一面程序，使其输出“56 56”，并在退出运行时正确释放分配给指针的存储空间。所给程序如下：# include

void main ( )

{

int *a=int new(56);

int

cout<<*a<<＂＂<<*p<

}

12．在下面程序的下划线处填上正确的语句，使类的数据成员i的值为20，输出为35。

#include

class sum

{

public:

void disp( ){cout <

};

void main( )

{

Sum a= ；

a.disp( );

}

13．给出类声明中的转换函数的定义。

Class number{

private:

int val;

pnblic:

number( int I ) { val =I;}

operator int();

};

五、程序分析题

1．# include < iostream.h >

void main ()

{

int n=333;

int&m =n;

cout<< m;

m=m+150;

cout<<””<

n=n-150;

cout<<””<

}

2．分析下面程序的输出结果。

# include

class base

{

char c；

public：

void change(char a)

{c=a+32；cout<

}；

void main( )

{

base a；

a.change(′A′)；

a.ch ange(′B′)；

}

3．分析下面程序的输出.

# include

class base

{

int num;

public:

base(int x)

{num=x; cout<<”Initializing num=”<

};

void main()

{

cout<<”Entering main” <

cout<<”Exiting main<< endl;

}

static base a(548);

4．分析下面程序的输出结果。

# include < iostream.h >

# include < iomanip.h >

void main( )

{

cout < < oct < < 15 < < endl:

cout < < hex < <15 < < endl:

cout <

cour < <256 < < “OK” < < endl:

}

5．分析下面程序输出结果。

#include

void f ( )

{

static int n=25;

n -- ;

cout < < ”n=”<

}

void main ()

{f or (int i=0; i<= 2 ; i+ +)

f ( );

}

6．分析下面程序的输出结果

class base{

public:

int x;

void setx(int a){x=a;}

int getx( ){return x;}

};

# include

void main( )

{

base a={125},b;

b=a;

cout<

cout<

}

7．分析下面程序的输出

# include

class base {

private：

int a；

public：

~ base( ){ cout<<＂析构…＂<

base (int a=0)：a(a)

{ cout <<＂初始化．．．＂<

void main( )

{

base a(8),b；

}

8．分析下面程序的输出结果。

# include < iostream.h>

# include < iomanip.h >

V iod main ( )

{

Cout <

<

<

<

Cout < < setw ( 8 ) <

Cout< < setiosf iags (ios: : right )

< < setw( 4 )< < 1

< < setw( 4 )< < 2 < < endl:

Cout< < setiosf iags (ios: : lef t )

< < setw( 4 )< < 1

< < setw( 4 )< < 2 < < endl:

}

9．分析下面程序的输出结果。

#include

class base

{

Private:

int x,y;

public:

void setxy(int a,int b){x=a;y=b;}

void show(base *p)

{cout<x<<”,”<y;}

};

void main()

{

base a;}

a．setxy(25，39)

b．show(＆a)；

｝

10．分析下面程序的输出结果。

#include < iostream.h>

void main( )

{

int x = 56;

int *a;

int *&p=a;

p=new int(x +2);

cout < <*p <

cout < < a[0] < < endl;

cout<

}

11．分析下面程序的输出结果。

#include

class base

{

Private:

int x,y;

public:

void setxy(int a,int b){x=a;y=b;}

void show(base *p)

{cout<x<<”,”<y;}

};

void main()

{

base a;

a．setxy(25，39)

a．show(＆a)；

｝

12．分析下面程序的输出结果。

# include

class A

{

int a;

pubic:

A(int a=0):a(a){ cout<

void show(){cout<

};

class B{

A al;

int b

public:

B(int m, int n):al(m),b(n){}

Void show(){al.show();cout<

};

void main()

{

B b(256.285),c(b);

c.show()

}

13．分析程序功能并给出输出结果。

# include < iostream .h >

# include < f stream .h >

V iod main ( void )

{

Fstream f in,f out;

Fout.open(“my.txt”,ios::out);

If(! f out.is_open())

Retnrn;

For(int i=0;i<=10;i=i+2)

Fout<<”This is line”<

Fout.close();

Fin.open(”my.txt”ios::in);

If(! Fin.is_open())

Return;

Char str[100];

While(! Fin.eof()){

Fin.getline(str,100);

Cout<

}

Fin.close();

}

14．分析下面程序的输出结果。

# include

class A

{

int a;

pubic:

A(int a=0):a(a){cout<

A(A&t){a=t.a;cout<

};

class B{

A al;

Int b;

public:

B(int m,int n) m),b(n){}

B(B&t):al(t.al){b=t.b;}

V oid show(){al.show();cout<

void main()

{

B b(256.285);

B c(b);

c.show();

}

15．# include < iostream.h >

void main ()

{

int n=333;

int&m =n;

cout<< m;

m=m+150;

cout<<””<

n=n-100;

cout<<””<

}

16．分析下面程序的输出结果。

#include

class base

{

Private:

int x,y;

public:

void setxy(int a,int b){x=a;y=b;}

void show(base *p)

{cout<x<<”,”<y;}

};

void main()

{

base a;

a．setxy(25，39)

a．show(＆a)；

｝

17．分析程序功能。

# include

Void main()

{

For(int i=0;i<10;i++)

Cout<

18．分析下面程序的输出结果。

# include

class A

{

protected

int m

public:

void Disp(){cout<

};

class B

{

protectected

int n;

public:

void Disp(){cout<

};

class c :public A，public B

{

public:

void Set(int x ，int y){m=x; n=y;}

void Disp( ) { cout<

};

void main()

{

C c;

c.Set(4656,8676);

c.Disp();

c.A::Ddisp();

c.B::Disp();