面向对象程序设计资料整理长大.doc

面向对象程序设计复习资料
(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.float
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. free( ) 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. fstream.h C.stdio.h D. stdlib.h
29． 下面关于类模板叙述不正确的是 ( )
Ａ.声明类模板”; ”号结束　　　　 Ｂ.不能重载运算符
Ｃ.能够使用友元函数　　　　　 　 Ｄ.能使用虚函数
30．系统不会为类自动建立什么成员函数 ( )
A．默认构造函数 B．默认析构函数 C．默认虚析构函数 D．默认赋值运算赋
二、 填空题:
1．函数 int * func(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．函数func(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 < <endl;

2．找出以下程序中的错误,并说明原因。
# include < iostream.h>
class base
{
int m, n;
public:
base(int a, int b): m(b), n(a)
void Disp( ){cout<<m<<＂, ＂<<n<<endl; }
};

3．找出以下程序中的错误, 并说明错在何处。
# include <iostream.h>
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 <iostream.h >
void main()
{
int *p , a[5] = {1,2,3,4,5} ;
p =&a[5];
cout < <p < < endl;
}
5．找出类定义中的错误并说明理由。
class base
｛
private:
int x, y;
void setxy(int a, int b)｝｛x=a; y=b｝
public:
void show (base * p)
｛cout<<p->x<<”, ”<<p->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 <iostream.h>
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<<endl;
cout<<*pa<<endl;
delete pb;
}

9．找出下面程序中的错误并给出正确的运行结果。
# include <iostream.h>
class base
｛
private:
int x, y;
public:
void setxy(int a, int b) ｛x=a; =b｝
void show(base ＆b)
｛cout<<b.x<<”, ”<<b.y; ｝
｝;
void main( )
｛
base a;
a.setxy(28, 59)
a.show(＆a);
｝
10．下面是使用类Ａ的主函数, 改正其中的错误。
　　　void main( )
{
A p[2]={ (new A), ( new A) }
for( int i=0; i<2; i+ +)
delete A[i];
｝

11．指出下面程序段中的错误。
const int R= 15;
R=3 *R;
int m =50-R;
cout << m < <endl;

12．下面是使用类Ａ的主函数, 改正其中的错误。
　　　void main( )
{
A p[2]={ (new A), ( new A) }
for( int i=0; i<2; i+ +)
delete A[i];
｝
13．仔细阅读下面程序, 其中有一个成员函数定义不正确, 找出并改正错误。
#include <iostream.h>
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．在下面程序中的下划线处填上内联fun函数的原型声明、 返回类型和调和调用语句。
# include<iostream.h>

void main()
﹛
int a=5;
int b=8;

cout<<a<<endl;
cout<<b<endl;
﹜
inline void fun(int& m,int& n)
﹛
int temp=m;
m=m+n;
n=temp-n;
﹜

2．在下面的主程序中只允许显式地使用一次set成员函数, 在下划线处填上适当的程序, 使程序的输出为: 589589
#include<iostream.h>
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 <iostream.h>
void main()
{
cout.setf(ios::scientific | ios::left | ios::showpos);
cout << －25.89F << endl;
cout<< 25.89f << endl;
}

4．使用内联函数重新定义下面求两个整数最小值的宏定义。
#define MAX(a,b)(a<b? a:b)
解:
inline int MAX(int a, int b)
{
return a<b?a:b;
}

5．下面是类test的两个成员函数的定义, 根据它们的定义, 给出最小的类声明形式, 其
中数据成员为私有, 成员函数使用原型声明。
test::tese(int a,int b)
{m=a;n=b}
void test::show()
{cout<<m<<”,”<<n<<endl;}

6．给出类声明中的转换函数的定义。
class number{
private:
int val;
public:
number( int i ) { val =i;}
operator int();
};

7．完成一面程序, 使其输出”56 56”, 并在退出运行时正确释放分配给指针的存储空间。所给程序如下:
# include <iostream.h>
void main ( )
{
int *a=int new(56);
int
cout<<*a<<＂＂<<*p<<endl;

}

8．在下面程序的下划线处填上正确的语句, 使类的数据成员i的值为20, 输出为35。
#include <iostream.h>
class sum
{
public:

void disp( ){cout <<i+j<<endl;}
};
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”<<b<<endl;}
};
void main()
{ A a,*pa;
display(__ _ _ );
B b;
b.display(B place );
pa=_ ____;
pa->display(B place );
}

11．完成一面程序, 使其输出”56 56”, 并在退出运行时正确释放分配给指针的存储空间。所给程序如下:
# include <iostream.h>
void main ( )
{
int *a=int new(56);
int
cout<<*a<<＂＂<<*p<<endl;

}

12．在下面程序的下划线处填上正确的语句, 使类的数据成员i的值为20, 输出为35。
#include <iostream.h>
class sum
{
public:

void disp( ){cout <<i+j<<endl;}
};
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=n-150;
cout<<” ”<<m;
}

2．分析下面程序的输出结果。
# include<iostream.h>
class base
{
char c;
public:
void change(char a)
{c=a+32; cout<<c<<endl; }
};
void main( )
{
base a;
a.change(′A′);
a.change(′B′);
}

3．分析下面程序的输出.
# include<iostream.h>
class base
{
int num;
public:
base(int x)
{num=x; cout<<”Initializing num=”<<num<<endl;}
};
void main()
{
cout<<”Entering main” <<endl;
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 < <setflii(‘a’ ) < < setw (10 ):
cour < <256 < < ”OK” < < endl:
}

5．分析下面程序输出结果。
#include <iostream.h>
void f ( )
{
static int n=25;
n -- ;
cout < < ”n=”<<n<<” ”;
}
void main ( )
{for (int i=0; i<= 2 ; i+ +)
f ( );
}

6．分析下面程序的输出结果
class base{
public:
int x;
void setx(int a){x=a;}
int getx( ){return x;}
};
# include <iostream.h>
void main( )
{
base a={125},b;
b=a;
cout<<a.x<<endl;
cout<<b.getx( )<<endl;
}

7．分析下面程序的输出
# include<iostream.h>
class base {
private:
int a;
public:
~ base( ) { cout<<＂析构…＂<<a<< endl ; }
base (int a=0) : a(a)
{ cout <<＂初始化．．．＂<<a<<endl; }
} ;
void main( )
{
base a(8),b;
}

8．分析下面程序的输出结果。
# include < iostream.h>
# include < iomanip.h >
Viod main ( )
{
Cout <<setfill ( ”a” )
< <setw ( 0 ) < < 15 < < endl
< <setw ( 1 ) < < 15 < < endl
< <setw ( 4 ) < < 15 < < endl:
Cout < < setw ( 8 ) < <setfill ( ”a”) < < endl:
Cout< < setiosfiags (ios: : right )
< < setw( 4 )< < 1
< < setw( 4 )< < 2 < < endl:
Cout< < setiosfiags (ios: : left )
< < setw( 4 )< < 1
< < setw( 4 )< < 2 < < endl:
}

9．分析下面程序的输出结果。
#include<iostream.h>
class base
{
Private:
int x,y;
public:
void setxy(int a,int b){x=a;y=b;}
void show(base *p)
{cout<<p->x<<”,”<<p->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 < <endl;
cout < < a[0] < < endl;
cout<<x<<endl;

}

11．分析下面程序的输出结果。
#include<iostream.h>
class base
{
Private:
int x,y;
public:
void setxy(int a,int b){x=a;y=b;}
void show(base *p)
{cout<<p->x<<”,”<<p->y;}
};
void main()
{
base a;
a．setxy(25, 39)
a．show(＆a);
｝

12．分析下面程序的输出结果。
# include <iostream.h>
class A
{
int a;
pubic:
A(int a=0):a(a){ cout<<a<<endl;}
void show(){cout<<a<<endl;}
};
class B{
A al;
int b
public:
B(int m, int n):al(m),b(n){}
Void show(){al.show();cout<<b<<endl;}
};
void main()
{
B b(256.285),c(b);
c.show()
}

13．分析程序功能并给出输出结果。
# include < iostream .h >
# include < fstream .h >
Viod main ( void )
{
Fstream fin,fout;
Fout.open(”my.txt”,ios::out);
If(! fout.is_open())
Retnrn;
For(int i=0;i<=10;i=i+2)
Fout<<”This is line”<<i+1<<endl;
Fout.close();
Fin.open(”my.txt”ios::in);
If(! Fin.is_open())
Return;
Char str[100];
While(! Fin.eof()){
Fin.getline(str,100);
Cout<<str<<endl;
}
Fin.close();
}

14．分析下面程序的输出结果。
# include <iostream.h>
class A
{
int a;
pubic:
A(int a=0):a(a){cout<<a<<endl;}
A(A&t){a=t.a;cout<<a<<endl;}
};
class B{
A al;
Int b;
public:
B(int m,int n)Lm),b(n){}
B(B&t):al(t.al){b=t.b;}
Void show(){al.show();cout<<b<<endl;}
};
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=n-100;
cout<<” ”<<m;
}

16．分析下面程序的输出结果。
#include<iostream.h>
class base
{
Private:
int x,y;
public:
void setxy(int a,int b){x=a;y=b;}
void show(base *p)
{cout<<p->x<<”,”<<p->y;}
};
void main()
{
base a;
a．setxy(25, 39)
a．show(＆a);
｝

17．分析程序功能。
# include <iomanip.h>
Void main()
{
For(int i=0;i<10;i++)
Cout<<endl<<setw(10-i)<<’*’<<setw(10)<<’*’;
}

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

# include <iostream.h>
class A
{
protected
int m
public:
void Disp(){c