面向对象程序设计复习题
面向对象程序设计复习题
一、单项选择题。
1引入内联函数的主要目的是A)缩短程序代码，少占用内存空间B．既可以保证程序的可读性，又能提高程序的运行效率C)提高程序的执行速度D)使程序的结构比较清晰2重载函数是A)以函数参数来区分，而不用函数的返回值来区分不同的函数B．以函数的返回值来区分，而不用函数参数来区分不同的函数C)参数表完全相同而返回值类型不同的两个或多个同名函数D)参数表和返回值类型都必须是不同的两个或多个同名函数3有函数原型 void fun2 (int *), 下面选项中，正确的调用是A) double x = 2.17。
fun2 (&x)。
C) int a = 15。
fun2 (a*3.14)。
B) int b = 100。
fun2 (& b)。
D) fun2 (256)。
4在C++中,要实现动态联编,必须使用( )调用虚函数。
A) 类名B) 派生类指针 C)对象名D) 基类指针5 在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是A)派生类的对象可以直接访问基类中的所有成员B)派生类的对象可以初始化基类的引用C)派生类的对象可以赋给基类的对象D) 派生类的对象的地址可以赋给指向基类的指针6设置虚基类的目的是A)消除两义性 B) 简化程序C)提高运行效率 D)减少目标代码7关于构造函数，以下说法错误的是A) 构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。
在对象创建时由系统自动调用。
B) 基类的构造函数可以被派生类所继承。
C) 如果程序中未声明，则系统自动产生出一个缺省形式的构造函数。
D) 允许为内联函数、重载函数、带缺省形参值的函数。
8下列关于C++函数的说明中，正确的是A)内联函数就是定义在另一个函数体内部的函数B)函数体的最后一条语句必须是return语句C)标准C++要求在调用一个函数之前，必须先声明其原型D)编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式9 由于常对象不能被更新，因此A)通过常对象只能调用它的常成员函数B)通过常对象只能调用静态成员函数C)常对象的成员都是常成员D)通过常对象可以调用任何不改变对象值的成员函数10下列关于虚函数的说明中，正确的是A)从虚基类继承的函数都是虚函数 B)虚函数不得是静态成员函数C)只能通过指针或引用调用虚函数 D)抽象类中的成员函数都是虚函数11 运算符重载是对已有的运算符赋予多重含义，因此A)可以对基本类型(如int类型)的数据，重新定义“+”运算符的含义B)可以改变一个已有运算符的优先级和操作数个数C)只能重载C++中已经有的运算符，不能定义新运算符D)C++中已经有的所有运算符都可以重载12模板对类型的参数化提供了很好的支持，因此A)类模板的主要作用是生成抽象类B)类模板实例化时，编译器将根据给出的模板实参生成一个类C)在类模板中的数据成员都具有同样类型D)类模板中的成员函数都没有返回值13下列符号中可以用作C++标识符的是A)_radius B)foo~bar C)else D)3room14下列语句中，错误的是A)const int buffer=256。
面向对象程序设计复习题文档
面向对象程序设计考试题型：1）选择题10题，共20分2）填空题10题，共20分3）程序阅读题3题，共15分4）程序填空题，10空，共20分5）简答题3题，共15分6）编程题1题，共10分一、选择题：1.属于C#语言的关键字( )。
A. abstractB. camelC. SalaryD. Employ答案：A2.C#语言中，值类型包括：基本值类型、结构类型和（）。
A.小数类型B.整数类型C.类类型D.枚举类型答案：D3. 假定一个10行20列的二维整型数组，下列哪个定义语句是正确的（）。
A. int[]arr = new int[10,20]B. int[]arr = int new[10,20]C. int[,]arr = new int[10,20]D. int[,]arr = new int[20;10]答案：C4．在类作用域中能够通过直接使用该类的（）成员名进行访问。
A. 私有B. 公用C. 保护D. 任何答案：D5.小数类型和浮点类型都可以表示小数，正确说法：( )A. 两者没有任何区别B. 小数类型比浮点类型取值范围大C.小数类型比浮点类型精度高D. 小数类型比浮点类型精度低答案：C6．能作为C#程序的基本单位是( )。
A. 字符B. 语句C. 函数D. 源程序文件答案：B7. 可用作C#程序用户标识符的一组标识符是( )。
A. void define +WORDB. a3_b3 _123 YNC. for -abc CaseD. 2a DO sizeof答案：B8.引用类型主要有4种：类类型、数组类型、接口类型和（）。
A.对象类型B.字符串类型C.委托类型D.整数类型答案：C9.StreamWriter对象的下列方法，可以向文本文件写入一行带回车和换行的文本的是（）。
A.WriteLine()B.Write()C.WritetoEnd()D.Read()答案：A10.建立访问键时，如“新建(N)”菜单中的“N”键，需在菜单标题的字母前添加的符号是( )。
成人教育 《面向对象程序设计》期末考试复习题及参考答案
面向对象程序设计复习题二一、填空1.程序的三种常见结构是、、，其中结构是程序的默认结构。
2.同名方法给出不同的实现，并通过参数类型或个数进行区分，称为。
3.和“继承”匹配的概念是。
4.由类构建对象的过程称为。
5.抽象类是含有的类。
6.实现软件复用有两种方式，分别为、、。
7.有定义const int *p，p称为。
8.通过继承产生的类称为。
9.virtual关键字在C++中有两个用处，分贝是，和。
10.方法重载和实现了多态性。
11.请给出C++外的另外一种支持面向对象设计语言。
12.类的三个要素是、、。
13.对象释放前执行的函数是。
二、名词解释1、构造函数2、对象3、运算符重载4、析构函数5. 面向对象6. 继承三、简答1.比较类和结构体？2.重载的意义？3.抽象类的作用和意义？4.组合与继承的区别？四、辩析1.任何父类对象都可以被子类对象替代。
2.public修饰符号破坏了数据的开放性。
3.private继承方式不能产生子类。
4.不能实例化的类一定是抽象类。
五、综合回答1．简述多态的实现机制。
2．谈谈多态的意义。
3．面向对象程序设计思想的优点和缺点。
面向对象程序设计复习题二答案一、填空（1）顺序（2）选择（3）循环（4）顺序（5）函数重载（6）抽象（7）实例化（8）纯虚函数（9）继承(10) 组合（9）和（10）不区分顺序（11）常量指针（12）派生类（13）虚函数（14）虚拟继承（13）和（14）不区分顺序（15）覆盖（16）Java或者C#（17）类的标识（18）类的状态（19）类的操作（17）（18）（19）不区分顺序（20）析构函数二、名词解释1、当类实例化时自动调用的成员函数，负责实现对象的初始化2、按照数据类型分配的内存空间，可以实现方法的调用3、将系统定义的运算符操作对象的类型扩展的过程，一般针对自定义类型4、对象空间释放之前自动调用的函数5、是程序设计思想，相对面向过程而言更加强调封装性6、两个类之间的一种关系，其中一个类的某个成员类型是另一个类三、简答1、C++中类和结构体具有同等的功能，唯一区别是类缺省成员属性是private，而结构体缺省为public2、重载的意义在于丰富了动作的多样性，但是并不加重程序员的负担。
(完整word版)面向对象程序设计(C++)复习题
一选择题（共45题）1．对类的构造函数和析构函数描述正确的是（ ).A.构造函数可以重载,析构函数不能重载√B.构造函数不能重载，析构函数可以重载C.构造函数可以重载，析构函数也可以重载D.构造函数不能重载，析构函数也不能重载2．继承具有（），即当基类本身也是某一个类派生类时,底层的派生类也会自动继承间接基类的成员。
A）规律性 B.传递性√ C.重复性 D。
多样性3．假设OneClass为一个类，则该类的复制初始化构造函数的声明语句为（）。
A.OneClass（OneClass p)；B. OneClass& （OneClass p );C。
OneClass（OneClass & p); √ D. OneClass （OneClass ＊ p)；4．对于结构中定义的成员，其默认的访问权限为（）。
A.public B。
protected C.private D。
static5．下面对静态数据成员的描述中，不正确的是( ）。
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. x.a √9。
对于一个类的构造函数,其函数名与类名( )。
A。
完全相同√ B. 基本相同 C. 不相同 D. 无关系10。
一个类的构造函数通常被定义为该类的（ )成员.A. 公有√B. 保护 C。
私有 D。
友元11. 一个类的析构函数通常被定义为该类的（）成员。
A. 私有 B。
保护 C。
公有√ D。
面向对象程序设计期末复习题资料
面向对象程序设计期末复习题一、单项选择题1．对于类中定义的成员，其隐含访问权限为【 B 】A) public B) private C) static D)protected2．关于类和对象不正确的说法是【 B 】A) 类是一种类型，它封装了数据和操作 B) 一个类的对象只有一个C) 对象是类的实例D) 一个对象必属于某个类3．下面关于对象概念的描述中，【 C 】是错误的。
A)对象代表着正在创建的系统中的一个实体B)对象就是C语言中的结构体变量C)对象是一个状态和操作(或方法)的封装体D)对象之间的信息传递是通过消息进行的4. 使用派生类的主要原因是【 A 】。
A)提高代码的可重用性B)提高程序的运行效率C)加强类的封装性D)实现数据的隐藏5. 有关析构函数的说法不正确的是【D 】A)析构函数有且只有一个B)析构函数无任何函数类型C)析构函数没有形参D)析构函数的作用是在对象被撤消时收回先前分配的内存空间6. 声明一个类的对象时，系统自动调用一个函数；撤消对象时，系统自动调用一个函数；该函数为【 C 】A) 成员函数；构造函数B) 复制构造函数；析构函数C) 构造函数；析构函数D) 析构函数；复制构造函数7. 下列关于运算符重载的描述中，【 D 】是正确的。
A)运算符重载可以改变操作数的个数B)运算符重载可以改变优先级C)运算符重载可以改变结合性D)运算符重载不可以改变语法结构8. 能用友元函数重载的运算符是【 A】。
A)+ B)= C)[] D)->9．当一个派生类私有继承一个基类时，基类中的所有公有成员和保护成员成为派生类的【 A 】A) private成员B) protected成员C) public成员D) 友元10．在C++中，要实现动态联编，必须使用【D】调用虚函数A) 类名B) 派生类指针C) 对象名D) 基类指针11．若一个类中含有纯虚函数，则该类称为【 A 】A) 抽象类B) 纯基类C) 派生类D) 基类12．当使用ifstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式【 B 】A) ios:: out B) ios:: inC) ios::in|ios::out D) ios::binary13.通常拷贝构造函数的参数是【 C 】。
面向对象程序设计复习试题(答案)
语法扩充1.1选择题在C++中用（D）能够实现将参数值带回。
a）数组b）指针c）引用d）上述ABC都可考虑函数原型voidtest(inta,intb=7,char*ch="*"),下面的函数调用中，属于不合法调用的是：（C）A)test(5)B)test(5,8)C)test(6,"#")D)test(0,0,"*")；已知:intm=10；下列表示引用的方法中，正确的是：（C）A)C)在A)对在A)C)A)C)A)intFunc(int，int，int)；B)doubleFunc(int，int)；C)doubleFunc(double，double)；D)doubleFunc(int，double)；下面的哪个保留字不能作为函数的返回类型（C）A)voidB)intC)newD)long一个函数功能不太复杂，但要求被频繁调用，选用（A）。
A.内联函数B.重载函数C.递归函数D.嵌套函数已知函数f的原型为：voidf(int&a,char*b)；变量s,t的定义是：ints；chart[]="ABCD"；把s和t分别作为第一参数和第二参数来调用函数f，正确的调用语句是（C）Af(&s,&t)；Bf(&s,t)；Cf(s,t)；Df(s,&t)；若定义cin>>str;当输入MicrosoftVisualStudio6.0！所得结果是str=（B）。
A、MicrosoftVisualStudio6.0！B、MicrosoftC、MicrosoftVisualD、MicrosoftVisualStudio6.0.函数模板（C）。
A、代表某一具体函数B、与模板函数是同一个函数C、与某一个具体的数据类型连用D在ABCDAC1.21。
23int*&p=c;p=&b;4、假设有如下函数定义:voidFun(intx,inty=100);则语旬Fun(5)语句__Fun(5，100)_等价。
面向对象程序设计复习题库
判断题1. C++中标识符内的大小写字母是没有区别的。
2. C++是一种以编译方式实现的高级语言。
3. 在私有继承中，基类中所有成员对派生类都是不可见的。
4. 在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
5. 使用关键字class定义的类中缺省的访问权限是私有（private）的。
6. 引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。
7. 类封装了数据和操作。
8. 析构函数可以有形参。
9. 派生类至少有一个基类。
10. 全局函数和静态成员函数也能声明为虚函数。
11. 在公有和保护继承方式下，派生类的对象可以对基类的保护成员进行访问12. 友元本身就是类的成员。
13. 一个类只能有一个对象。
14. 构造函数没有函数类型。
15. 构造函数没有函数类型。
16. 只有类的成员函数才能声明为虚函数。
17. 所谓私有成员是指只有类中所提供的成员函数才能直接访问它们，任何类以外的函数对它们的访问都是非法的。
18. For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。
19. 通常的拷贝初始化函数的参数是某个对象的成员名或对象的引用名。
20. 已知：类A中一个成员函数说明如下：void Set(A& a)；其中A& a的含意是将a的地址值赋给变量Set。
选择题1. 一个最简单的C++程序，可以只有一个(2分)A. 库函数B. 自定义函数C. main函数D. 空函数2. C++程序中的简单语句必须以( )结束(2分)A. 冒号B. 分号C. 空格D. 花括号3. 下列选项中，全部都是C++关键字的选项为(2分)A. while IF StaticB. break char goC. sizeof case externD. switch float integer4. 下列正确的字符常量为(2分)A. "a"B. 'name'C. aD. '\101'5. 下列选项中，( )不能交换变量a和b的值。
面向对象程序设计期末复习题及答案
C++面向对象程序设计复习试题类型1、单项选择题(在每小题的四个备选答案中，选出一个正确答案，并将正确答案的序号填在题干的括号内。
15题，每小题2分，共30分) [主要从作业题目中抽出来]2. 填空题。
（10题，每小题3分，共30分）3、阅读程序，写出程序运行结果。
【也称计算题】（3题，每小题5分，共15分）4、程序编制题【也称综合分析题】。
(第1、2题每题8分，第3题9分，共25分) 重点复习内容打*号是重点，打▲号是编程题出题范围* 基本概念，对象，消息，类。
面向对象系统特性，封装性，继承性，多态性。
*▲C++类的构成，类与对象，构造与析构，动态存储，类嵌套。
静态成员，对象数组，友元。
*函数重载。
运算符重载。
*引用定义与引用参数* 基类与派生类的定义。
* 基类及派生类的访问权（含派生类对基类的访问、通过派生类对象对基类的访问）和初始化。
多继承与虚基类。
*多态性与虚函数。
纯虚函数、抽象类。
*▲函数模板。
*▲使用类来定义对象并在程序中的应用题型样题填空题 1. 假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为_________。
答案：102.可以用p.a的形式访问派生类对象P的基类成员a,其中a是_________。
答案：公有继承的公有成员3.能作为重载函数的调用的依据是_________。
答案：参数个数、参数类型4.在进行完任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态；其中只能用于检测输入流是否结束状态的操作函数名称是_________答案：eof5.函数重载是指_________。
答案：两个或两个以上的函数取相同的函数名，但形参的个数或类型不同6.在派生类中重新定义虚函数时必须在_________ 方面与基类保持一致。
答案：参数个数阅读程序例题【计算题】1．分析以下程序的执行结果#include<iostream.h>class Sample{int x,y;public:Sample() {x=y=0;}Sample(int a,int b) {x=a;y=b;}~Sample(){if(x==y)cout<<“x=y”<<endl;elsecout<<“x!=y”<<endl;}void disp(){cout<<“x=”<<x<<“,y”=<<y<<endl;}};void main(){Sample s1,s2(2,3);s1.disp();s2.disp();}解：x=0,y=0x=2,y=3x!=yx=y2.分析以下程序的执行结果#include<iostream.h>int add(int x,int y){return x+y;}int add(int x,int y,int z){return x+y+z;}void main(){int a=4,b=6,c=10;cout<<add(a,b)<<,<<add(a,b,c)<<endl; }解：10,20 3.分析以下程序执行结果#include<iostream.h>int add(int x,int y){return x+y;}double add(double x,double y){return x+y;}void main(){int a=4,b=6;double c=2.6,d=7.4;cout<<add(a,b)<<","<<add(c,d)<<endl; }解：10，104.分析以下程序执行的结果#include<iostream.h>class Sample{int x,y;public:Sample(){x=y=0;}Sample(int a,int b){x=a;y=b;}void disp(){cout<<"x="<<x<<",y="<<y<<endl;}};void main(){Sample s1,s2(1,2),s3(10,20);Sample *pa[3]={&s1,&s2,&s3};for(int i=0;i<3;i++)pa[i]->disp();}解：x=0,y=0x=1,y=2x=10,y=20 5. 分析以下程序的执行结果：#include<iostream.h>class base{int n;public:base(){};base (int a){cout << "constructing base class" << endl; n=a;cout << "n= "<< n << endl;}~base() { cout << "destructing base class" << endl; }};class subs : public base{int m;public:subs(int a, int b) : base(a){cout << "constructing sub class "<< endl; m=b;cout << "m= "<< m << endl;}~subs() { cout << "destructing sub class "<< endl; }};void main (){subs s(1,2);}解：constructing base classn= 1constructing sub classm= 2destructing sub classdestructing base class6.分析以下程序的执行结果:#include <iostream.h>class Sample{protected:int x;public:Sample() { x=0; }Sample(int val) { x=val; }void operator++() { x++; }};class Derived:public Sample{int y;public:Derived():Sample(){ y=0; }Derived(int val1,int val2):Sample(val1){ y=val2; }void operator--(){ x--;y--;}void disp(){cout<<"x="<< x << ",y=" << y << endl; }};void main (){Derived d(3,5);d.disp();d++;d.disp ();d--;d--;d.disp();}解：x=3,y=5x=4,y=5x=2,y=37 分析以下程序执行结果：#include <iostream.h>class A{public:A(char *s) { cout << s << endl; }~A() {}};class B:public A {public:B(char *sl,char *s2) :A(sl){cout << s2 << endl;}};class C:public A{public:C(char *sl,char *s2) :A(sl){cout << s2 << endl;}};class D:public B,public C{public:D(char *sl,char *s2,char *s3,char *s4) :B(sl,s2),C(sl,s3){cout << s4 << endl;}};void main (){D d("class A","class B","class C","class D");}解：class Aclass Bclass Aclass Cclass D 补充例题1.分析以下程序的执行结果#include<iostream.h>template <class T>T max(T x,T y){ return (x>y?x:y); }void main(){ cout<<max(2,5)<<“,”<<max(3.5,2.8)<<endl; }解答：5,3.5 2．分析以下程序的执行结果#include<iostream.h>void main(){int a[]={10,20,30,40},*pa=a;int *&pb=pa;pb++;cout<<*pa<<endl;}解答：输出为:20 3.分析以下程序的执行结果#include<iostream.h>template <class T>T abs(T x){ return (x>0?x:-x); }void main(){ cout<<abs(-3)<<“,”<<abs(-2.6)<<endl; }解答：输出为：3，2.64.分析以下程序的执行结果#include<iostream.h>class Sample{char c1,c2;public:Sample(char a){c2=(c1=a)-32;}void disp(){ cout<<c1<<“转换为”<<c2<<endl; } };void main(){Sample a('a'),b('b');a.disp();b.disp();}解答：a转换为Ab转换为B 5.分析以下程序的执行结果#include<iostream.h>void main(){int a;int &b=a; // 变量引用b=10;cout<<“a=”<<a<<endl;} 解答：输出为：a=10 6.分析以下程序的执行结果#include<iostream.h>class Sample{int x;public:Sample(){};Sample(int a){x=a;}Sample(Sample &a){x=a.x++ +10;}void disp(){cout<<“x=”<<x<<endl; }};void main(){ Sample s1(2),s2(s1);s1.disp();s2.disp();}解答：x=3 // ++运算的结果x=12 // 2+107.分析以下程序的执行结果#include<iostream.h>class Sample{int x;public:Sample(){};Sample(int a){x=a;}Sample(Sample &a){x=a.x+1;}void disp(){cout<<“x=”<<x<<endl; } };void main(){ Sample s1(2),s2(s1);s2.disp();}解答：输出为：x=3。
面向对象程序设计复习总结题(含部分答案)
《面向对象程序设计》复习要点及复习题（一）复习要点1.标识符、基本数据类型（字节数）、构造数据类型、运算符的种类、运算符的优先级和结合性、控制台输入和输出2.三种基本控制结构、if…else语句、switch语句、for语句、while语句、do…while语句、跳转语句；函数参数传递、函数重载、内联函数；标识符的作用域和生存期。
3.类的定义和使用、this指针、构造函数和析构函数、组合技术、静态成员、友元、运算符重载4.指针与数组、二级指针、动态内存的分配与释放、深复制与浅复制、递归。
5.派生类的构造与析构、派生类与基类的赋值兼容、多重继承与虚基类。
6.虚函数与动态绑定、纯虚函数与抽象类(二) 复习题一、单项选择题。
1.在switch语句中，为了结束分支，一般应在每个分支的结尾处加上语句（C）。
A. continueB. gotoC. breakD. default2.说明友元函数的关键字是（D）。
A. inlineB. virtualC. staticD. friend3.下面对指向常量的指针描述正确的是（C）。
A. 只能指向常量B. 指向的数据可以被修改C. 可以指向普通变量D. 必须进行初始化4.友元函数没有（A）。
A. this指针B. 返回类型C. 函数名D. 参数5.关于重载，（A）不正确。
A. 类名可以重载B. 函数名可以重载C. 运算符可以重载D. 缺省参数是重载的一种方式6.用new分配n维数组空间，首地址赋予指针p，则p应为指向（C）维数组的指针。
A. 0B. 1C. n-1D. n7.为类X重载前缀自增运算，则函数返回类型应为（C）。
A. XB. X*C. X&D. int8.以下（A）未调用构造函数（X为类名）。
A. X*p;B. X obj;C. X obj(1);D. X obj=2;9.若在类外有函数调用X：：func()；则函数func是类X的（C）函数。
面向对象程序设计复习题
复习题（一）一、判断题（每题1分，共10分）1．将数据和对数据的操作相结合，形成一个有机的整体，体现了类的封装。
2．类和普通变量不同，可以先使用，后定义。
3．类的static数据成员要在文件作用域内进行定义性说明。
4．可以以”类名:: 静态成员函数(实参表)”的形式调用类的静态成员函数。
5．类定义中，默认的访问权限是private。
6．函数参数是对象的引用时，调用该函数进行参数传递时要调用复制构造函数。
7．运算符重载体现了类的多态性。
这种多态是在运行时完成的。
8．在多层虚拟继承中，如果虚基类没有默认的构造函数，则派生类构造函数的成员初始化列表中应该对列出直接基类和底层的虚基类的初始化。
9．iostream是由istream和ostream共同派生的。
10．在try块中抛出异常后，程序控制不会再执行try块中的后续语句。
二、选择题（每题1分，共10分）1．类O定义了私有函数F1。
P和Q为O的派生类，定义为class P: protected O{…}；class Q: public O{…}。
______可以访问Fl。
A．O的对象B．P类内C．O类内D．Q类内2．设p是指向一个动态申请对象的指针，则delete p;后，将调用______。
A．构造函数B．复制构造函数C．析构函数D．系统指定的成员函数3．A为类。
pa是指向A类对象的指针。
pf是指向A类成员函数int f()的指针。
则通过pa和pf调用f函数的正确形式是______。
A．pa->pf() B．pa->*pf() C．(pa->pf)() D．(pa->*fp)()4．在表达式-(x*y)中，”-”作为成员函数重载，”*”作为友元函数重载。
则正确的描述是______。
A．operator-()有一个参数，operator*()有一个参数。
B．operator-()有一个参数，operator*()有两个参数。
C．operator-()没有参数，operator*()有一个参数。
面向对象程序设计复习题
面向对象程序设计复习题概念填空题1.运算符能够用来访问与局部变量同名的全局变量。
2.运算符动态分配一个对象。
3.类的成员只能被该类的成员函数或友元函数访问。
4.类成员的默认访问模式是的。
5.类的数据成员是该类的所有对象共享的信息。
6.关键字指定了不可修改的对象或变量。
7.要在类的对象上使用运算符,除了运算符和外,其它的必须都要被重载。
8.重载不能改变原运算符的、、和对内部类型对象的原有含义。
9. 类的对象可作为类的对象处理。
10.友元函数中可以直接访问类的和成员。
1l.公有成员函数的集合常称为类的函数。
私有成员函数的集合常称为类的函数。
12.为了访问某个类的私有数据成员,必须在该类中声明该类的。
13. 提供了一种描述通用类的方法。
14.运算new分配的内存要用运算符回收。
15.参数表示重载后缀 ++ 运算符函数。
16.当用受保护的继承从基类派生一个类时,基类的公有成员成为派生类的的成员,基类的受保护成员成为派生类的成员。
17.在C++中,关键字、和用来建立新的数据类型。
18. 限定符用来声明只读变量。
19.函数能够定义一个在不同数据类型基础上完成同一任务的函数。
20.指向基类对象的指针可以指向其派生类的对象，但是不允许指向其派生类的对象。
答案：1:: 2 new 3私有和保护4私有5静态6const 7=& 8 优先级结合性操作数个数9派生类基类10 私有受保护11 接口工具12 友元13 类模板14 delete 15 int 16受保护受保护17class struct union 18 const 19模板20公有私有和保护阅读程序写结果1．#include <iostream.h>void main(){int a(6),b(8),c;c=(a>b?++a:b-=2);cout<<a<<','<<b<<','<<c<<endl;c=(a-b?a+b:a-6?b:a-6);cout<<a<<','<<b<<','<<c<<endl;}输出结果：答案：输出结果：6，6，66，6，02．#include <iostream.h>void main(){int i,j;for(i=11; i<=20 ; i+=2){for(j=2;j<i;j++)if(i%j==0)break;if(j!=i)cout<<i <<" ";}cout<<endl;}输出结果：答案：12 14 15 16 18 3．#include <iostream.h>#include <iostream.h>int f(int p);void main(){int a[]={1,2,3,4,5};for(int i=0;i<5;i++)cout<<f(a[i])<<" ";cout<<endl;}int f(int p){static int s=1;s*=p;return s;}输出结果：答案：1 2 6 24 1204．#include <iostream.h>int f(int *p);void main(){int a[]={1,2,3,4,5}for(int i=0;i<4;i++)cout<<f(a+i)<<”“;cout<<endl;}int f(int *p){static int s=0;s+=*p;return s;}输出结果：答案：1 3 6 10 15 4．#include <iostream.h>void main(){int a[5],x,i=0;do{cin>>x;if(x%2==0){a[i]=x;i++;}}while(i<5);for(i=0;i<5;i++)cout<<a[i]<<" ";cout<<endl;}输入：1 6 5 82 0 7 10输出结果：答案：6 8 2 0 105．#include <iostream.h> class myclass{int a,b;static int s;public:myclass(int i, int j){a=i; b=j;cout<<"Constructor.\n";}~myclass(){cout<<"Destructor.\n";}void sum(){ s+=a*b; }void print(){cout<<a<<","<<b<<”sum=”<<s<<endl;}};int myclass::s =0;void main(){myclass *a1, *a2;a1=new myclass(1,1);a2=new myclass(10,20);(*a1).sum();(*a2).sum();a1->print();a2->print();delete a1;delete a2;}输出结果：答案：Constructor.Constructor.1,1 sum=20110,20 sum=201Destructor.Destructor.6．#include <iostream.h>{int a,b;for(a=1,b=1;b<=10;b++){if(a>=10)break;if(a==1){a+=3;continue;}a-=3;}cout<<"a="<<a<<"b="<<b<<endl;}输出结果：答案：a=1b=117．#include <iostream.h>class A{private:int a,b;public:A(int i, int j){ a=i; b=j; }void move(int m,int n){a+=m;b+=n;}void show(){cout<<"("<<a<<","<<b<<")"<<endl;}};class B: public A{private:int x,y;public:B(int i, int j,int k,int l):A(i,j){ x=k; y=l; }void show(){ cout<<x<<","<<y<<endl; }void fun(){move(30,50);}void f1(){A::show();}};void main(){A e(10,20);e.show ();B b(30,40,50,60);b.fun ();b.show();b.f1();}输出结果：答案：(10,20)50,60(60,90)8. #include <iostream.h>class B{private:int Y;public:B(int y=0) { Y=y; cout<<″B(″<<y<<″)\n″; }～B() { cout<<″～B()\n″;}void print() { cout <<Y<< ″″; }} ;class D: public B{private:int Z;public:D (int y, int z):B(y){ Z=z;cout<<″D(″<<y<<″,″<<z<<″)\n″;}～D() { cout<<″～D()\n″; }void print() {B∶∶print();cout <<Z<<endl;}};void main(){ D d(11,22);d.print();}输出结果：答案：B(11)D(11,22)112~D()~B()9．#include <iostream.h>#include <iomanip.h>void main(){int i,j,k;for(i=1;i<=3;i++) //控制输出行{for(j=1; j<=6-i; j++) //每行前的空格cout<<" "; //输出四个空格for(k=1;k<=i;k++)cout<<setw(4)<<k;for(k=i-1; k>0 ;k--)cout<<setw(4)<<k;cout<<endl;}}输出结果：答案：11 2 11 2 3 2 110. #include <iostream.h>class A{private:double X,Y;public:A(double xx=0, double yy=0){ X=xx; Y=yy;cout<<″构造函数被调用(″<<X<<″,″<<Y<<″)″<<endl;}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,5）构造函数被调用（1,2）11.#include <iostream.h>class Areaclass{public:Areaclass(double x=0,double y=0){height=x;width=y;}protected:double height;double width;};class Box: public Areaclass{public:Box(double h,double w):Areaclass (h,w){ }double Area();};class Triangle:public Areaclass{public:Triangle(double h,double w):Areaclass(h,w){ }double Area( );};double Box::Area(){ return height*width; }double Triangle::Area(){ return width *height *0.5; } void main(){Box obj1(2.5,4.0);Triangle obj2(4.0,3.5);cout<<"Box="<<obj1.Area()<<endl;cout<<"Triangle="<<obj2.Area()<<endl;}输出结果：答案：Box=10Triangle=712. #include<iomanip.h>void main(){ int a［9］={1,2,3,4,5,6,7,8,9};for(int i=0; i<9; i++) {cout << setw(4) << a［i］;if(i%3==2)cout<<endl;}}输出结果：答案：1 2 34 5 67 8 913. #include <iostream.h>template <typename T>void print(T a［］,int n ){ for(int i=0; i<n; i++){ cout<<a［i］<<″″;if (i%5==4)cout<<endl;}cout<<endl;}void main(){int a［］={1, 2, 3, 4, 5, 6, 7};double b［4］={8, 9, 10, 11 };print(a,sizeof(a)/sizeof(int));print(b,4);}输出结果：答案：1 2 3 4 56 78 9 10 1114. #include <iostream.h>class A{private:static int n;int X;public:A(int x=0) { X=x; n++; }～A() { n-- ; }static int GetNum(){ return n; }void print();};void A∶∶print() { cout << ″n=″<< n << ″, X=″<< X<< endl; } int A∶∶n = 0;void main(){ A *p=new A(12);p->print();A a(34);a.print();delete p;cout << ″n=″<< A::GetNum() << endl;}输出结果：答案：n=1,X=12n=2,X=34n=115. #include <iostream.h>void main(void){ int n=6, k;cout << n << " Factors ";for (k=2; k < n; k++)if (n % k == 0)cout << k << " ";cout << endl;}输出结果：答案：6 Factors 2 316. #include <iostream.h>class myclass{private:int x,y;static long sum;public:myclass(int a,int b) { x=a;y=b;}void getxy(){sum*=x*y;cout<<"sum="<<sum<<endl;}};long myclass::sum=1;void main(){myclass ob1(1,3);ob1.getxy();myclass ob2(2,4);ob2.getxy();myclass ob3(5,6);ob3.getxy();}输出结果：答案：sum=3sum=24sum=72017.#include<iostream.h>#include<string.h>void main(){int i;char *max, str[3][10]={"Wang","Zhang","Li"};max=str[0];for(i=0;i<3;i++)if(strcmp(max,str[i])<0)max=str[i];cout<<"The max string is: "<<max<<endl;}输出结果：答案：The max string is: Zhang三、程序填空1.菲波纳齐数列为：1，1，2，3，5，8，13，……；下面是实现计算该数列前10项的程序，请在空白处填入合适的内容。
面向对象程序设计复习题(附参考答案)
【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】机器语言中的指令编码为（）编码。
[A.]二进制[B.1符号[c.1十进制[D.]数字【答案】A【知识点】01106.1.1.1【解析】无【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】JaVa语言的主要特点不包括（）。
[A.]面向对象[B.]自动垃圾回收[CJ处理文件[D.]可移植性【答案】C【知识点】01106.1.1.1【解析】无【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】Java开发工具包简称为（）。
[A.]JKD[B.]JRK[C.]JDK[D.]JRE【答案】C【知识点】01106.1.1.1【解析】无【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】具有相同属性和服务的一组对象的模板称为（）。
1B.]类[c.1代码[D.]概念【答案】B【知识点】01106.1.1.1【解析】无【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】类是对具有共同属性和行为的对象的抽象描述，每个对象称为该类的一个（）。
[A.]产品[B.1元素[c1成分[D.]实例【答案】D【知识点】01106.1.1.1【解析】无【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】Java是一门（）语言。
[A.]机器[B.]汇编[C.）面向过程的高级[D.]面向对象的高级【答案】D【知识点】01106.1.1.1【解析】无【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】使用JDK编译JaVa程序时使用的命令是（）。
面向对象程序设计复习题及参考答案
网络數谋程考试复习题及参考答案面向对象程序设计一、填空题：1.创建类的对象时，使用运算符 ___________ 给对象分配内存空间。
2.Java通过 ______________________________________________ 来区分重载函数。
3.在子类中使用保留字 _____________ 可调用被子类覆盖的父类中的方法。
4•使用保留字_____________ 可以从一个构造方法中调用同一个类的另一个构造方法。
5.抽象类用修饰符 ________________ 定义。
6.类的数摒成员的访问权限修饰符一般为 ____________________7.访问权限修饰符按照访问权限的大小从大到小分别为______________________ . _&定义类的构造方法不能有_________________ ，其需称与 _______________ 名相同。
9.______________________________________________________________________ 抽象方法是的特征是「10.Java中的所有异常都是从_____________________ 继承来的。
11.对象引用中存储的内容是_________________________________ -12 •下列程序段执行后，String strl = new String Java");String str2 = new String(^Java^);if (strl・ equals(str2)) {System・ out. println(z/They are equal");} else {System ・ out. print In ("They are not equal?/);}输出结果为：____________________________________________13.下而循环执行后的sun值为int count =0, sum = 0;whi.le ( count <10 ) {sum += count;count ++;}14.Java语言中关键字______________________ ^表示双精度类型。
面向对象程序设计复习题
一、选择题（每题1分，共30分）1. 下列关于C++语言的描述，哪个是错误的？（）。
A. C++语言支持结构化程序设计方法B. C++语言是解释执行的C. C++语言是编译执行的D. C++语言支持面向对象程序设计方法2. 下列哪种数据类型的存储位数最多？（）。
A. charB. intC. floatD. double3.下列哪个名字可以作为变量名？（）。
A. No.1B. 123ABCC. longD. Long4. 下列定义变量语句中，错误的是（）。
A. int x, y;B. int x = 5, y;C. int x = y = 5;D. int x = 5, y = 5;5. 计算圆形周长的公式是：周长=2πr，其中r为半径。
编写计算圆形周长的程序时需要将什么数据定义成变量？（）。
A. πB. 半径C. 周长D. 半径和周长6. C++语言表达式：5 / 2，该表达式结果的数据类型和值分别是（）。
A. short，2B. int，2C. float，2.5D. double，2.57. 执行C++语句：int x = 5, y = 6, z; z = x++ / --y; 执行后变量x、y和z的值分别为（）。
A. 5, 5, 1B. 6, 5, 1C. 6, 5, 1.2D. 5, 6, 08. 执行下列语句：int x = 5, &y = x; y = x + 10; 执行后变量x的值为（）。
A. 5B. 10C. 15D. 209. 下列定义并使用指针变量px的语句中，正确的是（）。
A. int x, *px; px = 10;B. int x, *px = &x; px = 10;C. int x, *px; *px = 10;D. int x, *px = &x; *px = 10;10. 执行下列C++语句：int x = 15;if (x%2 == 0) cout << x / 2;else cout << x / 2 + 1;显示器上将显示（）。
面向对象程序设计考试复习题
1.面向对象：一种运用对象、类、继承、封装、包含、消息传递、多态性等概念来构造系统的软件开发方法对象：代表正在创建的系统中的一个实体类：具有相同属性和行为特征的若干对象的集合继承：提供了创建新类的一种方法，它的本质特征是行为共享封装：提供一种对数据访问的控制机制，使得一些数据被隐藏在封装体内，因此具有隐藏性包含：复杂类由若干简单类的对象组成成为类的包含关系消息传递：是向对象发出的服务请求多态性：指向不同对象发送同一消息，根据对象的类的不同完成不同的行为2.指针：用来存放某个变量的地址值的一种变量指针的值和类型与一般变量的不同：指针的这种变量所存放的值是某个变量在内存中地址值，指针的类型不是它存放的某个变量的地址值的类型，而是该指针所指向的变量的类型3.引用：某个对象或变量的别名，它不占内存空间它与指针的区别：a指针是变量，引用时变量的别名b指针通过地址间接访问某个变量，引用通过别名直接访问c 引用必须初始化，一旦被初始化后不得再作为其他变量的别名4.实现两个字符串的交换#include<iostream.h>Void mian(){void swap(char *&,char *&);Char *s1=”hello”;Char *s2=”good”;Swap(s1,s2);Cout<<s1<<”\n”<<s2<<endl;}5.类：一种复杂的数据类型，是将不同类型的数据和与这些数据相关的操作封装在一起的集合体定义格式：//说明部分Class<类名>{public：<成员函数和数据成员的说明或实现>Private:<数据成员和成员函数的说明或实现>}；//实现部分<各个成员函数的实现>类的访问权限：公有的，私有的，保护的6.对象：类的实例，任何一个对象都是属于某个已知类的定义格式：<类名><对象名表>；对象的成员表示：<对象名>.<数据成员名><对象名>.<成员函数名>（<参数表>）指向对象的指针的成员表示：<对象指针名>-><数据成员名><对象指针名>-><成员函数名>（<参数表>）7.构造函数的功能：在创建对象时使用特定的值来讲对象初始化特点：构造函数是成员函数，函数体可写在类体内也可写在类体外，它的名字与类名相同，它不指定返回类型，有隐含的返回值，该值由系统内部使用8.析构函数的功能：用来释放对象，在对象删除前做一些清理工作特点：是成员函数，函数体可写在类体内也可写在类体外，它的名字在类名前加~字符，不指定返回类型9.默认构造函数的特点：a是无参数的构造函数b函数名与该类的类名相同c 可以由用户定义，当类中没有定义任何构造函数时系统将自动生成一个函数体为空的默认构造函数d在程序中定义一个没有给定初始值的对象时，系统自动调用默认构造函数创建该对象默认析构函数的特点：a如果一个类中没有定义析构函数，系统将自动生成一个默认析构函数，格式如<类名>：：~<默认析构函数>（）{}b它与用户定义的析构函数具有相同特点，其区别仅在于默认析构函数是系统自动生成的并且是一个空函数10.静态成员和静态对象的不同：静态成员描述类的某个成员的特征，是与类相关的，静态对象描述某个类的对象的作用域静态数据成员的定义：在类体内，在该成员名的类型说明符前加关键字static静态数据成员的引用：格式<类名>：：<静态数据成员名>静态成员函数的特点：在其实现中可以直接引用静态成员，但不能直接引用非静态成员。
面向对象程序设计复习资料
面向对象程序设计期末总复习题一、单项选择题1.下面关于对象概念的描述中，_______是错误的。
〔B〕A.对象代表着正在创立的系统中的一个实体C.对象是一个状态和操作(或方法)的封装体2. 继承机制的作用是：(C)A．信息隐藏B．数据封装C．定义新类D．数据抽象(D)A.析构函数有且只有一个B.析构函数无任何函数类型D.析构函数不能是虚函数(A)A.提高程序的运行效率B.加强类的封装性C.实现数据的隐藏性5.通常拷贝构造函数的参数是__________。
(C)A.某个对象名B.某个对象的成员名C.某个对象的引用名6.如果在基类中将show声明为不带返回值的纯虚函数，正确的写法是________。
(C)A.virtual show()=0；B.virtual void show()；C.virtual void show()=0；D.void show=0 virtual；7.下面关于友元的描述中，错误的选项是_________。
(D)8.在C++中，_________运算符不能重载。
(B)A. +B.？：C.-D.<=9.以下关于运算符重载的描述中，________是正确的。
(D)A.运算符重载可以改变操作数的个数C.运算符重载可以改变结合性10. 在以下函数原型中，可以作为类AA构造函数的是_________(D)A．void AA(int) ; B．int AA( ) ; C．AA(int)const; D．AA(int);11.在声明类时，下面的说法正确的选项是_________。
(C)A.可以在类的声明中给数据成员赋初值C.private，public，protected可以按任意顺序出现D.没有用private，public，protected定义的数据成员是公有成员12.继承具有________，即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。
(B)A.规律性B.传递性C.重复性13.在多重继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规那么___________。
面向对象程序设计考前复习题及答案
简答题1、传统的结构化程序设计的优点和缺点是什么？优点：（1）这种程序设计方法力求算法描述精确。
（2）对每一子过程模块简单进行程序正确性证明。
缺点：（1）这种程序设计方法本质上是面对“过程”的，而“过程”和“操作”又是不稳定和多变的，因此不能干脆反映人类求解问题的思路。
（2）程序代码可重用性差。
程序中除少数标准库函数外，每设计一个程序时，程序员几乎从零做起。
即使重用代码，通常也是通过拷贝或编辑重新生成一份。
（3）维护程序的一样性困难。
该种方法将数据与对数据进行处理的程序代码分别。
2、什么是对象？每个对象都具有属性（Attribute）和方法（Method）这两方面的特征。
对象的属性描述了对象的状态和特征，对象的方法说明白对象的行为和功能，并且对象的属性值只应由这个对象的方法来读取和修改，两者结合在一起就构成了对象的完整描述。
3、什么是消息？在面对对象的程序设计中，由于对象描述了客观实体，它们之间的联系通过对象间的联系来反映。
当一个对象须要另外一个对象供应服务时，它向对方发出一个服务恳求，而收到恳求的对象会响应这个恳求并完成指定的服务。
这种向对象发出的服务恳求就称为消息。
4、什么是多态性？所谓多态性是指当程序中的其他部分发出同样的消息时，根据接收消息对象的不同能够自动执行类中相应的方法。
其好处是，用户不必知道某个对象所属的类就可以执行多态行为，从而为程序设计带来更大便利。
5、什么是面对对象的程序设计方法?这种方法将设计目标从模拟现实世界的行为转向了模拟现实世界中存在的对象及其各自的行为。
在OOP中，将“对象”作为系统中最基本的运行实体，整个程序即由各种不同类型的对象组成，各对象既是一个独立的实体，又可通过消息相互作用，对象中的方法确定要向哪个对象发消息、发什么消息以及收到消息时如何进行处理等。
6、面对对象方法的特点是什么？（1）OOP以“对象”或“数据”为中心。
由于对象自然地反映了应用领域的模块性，因此具有相对稳定性，可以被用作一个组件去构成更困难的应用，又由于对象一般封装的是某一实际需求的各种成分，因此，某一对象的变更对整个系统几乎没有影响。
《面向对象程序设计》期末复习带答案
一、单项选择题1．退出Visual Basic的快捷键是（）。
CA．Ctrl + Q B．Shift + Q C．Alt + Q D．Ctrl + Alt + Q2．以下四个VB的变量名中，不合法的是（）。
CA．Print_Num1 B．Abc% C．Const D．X1_y2_z33设置ADO数据控件RecordSource属性为数据库中的单个表名，则CommandType属性需要设置为（）。
B A．adCmdText B．adCmdTable C．adCmdStoredProc D．adCmdUnknown4设有如下过程：Sub ff( x，y，z )x = y + zEnd Sub以下所有参数的虚实结合都是传址方式的调用语句是（）。
BA.Call ff ( 5，7，z )B. Call ff ( x，y，z )C. Call ff ( 3 + x，5 + y，z )D. Call ff ( x + y，x - y，z )5．菜单的热键指使用Alt键和菜单标题中的一个字符来打开菜单，建立热键的方法是在菜单标题的某个字符前加上一个（）字符。
CA．% B．$ C．& D．#6．函数Int( 76 * RND() )的值是在（）范围内的整数。
CA. [1,75]B. [1,76]C. [0,75]D. [0,76]7．以下能够触发文本框Change事件的操作是（）。
DA. 文本框失去焦点B.文本框获得焦点C. 设置文本框的焦点D.改变文本框的内容8．设组合框Combo1 中有3个项目，则以下能删除最后一项的语句是（）。
BA．Combo1.RemoveItem Text B．Combo1.RemoveItem 2C．Combo1.RemoveItem 3 D．Combo1.RemoveItemCombo1.Listcount9．要使菜单项Menu1在程序运行时失效，使用的语句是（）。
DA．Menu1.Visible=True B．Menu1.Visible =False C．Menu1.Enabled=True D．Menu1.Enabled=False10．以下叙述中错误的是（）。
面向对象程序设计复习题汇总
1《面向对象程序设计》复习题一、单项选择题1. （）是面向对象系统包含的要素。
A、类B、多态C、友元D、重载答案：A2. 下列对常量的定义中，错误的是（）。
A、MyClass const obj(3,4;B、char * const p="hello";C、int i=1; const int &ref=i;D、void show( const;答案：C常量的定义：1常对象Const 类名对象名【（实参列表）】类名 Const 对象名【（实参列表）】2 常数据成员Const 类型常数据成员3 常成员函数类型成员函数名 Const4 指向对象的常指针类名 * Const 指针变量名=对象地址5 指向常变量的指针变量 Const 类型名 * 指针变量名3. 若有如下函数声明：void Fun(int x;，则下列（）能与该函数进行重载。
A、void Fun(int y;B、void Fun(int x,int y='1';C、int Fun(int x;D、void Fun(int const;答案：D4. 下列对构造函数和析构函数的描述中，错误的是（）。
A、构造函数可以重载B、析构函数名与类名相同C、构造函数中可以设置参数的缺省值D、类中只有一个析构函数答案：B5. 下列对友元的描述中，错误的是（）。
A、友元破坏了类的封装性B、友元提高了程序的运行效率C、友元可以在类外声明和定义D、友元能够访问类中的私有成员答案：C6. 下列对继承的描述中，正确的是（）。
A、派生类对象能够访问基类的公有成员B、派生类继承了基类的公有成员和保护成员C、派生类对象不能访问基类的保护成员D、派生类不改变基类成员的访问权限答案：C7. 程序中，编译时出错的语句是（）。
class Base{ };class Derived : public Base { };Derived objD1;Base objB=objD1; //ABase *pb=&objD1; //BBase &refB=objD1; //CDerived objD2=objB; //D答案：B8. 下面对派生类的描述中，正确的是（）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
v1.0 可编辑可修改《面向对象程序设计》复习题一、单项选择题1.（A）是面向对象系统包含的要素。
A、类B、多态C、友元D、重载2.下列对常量的定义中，错误的是（ C ）。
A、MyClass const obj(3,4);B、char * const p="hello";C、int &ref=2;D、void show() const;3.若有如下函数声明：void Fun(int x);，则下列（D ）能与该函数形成重载。
A、void Fun(int y);B、void Fun(int x,int y='1');C、int Fun(int x);D、void Fun(int) const;4.下列对构造函数和析构函数的描述中，错误的是（ B ）。
A、构造函数可以重载B、析构函数名与类名相同C、构造函数中可以设置参数的缺省值D、类中只有一个析构函数5.下列对友元的描述中，错误的是（ C ）。
A、友元破坏了类的封装性B、友元提高了程序的运行效率C、友元可以在类外声明和定义D、友元能够访问类中的私有成员6.下列对继承的描述中，正确的是（ A ）。
A、公有派生类对象能够访问基类的公有成员B、派生类只继承了基类的公有成员和保护成员C、派生类对象不能访问基类的保护成员D、派生类不改变基类成员的访问权限7.程序中，编译时出错的语句是（D ）。
class Base{ };class Derived : public Base { };Derived objD1;Base objB=objD1; 数据成员 C.构造函数 D.静态成员函数分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作；28：下列表达方式正确的是（）。
A．class P{ B． class P{public： public：int x=15； int x；void show(){cout<<x；} void show(){cout<<x；}}； }C． class P{ D. class P{int f; public：}； int a；f=25； void Seta (int x) {a=x;}};答案：D分析：在类体内不可对数据成员进行初始化；类定义结束时需用分号；只有类中的成员函数才能存取类中的私有数据。
29：拷贝构造函数具有的下列特点中，（）是错误的。
A．如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的B．拷贝构造函数至少有一个参数，并且是该类对象的引用C．拷贝构造函数是一种成员函数D．拷贝构造函数的名字不能用类名答案：D分析：如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的；拷贝构造函数至少有一个参数，并且是该类对象的引用；拷贝构造函数的名字与类同名，并且不被指定返回类型；拷贝构造函数是一种成员函数。
A．静态成员可分为静态数据成员和静态成员函数B．静态数据成员定义后必须在类体内进行初始化C．静态数据成员初始化不能在构造函数中完成D．静态成员函数中不能直接引用非静态成员答案：B分析：静态成员可分为静态数据成员和静态成员函数；静态数据成员被定义后，必须对它进行初始化，初始化在类体外进行，一般放在该类的实现部分最合适，也可以放在其他位置，例如，放在主函数前面等；静态数据成员初始化与该类的构造函数和析构函数无关；在静态成员函数的实现中，可以直接引用静态成员，但不能直接引用非静态成员。
31：关于友元的描述中，（）是错误的。
A．友元函数是成员函数，它被说明在类体内B．友元函数可直接访问类中的私有成员C．友元函数破坏封装性，使用时尽量少用D．友元类中的所有成员函数都是友元函数答案：A分析：友元函数是非成员函数，在类体内说明了，在类体外定义，定义和调用等同于一般的普通函数；由于它可以直接访问类的私有成员，因此破坏了类的封装性和隐藏性，尽量少用。
二、填空题1.下列运算符既可以作为类的成员函数重载，也可以作为类的友元函数重载，请在表格中的空1.答案: (1) +(b) (2) operator +(a,b)(3) ++() (4) operator –(a)2.下列程序执行后的输出结果是12,21,22，请将下列程序补充完整。
#include <>void fun1( (1) , int b) { int c; c=a; a=b; b=c; }void fun2( (2) , int *b) { int c; c=*a; (3) ; *b=c; }void fun3( (4) , int b) { int c; c=a; (5) ; b=c; }void main(){int x,y;x=1; y=2; fun1(x,y); cout<<x<<y<<',';x=1; y=2; fun2(&x,&y); cout<<x<<y<<',';x=1; y=2; fun3(x,y); cout<<x<<y<<endl;}2.答案: (1) int a (2) int *a (3) *a=*b(4) int &a (5) a=b3.下列程序执行后的输出结果是B0 D00 B1 D23 ~D ~B ~D ~B，请将下列程序补充完整。
class Base {public:Base(int i=0) {x = i; cout<<'B'<<x<<' ';}~Base() { cout<<"~B"<<x<<' '; }private:int x;};class Derived : public Base {int y, z;public:__________________(1)________________________员名”的形式访问的对象成员仅限于被声明为 (1) 的成员；若要访问其他成员变量，需要通过 (2) 函数或 (3) 函数。
答案：(1) public (2) 成员 (3)友元分析：类体内的数据成员可声明为公有的、私有的和保护的，公有的数据成员可利用“对象名.成员名”形式来进行访问；私有的数据成员能被类中的成员函数或友元函数所调用；保护的数据成员可以在类体中使用，也可以在派生类中使用，但不能在其他类外通过对象使用。
三、写程序结果题1.#include <>class Test {public:Test (double m,double n,double d):p(d) { x=m; y=n; }void Show();void Show() const;private:double x, y;const double p;};void Test::Show() {cout<<x<<","<<y<<endl;cout<<"p="<<p<<endl;}void Test::Show() const {cout<<x<<","<<y<<" const"<<endl;cout<<"p="<<p<<" const"<<endl;}void main() {Test a,,;();const Test b,,;();}答案：p=constp= const2.#include <>class A{public:A(int i){ cout<<"Constructor"<<endl; p=new int(i);}A(A& r){cout<<"Copy constructor"<<endl; p=new int;}~A(){cout<<"Destructor"<<endl; delete p;}A& operator =(A& r);void output() {cout<<*p<<endl;};private:int *p;};A& A::operator =(A& r) {cout<<"Assignment"<<endl;if(this==&r) return *this;delete p;p=new int;return *this;};void main(){A a(5);A b=a;A c(6);c=a;();};答案：ConstructorCopy constructorConstructorAssignment5DestructorDestructorDestructor3.#include <>class Base1{public:Base1(int x) { cout<<"Base1's con. "<<x<<endl; }~Base1() { cout<<"Base1's des. "<<endl; }};class Base2{public:Base2(int x) { cout<<"Base2's con. "<<x<<endl; }~Base2() { cout<<"Base2's des. "<<endl; }};class Derived : public Base2,public Base1{public:Derived(int x,int y):Base1(y),Base2(x) { cout<<"Derived's con."<<endl; }~Derived() { cout<<"Derived's des."<<endl; }};void main(){Derived obj(1,2);}答案：Base2's con. 1Base1's con. 2Derived's con.Derived's des.Base1's des.Base2's des.4．# include <>class A {int a,b;public :A() {a=b=0;cout<<"Default Constructing Object"<<' '<<a<<' '<<b<<endl;}A(int aa,int bb) {a=aa; b=bb;cout<<" Constructing Object"<<' '<<a<<' '<<b<<endl;}~A() {cout<<"Destructing Object"<<' '<<a<<' '<<b<<endl;}};void main(){A x,y(2,3),z(4,5);}答案：Default Constructing Object 0 0Constructing Object 2 3Constructing Object 4 5Destructing Object 4 5Destructing Object 2 3Destructing Object 0 05． # include <>template <class TT>class FF {TT a1,a2,a3;public :FF(TT b1,TT b2,TT b3) {a1=b1; a2=b2; a3=b3;}TT Sum() { return a1+a2+a3; }};void main(){FF <int> x(2,3,4),y(5,7,9);cout <<()<<' '<<()<<endl;}答案：9 216：分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。