目录
C＋＋面向对象程序设计模拟测试题 (2)
计算机技术与软件水平考试面向对象程序设计试题（1） (39)
计算机技术与软件水平考试面向对象程序设计试题（2） (41)
计算机技术与软件水平考试面向对象程序设计试题（3） (47)
计算机技术与软件水平考试面向对象程序设计试题（4） (54)
计算机技术与软件水平考试面向对象程序设计试题（5） (58)
计算机技术与软件水平考试面向对象程序设计试题（6） (64)
面向对象程序设计试题(6)参考答案 (67)
计算机技术与软件水平考试面向对象程序设计试题（7） (69)
面向对象程序设计试题(7)参考答案 (74)
2008年全国计算机及应用面向对象程序设计试卷 (75)
2009高等教育自学考试面向对象程序设计试题 (79)
《面向对象程序设计》期末考试（开）试题及答案 (86)
计科开放本科网络专业面向对象程序设计试题 (94)
【面向对象程序设计】全国2011年试题及答案 (101)
【面向对象程序设计】全国2010年试题及答案 (110)
【面向对象程序设计】2010年试题及答案 (118)
C＋＋面向对象程序设计模拟测试题
一.选择填空
1.下面关于对象概念的描述中，( A )是错误的。
A.对象就是C语言中的结构变量;
B.对象代表着正在创建的系统中的一个实体;
C.对象是一个状态和操作（或方法）的封装体;
D.对象之间的信息传递是通过消息进行的
2.下面关于类概念的描述中，( D )是错误的。
A.类是抽象数据类型的实现:
B.类是具有共同行为的若干对象的统一描述体;
C.类是创建对象的样板:
D.类就是C语言中的结构类型
3.在16位机中，int 型字宽为( A )字节。
A.2;
B.4;
C.6;
D.8
4.类型修饰符unsigned 修饰( D )类型是错误的。
A.char;
B.int ;
C.long int ;
D.float
5.在int a[5]={1,3,5};中，数组元素a[1]的值是( C )。
A.1;
B.0;
C.3;
D.2
6.在int b[][3]={{1},{3,2},{4,5,6},{0}};中b[2][2]的值是( C )。
A.0;
B.5;
C.6;
D.2
7.下列表达式中，( C )是非法的。
已知:int a=5;float b=5.5;
A.a%3+b;
B.b*b&&++a;
C.（.a>b）+(int (b)%2);
D.―――a+b
8.下列表达式中，( D )是合法的。
已知:doublem=3.2;int n=3;
A.m<<2;
B.（m+n）|n;
C.！m*=n;
D.m=5,n=3.1,m+n
9.下列for循环的次数为( B )。
for(int i=0,x=0;!x&&i<=5;i++)
A.5;
B.6;
C.1;
D.无限
10.下列while循环的次数是( A )。
while(int i=0)i――;
A.0;
B.1;
C.5;
D.无限
11.下述关于break语句的描述中，( C )是不正确的。
A.break语句可用于循环体内，它将退出该重循环;
B.break语句可用于开关语句中，它将退出开关语句;
C.break语句可用于if体内，它将退出if语句;
D.break语句在一个循环体内可以出现多次。
12.下列关于开关语句的描述中，( A )是正确的。
A.开关语句中default子句可以没有，也可有一个;
B.开关语句中每个语句序列中必须有break语句;
C.开关语句中default子句只能放在最后;
D.开关语句中case子句后面的表达式可以是整型表达式。
13.在一个被调用函数中，关于return 语句使用的描述，( D )是错误的。
A.被调用函数中可以不用return 语句;
B.被调用函数中可以使用多个return 语句;
C.被调用函数中，如果有返回值，就一定要有return 语句;
D.被调用函数中，一个return 语句可返回多个值给调用函数。
14.下列的( D )是引用调用。
A.形参是指针，实参是地址值;
B.形参和实参都是变量;
C.形参是数组名，实参是数组名;
D.形参是引用，实参是变量。
15.在传值调用中，要求( C )。
A.形参和实参类型任意，个数相等;
B.实参和形参类型都完全一致，个数相等;
C.实参和形参对应的类型一致，个数相等;
D.实参和形参对应的类型一致，个数任意。
16.在C＋＋中，关于下列设置参数默认值的描述中，( C )是正确的。
A.不允许设置参数的默认值;
B.设置参数默认值只能在定义函数时设置;
C.设置参数默认值时，应该是先设置右边的再设置左边的;
D.设置参数默认值时，应该全部参数都设置。
17.重载函数在调用时选择的依据中，( D )是错误的。
A.参数个数;
B.参数的类型;
C.函数名字;
D.函数的类型
18.采用函数重载的目的在于（D）。
A.实现共享;
B.减少空间;
C.提高速度;
D.使用方便，提高可读性
19.在下列关键字中，用以说明类中公有成员的是( A )。
A.public ;
B.private;
C.protected;
D.friend ;
20.下列的各类函数中，( C )不是类的成员函数。
A.构造函数;B析构函数;C.友元函数;D.拷贝初始化构造函数
21.作用域运算符的功能是( D )。
A.标识作用域的级别的;
B.指出作用域的范围的;
C.给定作用域的大小的;
D.标识某个成员是属于哪个类的。
22.( D )不是构造函数的特征。
A.构造函数的函数名与类名相同;
B.构造函数可以重载;
C.构造函数可以设置缺省参数;
D.构造函数必须指定类型说明。
23.( A )是析构函数的特征。
A.一个类中只能定义一个析构函数;
B.析构函数名与类名不同;
C.析构函数的定义只能在类体内;
D.析构函数可以有一个或多个参数。
24.通常的拷贝初始化构造函数的参数是( C )。
A.某个对象名;
B.某个对象的成员名;
C.某个对象的引用名;
D.某个对象的指针名。
25.关于成员函数特征的下述描述中，( A )是错误的。
A.成员函数一定是内联函数;
B.成员函数可以重载;
C.成员函数可以设置参数的缺省值;
D.成员函数可以是静态的。
26.下述静态数据成员的特征中，( A )是错误的。
A.说明静态数据成员时前边要加修饰符static ;
B.静态数据成员要在类体外进行初始化;
C.引用静态数据成员时，要在静态数据成员名前加＜类名＞和作用域运算符;
D.静态数据成员不是所有对象所共用的。
27.友元的作用( A )。
A.提高访问对象成员的效率;
B.加强类的封装性;
C.实现数据的隐藏性;
D.增加成员函数的种类。
28.已知:类A中一个成员函数说明如下:
void Set(A&a);
其中，A&a的含意是( C )
A.指向类A的指针为a;
B.将a的地址值赋给变量Set;
C.a是类A的对象引用，用来作函数Set( )的形参;
D.变量A与a按位相与作为函数Set（）的参数。
29.下列关于对象数组的描述中，( D )是错误的。
A.对象数组的下标是从0开始的;
B.对象数组的数组名是一个常量指针;
C.对象数组的每个元素是同一个类的对象;
D.对象数组只能赋初值，而不能被赋值。
30.已知:print ( )函数是一个类的常成员函数，它无返回值，下列表示中，( A )是正确的。
A.void print （）const ;
B.const void print （）;
C.void const print ;
D.void print (const );
31.关于new运算符的下列描述中，( D )是错误的。
A.它可以用来动态创建对象和对象数组;
B.使用它创建的对象或对象数组可以使用运算符delete删除;
C.使用它创建对象时要调用构造函数;
D.使用它创建对象数组时必须指定初始值。
32.关于delete运算符的下列描述中，( C )是错误的。
A.它必须用于new返回的指针;
B.它也适用于空指针;
C.对一个指针可以使用多次该运算符;
D.指针名前只用一对方括号符，不管所删除数组的维数。
33.下列说明中，
const char*ptr;
ptr应该是( C )
A.指向字符常量的指针;
B.指向字符的常量指针;
C.指向字符串常量的指针;
D.指向字符串的常量指针;
34.下列定义中，( B )是定义指向数组的指针p。
A.int *p[5];
B.int (*p)[5];
C.(int *)p[5];
D.int *p[];
35.下列对派生类的描述中，( D )是错误的。
A.一个派生类可以作另一个派生类的基类;
B.派生类至少有一个基类;
C.派生类的成员除了它自己的成员外，还包含了它的基类的成员;
D.派生类中继承的基类成员的访问权限到派生类保持不变。
36.派生类的对象对它的基类成员中( A )是可以访问的。
A.公有继承的公有成员;
B.公有继承的私有成员;
C.公有继承的保护成员;
D.私有继承的公有成员;
37.派生类的构造函数的成员初始化列中，不能包含( C )。
A.基类的构造函数;
B.派生类中子对象的初始化;
C.基类的子对象初始化;
D.派生类中一般数据成员的初始化。
38.关于多继承二义性的描述中，( C )是错误的。
A.一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性;
B.解决二义性的最常用的方法是对成员名的限定法;
C.基类和派生中同时出现的同名函数，也存在二义性问题;
D.一个派生类是从两个基类派生来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，也可能
出现二义性。
39.设置虚基类的目的是( B )。
A.简化程序;
B.消除二义性;
C.提高运行效率;
D.减少目标代码。
40.带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数，这样将对虚基类的子对象初始化( D )。
A.与虚基类下面的派生类个数有关;
B.多次;
C.二次;
D.一次。
41.对定义重载函数的下列要求中，( D )是错误的。
A.要求参数的个数不同;
B.要求参数中至少有一个类型不同;
C.要求参数个数相同时，参数类型不同;
D.要求函数的返回值不同。
42.下列函数中，( C )不能重载。
A.成员函数;
B.非成员函数;
C.析构函数;
D.构造函数。
43.下列对重载函数的描述中，( A )是错误的。
A.重载函数中不允许使用缺省参数;
B.重载函数中编译器根据参数表进行选择;
C.不要使用重载函数来描述毫无相干的函数;
D.构造函数重载将会给初始化带来多种方式。
44.关于虚函数的描述中，( C )是正确的。
A.虚函数是一个static 类型的成员函数;
B.虚函数是一个非成员函数;
C.基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数;
D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型。
45.关于纯虚函数和抽象类的描述中，( C )是错误的。
A.纯虚函数是一种特殊的虚函数，它没有具体的实现;
B.抽象类是指具有纯虚函数的类;
C.一个基类说明有纯虚函数，该基类的派生类一定不再是抽象类;
D.抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出。
46.下列描述中，( D )是抽象类的特征。
A.可以说明虚函数;
B.可以进行构造函数重载;
C.可以定义友元函数;
D.不能说明其对象。
47.面向对象程序设计中的数据隐藏指的是( D )
A.输入数据必须输入保密口令
B.数据经过加密处理
C.对象内部数据结构上建有防火墙
D.对象内部数据结构的不可访问性
[解析]输入数据必须输入保密口令和数据经过加密处理都不是面向对象程序设计的特征;对象内部数据结构上也不可能建有防火墙，所以它们都不是面向对象程序设计中所指的数据隐藏。面向对象程序设计系统中的封装单位是对象，对象之间只能通过接口进行信息交流，外部不能对对象中的数据随意地进行访问，这就造成了对象内部数据结构的不可访问性，也使得数据被隐藏在对象中。这就是面向对象程序设计中的数据隐藏所指。
48.下列各项中不符合函数重载必须满足的条件的是( C )
A.有不同的参数个数
B.对应的参数类型不相同
C.A和B必须同时满足
D.A和B只要满足一个即可
[解析]我们知道，在同一个作用域中，要实现函数重载必须满足的条件的是:①有不同的参数个数;或者②对应的参数有不相同的数据类型，即①和②中只要有一个满足就可以了。当然两者都满足更好，但这不是必须的。
49.下列带缺省值参数的函数说明中，正确的说明是( A )
A.int Fun(int x,int y=2,int z=3);
B.int Fun(int x=1,int y,int z=3);
C.int Fun(int x,int y=2,int z);
D.int Fun(int x=1,int y,int z=3);
[解析]在带缺省值参数的函数说明中，正确的说明应该是无缺省值的参数依次排列在参数表的左边，排完无缺省值的参数后，再依次排列带缺省值的参数。从所给出的四个选项来看，只有"int Fun(int x,int y=2,int z=3)"符合这条规定，其它的都不符合。
50.有如下的对类"CSample"的说明，其中( A )是错误的。
class CSample{
A.int a=23;
B.CSample( );
public :
C.CSample(int val);
D.~CSample( );
}
[解析]在下面对类"CSample"说明中，"CSample( )"和"CSample(int val)"是该类重载的构造函数."~CSample( )"是该类的析构函数，这三个语句都是正确的。错误的语句是"int a=23"，因为它违反了在类的声明（不管是引用性声明，还是定义性声明）中都不能以赋值表达式的形式给它的数据成员进行初始化。
51.已知类A中的一个成员函数的说明如下:
void Set(A&a);
则该函数的参数"A&a"的含义是( C )
A.指向A的指针为a
B.将变量a的地址赋给类A
C.类A对象引用a用作函数的形参
D.变量A与a按位与后作函数参数
[解析]因为A是一个类，所以"A&a"表示a是类A的对象，但因为对象a的前缀了符号"&"，则"&a"表示是类A 的对象引用。所以"A&a"的含义是类A对象引用a用作函数的形参。
52.若类A和类B的定义如下:
class A{
public :
int i,j;
void get( );
};
class B:A{
int i,j;
protected:
int k;
public :
void make( );
};
void B::make( ){k=i*j;}
则上述语句中( D )是非法的表达。
A.void get( );
B. int k;
C. void make( );
D.k=i*j;
[解析]对于给定的四项中，前三项都是正确的，只有第四项是错误的。因为，类B是类A的私有派生类（缺省访问类型），所以A中的公类型的数据成员在类B中成为了私有数据成员，但函数"void B::make( )"既然是类B的成员函数，则既可访问类A中的公有数据成员，也能访问类B中的私有数据成员，则表达式"k=i*j;"造成了访问的二义性，即其中的i和j，到底是取自类A呢？还是取自类B呢？
53.下面的主函数体中，( A )是错误的。
class A{
int i;
public :
virtual void fun( )=0;
A(int a){i=a;}
};
class B: public A{
int j;
public :
void fun( ){cout<<"B::fun( )\n";}
B(int b, int c):A(b){j=c;}
};
void main( )
A.{A a(5); }
B.{A*pa; }
C.{B b(7); }
D.{B*pb;}
[解析]在类A中，函数"virtual void fun( )=0"为纯虚函数，因此，类A为抽象类。作为抽象类，它是不能被用来定义具体对象的，而语句"Aa(5);"恰恰是定义抽象类的对象的，所以它是错误的
54.拷贝构造函数的作用是( C )
A.进行数据类型的转换
B.用对象调用成员函数
C.用对象初始化对象
D.用一般类型的数据初始化对象
[解析]进行数据类型的转换和用一般类型的数据初始化对象都是一般构造函数的功能。用对象调用成员函数不用构造函数，只要用"对象名.成员函数名"即可。所以拷贝（复制）构造函数的作用，只能是用对象来初始化对象。
55.下列说法中，正确的说法是( B )
A.所有的运算符都能被重载
B.运算符被重载时，它们的优先级与结合性不会改变
C.当需要时，我们可以自定义一个运算符来进行重载
D.每个运算符都可以被重载成成员函数和友元函数
[解析]当重载运算符时，不是所有的运算符都能被重载，有几个运算符是不能被重载的，如三目运算符'?:','.','*','::'.'#'等;也不是每个运算符都可以被重载成成员函数和友元函数，如运算符'=', '（）', '[]'和'->'都只能被重载成成员函数;无论何时，都不能自定义运算符来进行重载，也即重载只能对已有运算符进行;但是运算符被重载时，它们的优先级与结合性不会改变。
56.下面对结构或类中成员的访问中，不正确的访问是( A )
A.*pointer.salary;（其中pointer为指向类对象的指针）
B.pointer->salary;
C.x=worker.salary;（其中worker为具有类类型的对象）
D.Location &rA=A1;int x=rA.GetX( );（Location为已定义的类，A为对象）
[解析]因pointer为指向类对象的指针，所以"pointer->salary"是正确的访问数据成员的形式;因worker为具有类类型的对象，所以"worker.salary"也是正确的访问数据成员的形式;因Location为已定义的类，A1为对象，所以"Location &rA=A1;int x=rA.GetX( );"表示以对象A1初始化对象引用rA，然后由对象引用rA调用成员函数GetX( )给变量x 赋值，这样的访问成员函数的形式也是正确的;"*pointer.salary;"中，因为运算符'.'的优先级高于运算符'*'的优先级，所以相当于"*（pointer.salary）;"，那正确的形式应该是"*（pointer->salary）;"。故"*point er.salary"是不正确的访问。
57.以下不属于存取权限的是( B )。
A.public
B.static
C.protected
D.private
58.以下叙述中正确的是( D )
A.在C++中数据封装是通过各种类型来实现的
B.在C++中，数据封装可以由struct关键字提供
C.数据封装就是使用结构类型将数据代码连接在一起
D.数据封装以后，仍然可以不通过使用函数就能直接存取数据。
59.以下叙述中不正确的是:( D )
A.对象之间可以相互赋值
B.对象可以用作数组的元素
C.对象可以用作函数参数
D.一个对象不能用作另一个对象的成员
59..以下叙述中正确的是:( B )
A.在定义构造函数时可以指定返回类型
B.在定义析构函数时不能指定参数
C.一个类只能有一个构造函数
D.在一个类可以有多个析构函数
60.假定类A已经定义，对于以A为基类的单一继承类B，以下定义中正确的是:( A )
A.class B:public A{//...};
B.class A:public B{//...};
C.class B:public class A{//...};
D.class A:class Bpublic {//...};
61.下面叙述不正确的是:( D )
A.派生类一般都用公有派生;
B.对基类成员的访问必须是无二义性的;
C.赋值兼容原则也适用于多重继承的组合;
D.基类的公有成员在派生类中仍然是公有的。
62.C++类体系中，不能被派生类继承的有( A )。
A.转换函数.构造函数
B.构造函数.赋值操作函数
C.虚函数.静态成员函数
D.静态成员函数.转换函数
63.以下基类中的成员函数( C )表示纯虚函数
A.virtual void vf(int );
B.void vf(int )=0;
C.virtual void vf( )=0;
D.virtual void vf(int ){}
64.通过一个对象调用虚函数时，C++系统对该调用采用( A )。
A.动态联编
B.静态联编
C.不确定是哪种联编
D.函数重载
65.以下叙述不正确的是( C )
A.转换函数不能带有参数
B.转换函数不能指定返回类型
C.转换函数不能说明为虚函数
D.一个类可以有多个转换函数
66.有如下一个函数模板:
template
T max(T x,T y){return (x>y)?(x):(y);}
当对T传给char*类型时，则可能产生错误结果，所以应该为这个函数模板提供一个( C )
A.模板实例
B.特定模板函数
C.重载函数模板
D.替换模板
67.下面的针对在C++中说明类的各种建议中，( C )是不正确的。
A.尽量使类接口既完整又最紧凑
B.尽量少用const
C.避免对指针和数值类型重载
D.明确禁用无端隐含生成的成员函数
68.一个C++程序至少应包含( B )个函数。
A.0
B.1
C.2
D.3
69.在微型机上，一个unsigned int 型变量在内存中占( B )个字节的存储空间。
A.1
B.2
C.3
D.4
70.下面语句中( C )是非法的。
A.int a=3,b=3;
B.int a,b=3;
C.int a=b=3;
D.int a=3,b
71.下述语句
int x,i=3; x=(i++)+(i++)+(i++);
执行后，x的结果为( A)。
A.9
B.15
C.0
D.12
72.设a=12，n=5，则表达式a%=(n%=2)运算后，a的值为( A ).
A.0
B.1
C.6
D.12
73.设a=3，b=2，c=l，则表达式a=b>c的值为( A ).
A.0
B.1
C.2
D.3
74.C++编译器通常不提供对( C. )的检查。
A.函数原型
B.变量类型
C.数组边界
D.指针类型
75.只有( D )变量才能说明为extern变量。
A.全局变量
B.静态变量
C.寄存器变量
D.自动变量
76.设有两个int 型的指针p1和p2，则p1和p2( B )。
A.可以相加，但不可以相减
B.可以相减，但不可以相加
C.既不能相加，也不能相减
D.可以相加，也可以相减
78.假设已定义了一个字符型指针char*p;欲使指针指向常量串"I love china!",可用语句( B )来完成。
A.*p="I love China!";
B.p="I love China!";
C.*p->'I love China!";
D.p->"I love China!"
79.下面关键字中( D )不可以刚来定义类。
A.class
B.struct
C.union
D.enum
80.一个类的构造函数( D ).
A.可以有不同的返回类犁
B.只能返回整型
C.只能返回void型
D.没有任何返同类刑
81.若类X是类Y的友元类，则下列访问关系中( B )是正确的
A.类X的成员不能访问类Y的私有成员
B.类X的成员可以访问类Y的私有成员
C.类Y的成员可以访问类X的私有成员
D.仅类Y的公共成员可访问类X的私有成员
82.在c++中，一个虚函数是通过关键字( A )放在其基类说明的前面来加以说明的
A.virtual
B.protected
C. operator
D.this
83.在派生关系中，( A )。
A.构造函数和释放函数是不能继承的
B.构造函数可以继承，但释放函数不可以继承
C.构造函数不可以继承，但释放函数可以继承
D.构造函数和释放函数都能继承
84.下列标识符中( A )是正确的。
A.suml23
B.suml23$
C.*pt_123
D.Sum-Count
85.下面语句中( C )是非法的。
A.char x='C';
B.char x='#';
C.char x="*";
D.char x='$';
86.设x=1.2，y=2.0，则语句z=(int )x+y:执行后，x的结果为( D )
A.3.2
B.1
C.3.0
D.1.2
87.设n=l，b=2，则表达式a&b的值为( A )。
A.0
B.1
C.2
D.3
88.全局变量的作用域限于( B )。
A整个程序 B.从定义变量的位置开始到本源文件结束
C.本源文件
D.从定义变量的位置开始到本程序结束
89.在C++语言中，数组可以作为函数的参数，但若用数组名作函数的实参，则将( C )传递到被调函数中去。·
A整个数组 B.数组的第一个元素
C.数组地址
D.整个数组的拷贝
90.发生函数调用时，主调函数将实参传递给被调函数，在被调函数执行过程中，实参的值( C )。
A.是可以改变的
B.是不可改变的
C.可以通过指针间接改变
D.是数组时可以改变
91.语句int *p[n]和int (*p)[n]的含义分别是( B )。
Aint *p[n]定义了一个数组指针，int (*p)[n]定义了一个指针数组
B.int *p[n]定义了一个指针数纽，int (*p)[n]定义了一个数组指针
Lint *p[n]定义了一个数组指针，int (*p)[n]定义了一个数组指针
D.int *p[n]定义了—个指针数组，int (*p)[n]定义了一个指针数组
92.若有如下枚举类型
enumweekday{mon，tue，wed，thu=100，Fri，sat};
则wed的取值为( A)。
A.2
B.3
C.99
D.101
93.只有( D )变量才能说明为register变量。
A全局变量 B.静态变量 C.外部变量 D.自动变量
94.欲使一整型指针p指向一整型变量x,下面哪种方式最好?( C )
A.int x，*p;*p=x;
B.int x,*p;*p=&x;
C.int x;int *p=&x;
D.int x，*p; p=x;
95.在C++中，一个变量一旦用const修饰，便无法对其进行重写，其生存期一直持续到( D )。
A.所在源文件的末尾
B.程序结束
C.编译结束
D.其作用域结束
96.在C++中，当为一个变量定义引用时，引用类型( A )。
A.必须与变量类型一致
B.不一定与变量类型一致
C.也即变量的指针
D.也即变量的地址
97.在用C++定义类时，下面哪个关键字可用以对类成员进行修饰?( C )
A.extern
B.auto
C.static
D.register
98.在C++的类中以成员函数方式重载双目运算符时，只能指定( A )。
A.一个参数
B.两个参数
C.二个参数
D.不能指定参数
99.在C++中，对于基类的protected成员，当以protected方式派生一个新类时。该成员将成为派生类的( B )成员。
A.private
B.protected
C.public
D.非法
100.C++的基类指针可以访问派生类对象，但不能访问派生类对象的( D )成员。
A.private
B.protected
C.public
D.新增
101.在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为( D )指针。
A.对象
B.派生C基类 D.this
102.凡是能用以派生新类，却不能创建自己的对象的类称为( B )。
A.虚基类
B.抽象类C容器类 D.派生类
103.以下不正确的叙述是( D )。
A在C++程序中，逗号运算符的优先级最低。
B.在C++程序中，APH和aph是两个不同的变量。
C.若a和b类型相同，在计算了赋值表达式a=b后b中的值将放人a中，而b中的值不变
D.当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值
104.以下符合C++语法的赋值表达式是( B )。
A.d=9+e+f=d+9
B.d=9+e,f=d+9
C.d=9+e，e++，d+9
D.d=9+e++=d+7
105.设变量a是整型，f是实型，i是双精度型，则表达式10+'a'+i*f值的数据类型是( C. )。
A.int
B.float
C.double
D.不确定
106.已知ch是字符型变量，下面不正确的赋值语句是( A )。
A.ch='a+b';
B.ch='\0';
C.ch='7'+'9';
D.ch=5+9;
107.下面关键字中( D )不可以用来定义类?
A.class
B.struct
C.union
D.enum
108.以下描述中正确的是( D )。
A.for循环只能用于循环次数已经确定的情况
B.for循环是先执行循环体语句，后判断表达式
C.在for循环中，不能用break语句跳出循环体
D.for循环的循环体语句中，可以包含多条语句，但必须用花括号括起来
二.判断下列描述的正确性，对者划√，错者划×。
1.C＋＋引进了引用的概念，对编程带来了很多方便。( √ )
2.C＋＋允许使用友元，但是友元会破坏封装性。( √ )
3.转义序列表示法只能表示字符不能表示数字。( ×)
4.引用是用来给某个变量以别名的变量。对引用的操作，实质上就是对被引用的变量的操作。( √ )
5.在C＋＋中，传址调用将被引用调用所替代。( √ )
6.所有的函数在定义它的程序中都是可见的。( ×)
7.使用关键字class 定义的类中缺省的访问权限是私有（private）的。( √ )
8.作用域运算符（∷）只能用来限定成员函数所属的类。( ×)
9.构造函数和析构函数都不能重载。( ×)
10.所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。( ×)
11.某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。( √ )
12.如果一个成员函数只存取一个类的静态数据成员，则可将该成员函数说明为静态成员函数。( √ )
13.指向对象的指针与对象都可以作函数参数，但是使用前者比后者好些。( √ )
14.对象引用作函数参数比用对象指针更方便些。( √ )
15.对象数组的元素可以是不同类的对象。( ×)
16.const char*p说明了p是指向字符串的常量指针。( ×)
17.C＋＋语言中，既允许单继承，又允许多继承。( √ )
18.派生类的继承方式有两种，公有继承和私有继承。( ×)
19.在公有继承中,基类中只有公有成员对派生对象是可见的。( ×)
20.在私有继承中，基类中只有公有成员对派生类是可见的。( √ )
21.构造函数可以被继承。( ×)
22.析构函数不能被继承。( √ )
23.多继承情况下，派生类的构造函数的执行顺序取决于定义派生时所指定的各基类的顺序。( √ )
24.解决多继承情况下出现的二义性的方法之一是使用成员名限定法。( √ )
25.函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。( √ )
26.多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数定义实现的。( √ )
27.对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。( ×)
28.对单目运算符重载为友元函数时，说明一个形参;重载为成员函数时,不能显式说明形参。( √ )
29.重载运算符保持原运算符的优先级和结合性不变。( √ )
30.虚函数是用virtual 关键字说明的成员函数。( √ )
31.构造函数说明为纯虚函数是没有意义的。( √ )
32.抽象类是指一些没有说明对象的类。( ×)
33.动态联编是在运行时选定调用的成员函数的。( √ )
34.使用提取符（<<）可以输出各种类型的变量的值,也可以输出指针值.( ×)
35.静态变量在整个程序的运行过程中始终都是存在着的。( √ )
36.一个变量的指针就是该变量地址所指向的存储单元。( √ )
37.在C++中，可以定义一个指向函数的指针。( √ )
38.C++语言不允许把一个结构作为一个整体进行输入输出。( √ )
39.在C++中定义数组时，任何时候都不可以省略下标。( ×)
40.对于int a[1]，可以用a++来指向数组的第二个元素。( ×)
41.C++对常量也可以建立引用。( √ )
42.在定义一个类时，不能在类说明中对数据成员使用表达式进行初始化。( √ )
43.如果在类声明中没有定义拷贝构造函数，就不能用一个对象去初始化另一个对象。( ×)
44.一个指向基类的指针可以访问从基类派生出来的任何对象。( √ )
45.C++语言函数不能进行嵌套定义。( √ )
46.语句int *p( ):定义了一个指向函数的指针。( √ )
47.在C++语言中，数据类型的转换必须是显式的。( ×)
48.发生传值调用时，形参和实参各占一个独立的存储空间。( √ )
49.C++语言不能定义字符串变量。( √ )
50.在C++中，当存在一个与模板函数同名的普通函数时，调用的顺序是模板函数优先。( ×)
51.C++的虚函数必须是类的一个成员，而不允许是类的友元。( √ )
三.写出下列程序的输出结果
1.引用参数
#include
void swap(int &,int &);
void main( )
{int a=5,b=8; cout<<"a="< swap(a,b); cout<<"a="< } void swap(int &x,int &y) {int temp=x; x=y; y=temp;} 执行该程序后,输出结果如下: a=5,b=8 a=8,b=5 1.返回引用 #include int &f1(int n,int s[]) {int &m=s[n]; return m; } void main( ) {int s[]={5,4,3,2,1,0}; f1(3,s)=10;cout< 10 2.构造.析构函数调用 #include class A{ private: int a,b; public : A( ); A(int i,int j); void print ( ); }; A::A( ) { a=b=0; cout<<"Default constructor is called.\n"; } A::A(int i,int j) { a=i; b=j; cout<<"Constructor is called.\n"; } void A::print ( ) { cout<<"a="< void main( ) { Am,n(4,8); m.print ( ); n.print ( ); } 执行该程序后,输出结果如下: Default constructor is called. Constructor is called. a=0，b=0 a=4，b=8 2.构造.析构函数调用 #include class TDate{ private: int year,month,day; public : TDate(int y,int m,int d); ~TDate( ); void print ( ); }; TDate::TDate(int y,int m,int d) { year=y; month=m; day=d; cout<<"Constructor is called."< { cout<<"Destructor is called.\n"; } void TDate::print ( ) { cout< void main( ) { TDatetoday(2000,1,10),tomorrow(2000,1,111); cout<<"Today is "; today.print ( );cout<<"Tomorrow is ";tomorrow.print ( ); } 执行该程序后,输出结果如下: Constructor is called. Constructor is called. Today is 2000.1.10 Tomorrow is 2000.1.11 Destructor is called. 3.对象指针作参数 #include class M{ private: int x,y; public : M( ){x=y=0;} M(int i,int j){x=i; y=j;} void copy(M*m); void setxy(int i,int j){x=i;y=j;} void print ( ){cout< }; void M::copy(M*m) { x=m－＞x; y=m－＞y; } void fun(Mm1,M*m2); void main( ) {Mp(5,7),q; q.copy(&p); fun(p,&q); p.print ( ); q.print ( ); } void fun(Mm1,M*m2) {m1.setxy(12,15); m2－＞setxy(22,25); } 执行该程序后,输出结果如后:5,7 22,25 3.对象引用作参数 #include class A{ private: int m; public : A(int i=0){m=i; cout<<"Constructor is called.\n"; } void set(int i){m=i;} void print ( )const {cout< ~A( ){cout<<"Destructor is called.\n";} }; void fun(const A&c) {C.print ( ); } void main( ) { fun(5); } 执行该程序后,输出结果如下: Constructor is called. 5 Destructor is called. 4.派生 #include class A{ int a,b; public : A(int i,int j){a=i;b=j;} void move(int x,int y){a+=x;b+=y;} void show( ){cout<<"("< }; class B:privateA{ int x,y; public : B(int i,int j,int k,int l):A(i,j){x=k; y=l;} void show( ){cout< void fun( ){move(3,5);} void f1( ){ A::show( ); } }; void main( ) {A e(1,2);e.show( ); Bd(3,4,5,6); D.fun( ); D.show( ); D.f1( ); } 执行该程序后,输出结果如下: (1,2) 5,6 (6,9) 4.派生 #include class A{ int a,b; public : A(int i,int j){a=i;b=j;} void move(int x,int y){a+=x;b+=y;} void show( ){cout<<"("< }; class B:public A{ int x,y; public : B(int i,int j,int k,int l):A(i,j),x(k),y(l){} void show( ){cout< void fun( ){ move(3,5);} void f1( ){ A::show( ); } }; void main( ) {Ae(1,2);e.show( );Bd(3,4,5,6); D.fun( ); D.A::show( );D.B::show( ); D.f1( ); } 执行该程序后,输出结果如下: (1,2) (6,9) 5,6 (6,9) 5.虚函数与派生 #include class B{ protected: int b; public : B(int i){b=i+50;show( );} B( ){} virtual void show( ){cout<<"B::show( ) is called.b="< class D:public B{ protected: int d; public : D(int i):B(i){d=i+100;show( );} D( ){} void show( ){cout<<"D::show( )iscalleD.d="< }; void main( ){D d1(108);} 执行该程序后,输出结果如下: B::show( )is called.b=158 D::show( )iscalleD.d=208 5.虚函数与派生 #include class A{ public : A( ){} virtual void f( ){cout<<"A::f( )iscalleD.\n";} }; class B:public A{ public : B( ){f( );} void g( ){f( );} }; class C:public B{ public : C( ){} virtual void f( ){cout<<"C::f( )is called.\n";} }; void main( ) {Cc;C.g( );} 执行该程序后,输出结果如下: A::f( )is called. C::f( )is called. 6.请分析以下的程序，给出该程序的正确执行结果。 #include int add(int x,int y){return x+y;} void main( ) {int m=2,n=3; cout<<"1:"< m=2,n=3; cout<<"2:"< m=2,n=3; cout<<"3:"<< m=2,n=3; cout<<"4:"<< } 答:1:7 2:8 3:8 4:9 [解析]在说明答案之前，要说明两个问题: （1）C++语言中，函数参数是压在栈里的，因压栈是从前往后进行的，所以出栈就是从后向前进行的，也即先取最后的参数，然后再向前逐个取用; （2）对于单加运算，m++是先执行后加1，++m是加1后再执行。 由此，因m=2,n=3;，所以: 1:（m++）+（m+n）=2+（2+3）=7（m++后执行，且后加1，所以m=2一直未变） 2:（++m）+（m+n）=3+（2+3）=8（++m后执行，但先加1，执行++m时，m=3了） 3:（m+n）+（m++）=（3+3）+2=8（先执行m++，后加1，执行m+n时，m=3了） 4:（m+n）+（++m）=（3+3）+3=9;（先执行++m，且先加1，故一开始就有m=3） 7.请分析下面的程序并给出该程序的执行结果。 #include class AA{ int a; public : AA( ){cout<<"Initualizing AA!\n";} ~AA( ){cout<<"Destroying AA!\n"; }; class BB{ int b; AA p; public : BB( ){cout<<"Initualizing BB!\n";} ~BB( ){cout<<"Destroying BB!\n"; }; void main( ) {BB X; cout<<"Ending main!\n"; } 答:Initualizing AA! Initualizing BB! Ending main! Destroying BB! Destroying AA! [解析]虽然在主程序中只定义了一个类BB的对象，但在类BB中声明了类AA的对象作为它的数据成员。当一个类中含有对象作为数据成员时，在生成对象时，先调用成员对象的构造函数，再调用类自己的构造函数，所以输出了"Initualizing AA!"（成员对象构造函数的输出）和"Initualizing BB!"（类自己构造函数的输出）。对象生成后，执行下一句输出语句，则输出"Ending main!"。此时程序结束，调用析构函数来析构掉对象，先调用类自身的析构函数，其输出为"Destroying BB!"，再调用成员对象的析构函数，其输出为"Destroying AA!"。 8.写出下列程序的运行结果。 #include class AA{ int a; public : AA(int i){a=i;cout<<"AA="< virtual ~AA( ){cout<<"~AA="< }; class BB:public AA{ int b; public : BB(int i,int j):AA(i){b=j;cout<<"BB="< ~BB( ){cout<<"~BB="< }; void main( ) {AA *pa=new AA(8); delete pa; AA*pb=new BB(6,9); delete pb; } 答:AA=8 ~AA=8 AA=6 BB=9 ~BB=9 ~AA=6 [解析]语句"AA*pa=new AA(8);"动态生成一个类AA的对象并把它的地址赋给对象指针"pa"，为此系统调用了AA的构造函数，输出AA=8。接下来，执行语句"delete pa;"删除该对象指针，其实是删除了动态生成的对象，因此调用类AA的析构函数，输出~AA=8。接着执行语句"AA*pb=new BB(6,9);"，动态生成一个类BB的对象，并将其地址赋给类AA的指针"pb"。在生成派生类BB对象时，系统首先调用基类AA的构造函数输出AA=6，然后调用派生类BB的构造函数输出BB=9。最后执行语句"deletep b;"，由于基类AA的析构函数被定义为虚函数，因此在运行时是动态联编的。故系统先调用派生类BB的析构函数输出~BB=9，再调用基类AA的析构函数输出~AA=6（若基类析构函数非虚函数，则只输出~AA=6）。 9.写出下列程序的运行结果。 #include class AA{ public : static int n; AA( ){n++;} }; int AA::n=0; main( ) { cout<<"AA::n="< AA d2;cout<< cout<< } 答:AA::n=0 d1.n=1 d2.n=2 d1.n=4 d2.n=4 [解析]由于数据成员n的访问属性是公有的，所以在类外可访问它;又它是静态变量，所以具有全局性。在构造函数中，执行的是n++操作，即每次调用构造函数n就加1。当程序开始时，因未定义对象，所以n的值为初始化时的值，则输出为"AA::n=0"。当定义了对象d1后，由于调用了构造函数，则该对象中n=1，故输出"d1.n=1"。同理，对象d2输出"d2.n=2"。由于接下来生成了两个对象d3和d4，调用两次构造函数，n两次加1，此时n=4，所以下面两条语句的输出为"d1.n=4"和"d2.n=4"。 10.写出下列程序的输出结果。 #include class AA{ public : AA{}{cout<<"ConstructorofAA.\n";fun( );} virtual void fun( ){cout<<"AA::fun( )is called.\n";} }; class BB:public AA{ public : BB( ){cout<<"Constructor of BB.\n"; fun( );} void fun( ){cout<<"BB::fun( )is called.\n";} }; void main( ){BB d;} 答:Constructor of AA. AA::fun()is called. Constructor of BB. BB::fun( )is called. [解析]虽然函数fun( )说明为虚函数，但当在构造函数中被调用时，呈现的是静态联编，即基类和派生类都调用各自的函数fun( )。所以，当生成对象d时，先调用基类的构造函数，在构造函数中又调用自己的函数"fun( )"，所以输出为"Constructor of AA."和"AA::fun( )is called."。同理调用派生类的构造函数时，生成的输出为"Constructor of BB."和"BB::fun( )is called."。 11.请给出下面的程序的输出结果。 #include template void sort(T*a,int n) {Tnum; for(int i=0;i {for(int j=i;j if(a[j]>a[j+1]) {num=a[j];a[j]=a[j+1];a[j+1]=num;} } for(i=0;i cout< } void main( ) {int iver[5]={12,45,9,23,37}; double dver[5]={22.3,56.7,43.5,13.8,8.6}; sort(iver,5); sort(dver,.5); } 答:9 12 23 37 45 8.6 13.8 22.3 43.5 56.7 [解析]这是使用模板的例子。函数sort是一个递增的排序函数，T是个模板。当数组是整型数据类型时，它为整型数组排序;当数组为双精度数据类型时，它为双精度数组排序。所以输出如上结果。 12.给出如下程序运行结果: int main( ) {int num=50; int &ref=num; ref=ref+10; cout<<"num="< num=num+40; cont<<"ref="< return 0; } 13.给出如下程序运行结果: class test{ private: int num; public : test( ); int getint ( ){return num;} ~test( ); }; test::test( ){num=0;} test::~test( ){cout<<"Destuctorisactive"< void main( ) { testx[3]; cout<<"Exitingmain"< 14. #include int b[3][5]={11,12,13,14,15,21,22,23,24,25,31,32,33,34,35}; int (*p)[5]: p=b; For(int j=0;j<5;j++) cout<<*(*p+j)<<","; cout< } 15. #include #define PI 3.1415926 #define FUDGE(k) k*PI; #define PR(a) cout<<"a"< #define PRINT(a) PR(a);cout<<"\n"; #define PRINT2(a,b) PR(a);PRlNT(b); #define PRINT3(3,b,c) PR(a):PRINT2(b,c); #define MAX(a,b) (a void main( ) { int x=2; PRINT (x*FUDGE(2)); for(int cel=0;cel<=100;cel+=50) PRINT2(cel,9.15*cel+32); int x=l,y=2; PRINT 3(MAX(x++,y),x,y); PRINT 3(MAX(x++,y),x,y): } 16. #include #define N 8 void main( ){void print (int );print (l):} void print (int n){cout<<"W";if(n>=N) return ;else print (++n);} 17. #include #include class string{ private; char*str; public ; string(char*s); ~string( ); void print ( ); }; class person {private: string name; int age: 第3章面向对象程序设计基础 第3章面向对象程序设计基础 【1】什么是Java程序使用的类？什么是类库？ 答：类是将一类事物的特性描述出来，然后如果用这个类来定义对象，则该对象就拥有了这个类所描述的所有特性。 在Java系统中，系统定义好的类根据实现的功能不同，可以划分成不同的集合，每个集合称为一个包，所有包合称为类库。 【2】如何定义方法？在面向对象程序设计中方法有什么作用？ 答：方法的定义由两部分组成：方法声明和方法体。 方法的声明如下： 返回值类型方法名（参数类型形式参数1，参数类型形式参数2…）{ 程序代码； 返回值； } 在面向对象程序设计中，方法的作用是完成对类和对象属性操作。 【3】简述构造方法的功能和特点。下面的程序片段是某学生为student类编写的构造方法，请指出其中的错误。 void Student(int no,String name) { studentNo=no; studentName=name; return no; } 答：构造方法的功能是：构造方法是一个特殊的方法，主要用于初始化新创建的对象； 特点：构造方法的方法名要求与类名相同，用户不能直接调用，只能通过new运算符调用，而且构造方法是不返回任何数据类型，甚至也不返回void数据类型，即不能在构造方法前加void。 错误之处：（1）构造方法Student()前不能加void，（2）不能用return语句,(3)类名Student 首字母S改成小写s. 【4】定义一个表示学生的student类，包括的域有学号、姓名、性别、年龄，包括的方法有获得学号、姓名、性别、年龄及修改年龄。编写Java程序创建student类的对象及测试其方法的功能。 class Student { String id; String name; String sex; int age; void talk(){ 《面向对象程序设计》 大作业 题目学生成绩管理系统 学院 专业 班级 姓名 指导教师 2015 年11 月11 日 目录 一大作业的目的 (1) 二大作业的内容............................ . .. (2) 三大作业的要求与数据............... ...... . (3) 四大作业应完成的工作.................. . (4) 五总体设计（包含几大功能模块）........... . (5) 六详细设计（各功能模块的具体实现算法——流程图） (6) 七调试分析（包含各模块的测试用例，及测试结果） (7) 八总结 (8) 十参考资料 (9) 一大作业的目的 《面向对象程序设计》是一门实践性很强的课程，通过大作业不仅可以全方位检验学生知识掌握程度和综合能力，而且还可以进一步加深、巩固所学课程的基本理论知识，理论联系实际，进一步培养自己综合分析问题和解决问题的能力。更好地掌握运用C++语言独立地编写、调试应用程序和进行其它相关设计的技能。 二大作业的内容 对学生信息(包括学号、语文、数学、英语、平均分)进行管理,包括学生成绩的信息输入、输出、查询、删除、排序、统计、退出.将学生的成绩信息进行记录，信息内容包含：（1）学生的学号（2）学生的姓名（3）学生的成绩。假设，现收集到了一个班学生的所有成绩信息，要求用C语言编写一个简单的成绩管理系统，可进行录入、查询、修改和浏览等功能。学习相关开发工具和应用软件，熟悉系统建设过程。 三大作业的要求与数据 1、用C++语言实现系统； 2、对学生信息(包括学号、姓名、语文、数学、英语、平均分)进行管理,包括学生成绩的信息输入、输出、查询、删除、排序、统计、退出. 3、学生信息包括：其内容较多，为了简化讨论，要求设计的管理系统能够完成以下功能： (1) 每一条记录包括一个学生的学号、姓名、3门课成绩 (2)、成绩信息录入功能：(成绩信息用文件保存，可以一次完成若干条记录 的输入。) (3)、成绩信息显示浏览功能：完成全部学生记录的显示。 (4)、查询功能：完成按姓名查找学生记录，并显示。 (5)成绩信息的删除:按学号进行删除某学生的成绩. (6)、排序功能：按学生平均成绩进行排序。 (7)、应提供一个界面来调用各个功能,调用界面和各个功能的操作界面应尽可能清晰美观! 面向对象程序设计实验指导书 实验一、C++开发环境应用入门（2学时）(选做) 1、实验目的 （1）了解C++开发工具的特点 （2）熟悉C++开发环境 （3）学习用C++编写标准的C++程序 2、实验任务 使用C++来建立一个非图形化的标准C++程序，编译、运行下例程序： #include 一选择题（共 45题） 1．对类的构造函数和析构函数描述正确的是（）。 A.构造函数可以重载，析构函数不能重载√ B.构造函数不能重载，析构函数可以重载 C.构造函数可以重载，析构函数也可以重载 D.构造函数不能重载，析构函数也不能重载 2．继承具有（），即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。 A）规律性 B.传递性√ C.重复性 D.多样性 3．假设OneClass为一个类，则该类的复制初始化构造函数的声明语句为（）。 (OneClass p); B. OneClass& (OneClass p ); C. OneClass(OneClass & p);√ D. OneClass (OneClass * p); 4．对于结构中定义的成员，其默认的访问权限为（）。 B. protected D. static 5．下面对静态数据成员的描述中，不正确的是（）。 A.静态数据成员可以在类体内进行初始化√ B.静态数据成员不可以在类体内进行初始化 C.静态数据成员能受private控制符的作用 D.静态数据成员调用前必须初始 6. C++中的类有两种用法：一种是类的实例化，即生成类对象，并参与系统的运行；另一种是通过（）派生了新的类。 A.复用 B.继承√ C.封装 D.引用 7. 假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a 的格式为（）。 A. x(a) B. x[a] C. x->a D. √ 9. 对于一个类的构造函数，其函数名与类名( )。 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．派生类至少有一个基类 C．派生类的缺省继承方式是private D．派生类只继承了基类的公有成员和保护成员√ 16.下列对继承的描述中，错误的是（）。 A．析构函数不能被继承 实验一熟悉VC++IDE开发环境 一、实验目的 1、熟悉VC++6.0集成开发环境，熟练掌握VC++6.0项目工作区、各种编辑器、菜单栏和工具栏的使用。 2、掌握如何编辑、编译、连接和运行一个C++程序。 3、通过运行简单的C++程序，初步了解C++源程序的结构和特点。 二、实验要求 1、分析下列程序运行的结果。 程序一： #include 2015秋季学期计算机科学与技术本科 《面向对象程序设计技术》作业题 （在电大在线该课程讨论区跟帖提交，注明姓名和学号以记录成绩）选择题 1.可以在本类及派生类的成员函数中进行访问的访问控制修饰符是（B） A.private B.protected C.public 2.在IDE中将编程项目采用多文件结构下，类的定义一般放在（A） A.头文件 B.程序文件 C.主程序文件 3.内联成员函数在类外定义时要将其和类定义一起放在（A） A.头文件 B.程序文件 C.主程序文件 4.下面哪个内存区域是C++中的运行时动态内存分配区域？( D ) A.代码区 B.栈区 C.数据区 D.堆区 5.对象作为函数参数使用时，一般使用（A）形式 A.引用 B.指针 C.对象拷贝 6.同类的多个不同对象的数据成员值各有不同，但不同对象可以共享类的成员函数代码， 实际调用成员函数时，是通过（B ）来区分不同对象的。 A.显式给出不同对象不同地址 B.隐含的this指针 C.引用 7.下面哪一种情况不会自动调用拷贝构造函数。（E） A.用一个对象初始化另一个对象时 B.当一个对象作为值传递给一个函数时 C.当一个对象作为值从一个函数返回之前，该对象被拷贝到栈区 D.函数调用结束后，栈区中的返回对象拷贝给主调程序的对象 E.建立指向对象的指针并初始化指针值时 8.下列哪些对象的数据成员类型可以不用初始化表的方式进行初始化（D） A.常量数据成员 B.引用数据成员 C.类中对象成员 D.一般数据成员 9.下列哪一种类设计一般无需在类中设计静态数据成员以使建立的多个对象共享静态数 据数据成员。( D ) A.一个链表类的头指针和尾指针 B.一个学生类中用于保存建立了多少个学生对象的计数器 C.银行帐号类中的年利率 D.一般只用于建立一个对象的类 10.一个类中的公有（public）性质的静态数据成员，以下哪一种访问方式是错误的（D） A.对象名.静态数据成员名 B.指向对象的指针—>静态数据成员名 C.类名::静态数据成员名 D.类名.静态数据成员名 11.下列哪一个运算符不能够被类所重载（E） A.“.”成员访问运算符 B.“*”成员指针访问运算符 C.“::”域运算符 D.“？:”条件运算符 E.“=”赋值运算符 《面向对象程序设计》课程实验指导书 实验一 Java开发环境的安装与配置 一、实验目的： 1. 掌握JDK、Eclipse的安装步骤。 2. 理解环境变量PATH, CLASSPATH的作用，以及Eclipse的配置。 3. 熟悉Eclipse的编辑、编译与调试环境，编写简单的Application程序 编译执行并完成调试。 二、实验内容： 熟悉JDK的安装和配置，学习如何编写并运行简单的Application程序 (能输出一条简单的问候信息)； 三、实验要求： 1. 能正确地安装JDK 2. 熟悉环境变量PATH, CLASSPATH设置方法，熟悉编辑环境 3. 调试程序、编译，运行后得到正确的结果 四、实验步骤： 1．从https://www.doczj.com/doc/b111266660.html,/technetwork/java/index.html上下载最新版本的JDK，并安装。 2．设置环境变量PATH, CLASSPATH, 使得Java程序能正确编译和执行。 3．在Eclipse环境下编写一个HelloWorld.java程序， (1)在主方法static public void main(String[ ] args)中调用System. out.println()方法，使程序输出一条问候信息； (2) 编译运行程序，观察运行情况和输出结果。（使用JDK环境，调用 javac.exe和java.exe编译和执行程序） 实验二 Java语言基础 一、实验目的： 熟悉Java基本语法，基本数据类型，各种运算符及表达式的使用，掌握运算符优先级,熟悉使用Java的选择语句,循环语句。 二、实验内容： 1.编写Java Application程序，输出1900年到2000年之间的所有润年。 （闰年的判断条件：能被4整除且不能被100整除，或能被400整除）； 2.金字塔：Pyramid.java 在屏幕上显示一个由星型符号“*”组成的金字塔图案，示例如下： * *** ***** ******* 要求：金字塔高度h,可以由用户设置。 三、实验要求： 1. 正确使用Java语言的选择语句,循环语句； 2. 调试程序、编译，运行后得到正确的结果 3.写出实验报告。要求记录编译和执行Java程序当中的系统错误信息提成 示，并给出解决办法。 四、实验步骤： 1.编写主类； 2.在static public void main(String[ ] args)方法中加入实现要求功能 的代码，主要步骤如下： （第一题）从1900到2000循环，按照闰年的判断条件是则输出1900年到2000年之间的所有润年。 （第二题）允许用户设置金字塔高度。 4. 编译运行程序，观察输出结果是否正确。 面向对象编程练习题 专题1 初识Java 一、填空题 1．自从Sun推出Java以来，按应用范围可分为三个版本，分别是（）、（）、（）。 2．环境变量的设置，若JDK安装在“D:\JDK”，则应设置Path为（）、classpath为（）。3．Java源文件的扩展名为（），用Javac编译Java源文件，得到的字节码文件的扩展名为（）。4．如果Java源文件中有多个类，那么只能有一个类是（）类。 二、选择题 1．作为Java应用程序入口的main方法，其声明格式是（） A．public static int main(String args[]) B．public static void main(String args[]) C．public void main(String args[]) D．public int main(String args[]) 2．下面命令正确的是（） A．java AppFirst.java B．java AppFirst C．java appfirst.class D．javac AppFirst 3．设有一个Java小程序，源程序名为FirstApplet.java，其HTML文件为FirstApplet.html，则运行该小程序的命令为（） A．java FirstApplet B．javac FirstApplet.java C．appletviewer FirstApplet.java D．appletviewer FirstApplet.html 4．JDK安装完成后，主要的命令如javac、java等，都存放在根目录的（）文件夹下。 A．bin B．jre C．include D．doc 5．Java语言是一种语言。 A．机器B．汇编C．面向过程的D．面向对象的 6、Java程序的最基本组成单位是( )。 A．函数B．过程C．变量D．类 7. main()方法的返回值类型是（）。 A．boolean B．int C. void D．static 8. 下面哪个单词是Java语言的关键字（）A．False B．FOR C．For D．for 9. 、线程是Java的（）机制。 A．检查B．解释执行C．并行D．并发 1 什么是面向对象程序设计，它与传统的结构式程序有什么不同。 面向对象程序设计是一种适用于设计、开发各类软件的范型。它是将软件看成是一个由对象组成的社会：这些对象具有足够的智能，能理解从其他对象接受的信息，并以适当的行为作出响应；允许低层对象从高层对象继承属性和行为。通过这样的设计思想和方法，将所模拟的现实世界中的事物直接映射到软件系统的解空间。 与传统的结构式程序设计相比，面向对象程序设计吸取了结构式程序设计的一切优点（自顶向下、逐步求精的设计原则）。而二者之间的最大差别表现在： ·面向对象程序采用数据抽象和信息隐藏技术使组成类的数据和操作是不可分割的，避免了结构式程序由于数据和过程分离引起的弊病。 · 面向对象程序是由类定义、对象（类实例）和对象之间的动态联系组成的。而结构式程序是由结构化的数据、过程的定义以及调用过程处理相应的数据组成的 2 用面向对象方法建立模型的思维过程是怎样的。 用面向对象方法建立拟建系统的模型的过程就是从被模拟现实世界的感性具体中抽象要解决的问题概念的过程。这种抽象过程分为知性思维和具体思维两个阶段，其中：·知性思维是从感性材料中分解对象，抽象出一般规定，形成了对对象的普遍认识。·具体思维是从知性思维得到出的一般规定中揭示的事物的深刻本质和规律，其目的是把握具体对象的多样性的统一和不同规定的综合。 3 解释以下概念： ①对象：在现实世界中，对象就是可以感觉到的实体。每个对象具有一个特定的名字以 区别于其他对象；具有一组状态用来描述它的某些特性；具有一组操作，每一个操作决定对象的一种功能或行为（为自身服务的操作和为其他对象提供服务的操作）。而在面向对象系统中，对象是可以标识的存储区域。每个对象的状态被保存在此区域中，而实现一类对象行为的操作（代码）被保存在另外相关的存储器区域中。 ②消息：消息是要求某个对象执行其某种功能操作（方法）的规格说明。因此，消息是 由消息的接收者、消息要求提供的操作（消息名）和必要的参数组成的。 ③类：在现实世界中，类是对一组具有共同特性（属性和行为）的客观对象的抽象。而 在面向对象系统中，类是由程序员自定义的具有特定结构和功能的类型，是一种代码共享的手段。 ④实例：任何一个对象都是该对象所属类的一个具体实例。 ⑤公有消息：是由对象外向对象发送的消息，用于激活该对象的某种方法。 ⑥私有消息：是由对象向自身发送的消息，用于内部操作；该类消息不能从对象外向该 对象发送。 ⑦消息序列：在面向对象系统中一个事件的发生总会有多个对象的多次相互作用才能完 成，使得这些对象能够相互作用的消息组成的序列被称为消息序列。 4 类与实例的关系如何？ 类是创建对象的模板，而对象是实现类的实例。属于同一类的不同实例必须具有： ·相同的操作集合； ·相同的静态属性集合； ·不同的对象名和属性动态值。 学号：姓名： 第三章面向对象程序设计作业 一、判断题 1、一个Java源程序可有多个类，但只仅有一个public类，而且程序名与public类名相同。对 2、如果类A和类B在同一个包中，则除了私有成员外，类A可以访问类B中所有的成员。对 3、接口中的成员变量全部为常量，方法为抽象方法。对 4、抽象类可以有构造方法，可以直接实例化。错 5、对static方法的调用可以不需要类实例。对 6、包含抽象方法的类一定是抽象类。对 7、方法中的形参可以和方法所属类的属性同名。对 8、接口无构造器，不能有实例，也不能定义常量。错 9、类的实例对象的生命周括实例对象的创建、使用、废弃、垃圾的回收。对 10、Java应用程序的入口main方法只有一种定义法。对 二、选择题 1、下列答案正确的是（A ） A) 在同一个Java源文件中可以包含多个类，只能有一个被声明为public B) 在同一个Java源文件中只能包含一个类，并被声明为public C) 在同一个Java源文件中可以包含多个类，都可以被声明为public D) 在同一个Java源文件中可以包含多个类，只能有一个被声明为default 2、Java实现动态多态性是通过（ B ）实现的。 A) 重载B) 覆盖 C) 接口D) 抽象类 3、下列哪一个是正确的方法重载描述（ A ） A) 重载方法的参数类型必须不同 B) 重载方法的参数名称必须不同 C) 返回值类型必须不同 D) 修饰词必须不同 4、final关键字不可以用来修饰（ D ） A) 类B) 成员方法 C) 域D) 接口 5、接口的所有成员方法都具有（ B ）属性 A) private, final B) public, abstract C) static, protected D) static 6、Java的封装性是通过（A ）实现的 A) 访问控制B) 设计内部类 C) 静态域和静态方法D) 包 7、下列接口或类不属于.*包的是（ D ） A) Collection B)Vector C) Map D) Integer 8、下述哪一组方法，是一个类中方法重载的正确写法（ A ） A) int addValue( int a, int b ){return a+b;} C++面向对象程序设计实验报告 学院：信息科学与技术学院 班级：卓越电子1201 姓名：刘强 学号：120910115 实验二 C++面向过程程序设计 实验目的 掌握函数声明、定义和使用的方法 掌握函数递归调用的方法 实验内容 1、编写一个函数，求数列运算中从n个不同的数中取r个数的所有选择的个数，要求如下：主程序中设计一个循环，不断从输入接收n和r的值，计算结果并输出，当用户输入0 0时，程序结束； 能检查输入数据的合法性，要求n>=1并且n>=r； 能得到正确结果。 输入：5 3输出：10 输入：10 20；输出：Input Invalid !； 输入：-1 4；输出：Input Invalid!； 步骤： 利用一个函数fn(int n)计算n!， 利用另一个函数Cnr(int n, int r)计算Cnr，在该函数中调用fn()， 程序代码： #include int Cnr(int n,int r) { cout<<"Please input two numbers:"< 《面向对象程序设计》高起专习题三答案 一、单项选择题（本大题共25小题，每小题2分，共50分） 1、用“>>”运算符从键盘输入多于一个数据时，各数据之间应使用（ D ）符号作为分隔符。 A、空格或逗号 B、逗号或回车 C、逗号或分号 D、空格或回车 2、C++中声明常量的关键字是（ A ）。 A、const B、extern C、public D、enum 3、以下叙述中正确的是（ B ） A、使用#define可以为常量定义一个名字，该名字在程序中可以再赋另外的值 B、使用const定义的常量名有类型之分，其值在程序运行时是不可改变的 C、在程序中使用内置函数使程序的可读性变差 D、在定义函数时可以在形参表的任何位置给出缺省形参值 4、下列的符号常变量定义中，错误的定义是（ C ）。 A、const M=10; B、const int M=20; C、const char ch; D、const bool mark=true; 5、函数原型语句正确的是（ B ）。 A、int Function(void a) B、void Function (int); C、int Function(a); D、void int(double a); 6、在关键字private后面定义的成员为类的（ A ）成员。 A、私有 B、公用 C、保护 D、任何 7、在一个类的定义中，包含有（ C ）成员的定义。 A、数据 B、函数 C、数据和函数 D、数据或函数 8、在类作用域中能够通过直接使用该类的（ D ）成员名进行访问。 A、私有 B、公用 C、保护 D、任何 9、在关键字public后面定义的成员为类的（ B ）成员。 A、私有 B、公用 C、保护 D、任何 10、类中定义的成员默认为（ B ）访问属性。 A、public B、private C、protected D、friend 11、每个类（ C ）构造函数。 面向对象程序设计教程（C++语言描述）题解与课程设计指导 第1章 面向对象程序设计概论 一、名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。 二、填空题 （1）目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种重要的程序设计方法。 （2）结构化程序设计方法中的模块由顺序、选择和循环3种基本结构组成。（3）在结构化程序设计方法中，程序可表示为程序=数据结构+算法；而面向对象的程序设计方法，程序可表示为程序=对象+消息。 （4）结构化程序设计方法中的基本模块是过程；而面向对象程序设计方法中的基本模块是类。 （5）面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、选择题（至少选一个，可以多选） （1）面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （2）面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制叫做（C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （3）在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （4）面向对象程序设计中，对象与对象之间的通信机制是（C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与C语言的关系的描述中，（D ）是错误的。 A. C语言是C++的一个子集 B. C语言与C++是兼容的 C. C++对C语言进行了一些改进 D. C++和C语言都是面向对象的 【结果分析】 C语言是面向过程的。C++语言是一种经过改进的更为优化的C语言，是一种混合型语言，既面向过程也面向对象。 （6）面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依存、不可分割的整体来处理。 资料内容仅供您学习参考，如有不当或者侵权，请联系改正或者删除。 综合实验报告 面向对象程序设计 专业名称: 物联网工程 ___班级: _____ 级2班__ ___________姓名: 你哥哥 学号: 02051928 信息科学与工程学院 二零一三年七月 第一题: (1) 1.1题目概述 (1) 1.2设计思路 (2) 1.3设计说明与调试分析 (2) 1.4编码实现 (2) 1.5程序运行结果 (5) 1.6设计心得 (5) 第二题: (6) 2.1题目概述 (6) 2.2设计思路 (7) 2.3设计说明与调试分析 (7) 2.4编码实现 (7) 2.5程序运行结果 (11) 2.6设计心得 (11) 第一题: 1.1题目概述 用抽象类设计计算二维平面图形图形面积的程序, 在基类TDshape中设计纯虚函数area()和printName(), area()用于计算几何图形的面积, printName()用于打印输出几何图形的类名, 如Triangle类的对象就打印输出”Triangle”。每个具体形状的类则从抽象类TDshape派生, 各自需要定义其它独有的数据成员和成员函数, 而且定义area()和printName()的具体实现代码, 如图所示。 要求编写以TDshape为接口的函数, 借以访问具体类如 Triangle和Rectangle类的成员函数area(), printName ()。1.2设计思路 由简到繁, 逐步实现。 1.3设计说明与调试分析 编写基类TDshape->编写虚函数->编写继承类Triangle ->实例化TDshape和Triangle ->调用基类虚函数实现调用继承类相应函数->同样的方式处理继承类Rectangle. 1.4编码实现 #include 面向对象程序设计习题 1．面向对象程序设计中的数据隐藏指的是参考答案为:D A．输入数据必须输入保密口令B．数据经过加密处理 C. 对象内部数据结构上建有防火墙D．对象内部数据结构的不可访问性[解析]输入数据必须输入保密口令和数据经过加密处理都不是面向对象程序设计的特征；对象内部数据结构上也不可能建有防火墙，所以它们都不是面向对象程序设计中所指的数据隐藏。面向对象程序设计系统中的封装单位是对象，对象之间只能通过接口进行信息交流，外部不能对对象中的数据随意地进行访问，这就造成了对象内部数据结构的不可访问性，也使得数据被隐藏在对象中。这就是面向对象程序设计中的数据隐藏所指。 2．下列各项中符合函数重载必须满足的条件的是参考答案为:D A．必须有不同的参数个数B．对应的参数类型必须不相同 C. A和B必须同时满足D．A和B只要满足一个即可 [解析]我们知道，在同一个作用域中，要实现函数重载必须满足的条件的是：① 有不同的参 数个数；或者② 对应的参数有不相同的数据类型，即①和②中只要有一个满足就可以了。当然两者都满足更好，但这不是必须的。3．下列带缺省值参数的函数说明中，正确的说明是参考答案为:A A．int Fun(int x,int y=2,int z=3); B．int Fun(int x=1,int y,int z=3); C. int Fun(int x,int y=2,int z); D．int Fun(int x=1,int y,int z=3); [解析]在带缺省值参数的函数说明中，正确的说明应该是无缺省值的参数依次排列在参数表的左边，排完无缺省值的参数后，再依次排列带缺省值的参数。从所给出的四个选项来看，只有“int Fun(int x,int y=2,int z=3)”符合这条规定，其它的都不符合。 4．有如下的对类“CSample”的说明，其中（）是错误的。 class CSample { 参考答案为:A A．int a=23; B．CSample(); public: C．CSample(int val); 面向对象程序设计教程（C++吾言描述）题解与课程设计指导 面向对象程序设计概论 一、 名词解释 抽象封装消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公 共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的 单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对 象要求另一个对象实施某种操作的一个请求。 二、 填空题 （ 1） 目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种 重要的程序设计方法。 （2） 结构化程序设计方法中的模块由顺序、选择和循环 3 种基本结构组成。 （ 3） 在结构化程序设计方法中，程序可表示为程序 =数据结构 +算法； 而面向 对象的程序设计方法，程序可表示为程序 =对象 +消息。 （ 4） 结构化程序设计方法中的基本模块是过程； 而面向对象程序设计方法 中的基本模块是类。 （ 5） 面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、 选择题（至少选一个，可以多选） （ 1） 面向对象程序设计着重于（ B ）的设计。 A. 对象 B. 类 C. 算法 D. 数据 （ 2） 面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制 叫做（ C ）。 A. 抽象 B. 继承 C. 封装 D. 多态 （ 3） 在面向对象程序设计中，类通过（ D ）与外界发生关系。 A. 对象 B. 类 C. 消息 D. 接口 （ 4） 面向对象程序设计中，对象与对象之间的通信机制是（ C ）。 A. 对象 B. 类 C. 消息 D. 接口 （5）关于C++与 C 语言的关系的描述中，（D ）是错误的。 A. C 语言是C++勺一个子集 B. C 语言与C++是兼容的 C. C++对C 语言进行了一些改进 D. C++和C 语言都是面向对象的 【结果分析】 C 语言是面向过程的。C++吾言是一种经过改进的更为优化的 C 语言，是一种混 合型语言，既面向过程也面向对象。 （ 6） 面向对象的程序设计将数据结构与（ A ）放在一起，作为一个相互依 存、不可分割的整体来处理。 A. 算法 B. 信息 C. 数据隐藏 D. 数据抽象 第1 面向对象分析/设计课程大作业 银行业务处理系统 13级软件学院测试班 1367004029 曾丹 1.需求分析 随着社会经济的发展，信息化程度的不断深入，银行的传统业务己愈来愈不能满足银行客户的需要。 现今，人们的金融意识、科技意识己经有了很大的提高，在紧张忙碌的生活中，己越来越来不习惯每月奔忙于各银行营业柜台之问去排队缴各种各样的费用了；同时，各种经营单位如电信、移动、供电、煤气、自来水、证券等等一是为了提高服务质量、方便客户，二是为了减轻自己日趋繁重的工作量，纷纷委托银行为其开展代收代付业务：同时，随着我国加入世贸组织的日益临近，我国的银行业将面临更加激烈的同业竞争，如何提供更多的金融产品和更优质的服务，如 何吸引更多的客户，如何利用计算机技术加强银行帐户信息管理、进行银行业务再造，提高银行的工作效率和业务竟争能力是摆在各家银行面前的一个迫切需要解诀的问题。 近几年来，各商业银行加快了与社会各业的合作，利用自身的网点优势和业务特点，为其提供各种高效、快捷的代收代付业务，也就是中间代理业务，目前以与广大人民群众生活密切相关的各项缴费业务如水电费、电话费、手机费等代收业务为主，这些业务开展方式多种多样，但一般都离不开计算机的高效管理支持。 随着代理业务不断发展，业务品种越来越多，各项业务做法互有差异，这就对银行的电子化水平和相应的管理水平提出了更高的要求。如何利用电子化的手段构建一个高效统一的、通用灵活的系统来管理各种各样的业务，是每个商业银行所要研究的课题。支持决策系统的，需要在数据库的基础上，进行联机分析处理，每次处理的数据量大，响应时间长。 特别是银行每天要处理大量的存取款事件，做好存取款是银行工作重要的环节，然而要有效处理必须要有良好的程序和数据管理系统来建立一个良好的软件系统来实现快速、有效、准确、安全的处理银行事物。 主要用于银行的储蓄卡管理系统，它可以帮助我们有效、准确、并且高效实现的完成存取事件。此系统操作方便效率、安全性高，只要客户开户并设定好密码就可以轻松的实现存取款。 系统实现的主要有储蓄卡开户管理、存取款管理、用户查询历史数据显示、注销等功能。 储蓄卡开户管理模块：卡号、姓名、开户金额、身份证号、地址、电话、密码、确认密码和保存组成。（开户金额必须是数字，密码和确认密码必须一样是六位数字） *注销模块：一旦注销该卡号就不存在且余额提醒你取出。 通过该银行账户管理系统地运行，使办公人员可以轻松快捷的完成对账户管理的任务，提高账目管理效率，使银行的账目管理工作系统化、规范化、自动化。 该银行帐目管理信息系统，优点是设计过程思路清晰、模块划分简洁，设计各阶段分工明确。经过实践证明，该划分是合理的，极大得提高了本系统的实现。 Object- Orien ted Programmi ng C++ 主讲成长生 东华大学计算机科学与技术学院 第一章概述 § 1.1 面向对象程序设计的基本思想 C++是基于C语言发展的，又冲破C语言局限的面向对象的程序设计语言。它与Java 语言都作为当前计算机科学的主流语言, 越来越受到用户的欢迎。 要弄清楚什么是面向对象的程序设计, 首先了解和回顾传统的 （ Pascal（或C））结构化程序设计方法及其设计思想、程序结构及特点。SP（Structure Programming）是60 年代诞生的针对当时爆发的所谓”软件危机” , 为此发展形成了现代软件工程学的基础。 SP的总的设计思想是： . 自顶向下、层次化 . 逐步求精、精细化 程序结构是按功能划分基本模块的树型结构, 使模块间的关系尽可能简单独立。因此SP的程序的基本特点是： . 按层次组织模块（战略上划分战役） . 每一模块只有一个入口, 一个出口 ?代码和数据分离（程序=数据结构+算法） 归纳得到： SP 把数据和过程（代码、函数）分离为相互独立的实体, 用数据代表问题空间中的客体借以表示实际问题中的信 息; 程序代码则用来处理加工这些数据。程序员在编程时 必须时刻考虑所要处理的数据结构和类型。对不同的数据格式即使要作同样 的处理计算, 或者要对相同的数据格式作不同的处理都必须编写不同的程序（如两个整型数和两个浮点数相加）。这样的编程方法，即传统的SP方法设计出来的程序或系统其可重用的成分很少。其次把数据和代码作为不同的分离实体时, 总存在着用错误的数据调用正确的程序模块, 或用正确的数据调用错误的程序模块的危险, 从而使数据与程序始终保持兼容, 已成为程序员 的一个沉重的负担。在开发一个大型软件课题中, 当工程进入到 后期若用户改变了方案要求, 很容易使技术人员的前期工作受到摧毁性的打击，使其前功尽弃。为克服以上的弊端或者该SP方法难以控制处理的矛盾而产生了面向对象程序设计方法, 即Object —Oriented Programming ----------- OOP从二十世纪六十年代提出对象 的雏形, 到七十年代美国国防部的专用语言Ada 语言, 直到当前国际上流行的高品味的Java 和C++（Tc++,Balandc++ 及Vc++）, , 应该讲OOP方法与技术吸取了SP的一切优点，同时又正视和顺应现实世界由物质和意识二部分组成。映射到面向对象的解空间就是: 具体事物—对象; 抽象概念—类。 OOP的基本原理是用问题领域的模型来模拟大千世界，从而设计出尽可能直接、自然地表示问题求解方法的软件, 这样的软件由对象组成, 而对象则是完整反映客观世界事物具有不可分割的静态属性（”数据结构” ）与动态行为（”方法” ）的。而且它们是既有联系又第3章 面向对象程序设计基础
c++面向对象程序设计大作业
面向对象程序设计实验指导书讲解
面向对象程序设计 C 复习题
(完整版)《面向对象程序设计》答案
2016年电大面向对象程序设计技术-作业题
《面向对象程序设计》实验指导书
面向对象编程练习题库-test
什么是面向对象程序设计
面向对象程序设计(答案)
C++面向对象程序设计实验报告
《面向对象程序设计》高起专习题三答案
面向对象程序设计教程答案
面向对象程序设计实验报告完整版
面向对象程序设计习题
面向对象程序设计教程答案
面向对象程序设计大作业(C++)
面向对象程序设计完整版
相关主题
文本预览