面向对象程序设计复习题
面向对象程序设计复习题
一、单项选择题。
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.下列（C）的调用方式是引用调用。
A.形参和实参都是变量B.形参是指针，实参是地址值C.形参是引用，实参是变量D.形参是变量，实参是地址值2.假定CTest为一个类，并且有一无默认值的的有参构造函数和一无参构造函数，则执行“CTest objTest;”语句时将自动调用该类的（B）。
A.有参构造函数B.无参构造函数C.复制构造函数D.赋值构造函数3.假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a 的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（D）。
A.x.aB.x.a()C.x->GetValue()D.x.GetValue()4.C++编译系统确定调用是具体对象的过程称为关联。
C++有（B）关联。
A.1种B.2种C.3种D.4种5.下面有关重载函数的说法中正确的是（C）。
A.重载函数必须具有不同的返回值类型B.重载函数形参个数必须不同C.重载函数必须有不同的形参列表D.重载函数名可以不同6.如果表达式a==b中的“==”是作为普通函数重载的运算符，若采用运算符函数调用格式，则可表示为（C）。
A.a.operator==(b)B.b.operator==(a)C.operator==(a,b)D.operator==(b,a)7.下列对继承关系的描述中，（D）是正确的。
A.在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的；B.在公有继承中，基类中只有公有成员对派生类的对象是可见的；C.在私有继承中，基类中只有公有成员对派生类是可见的；D.在私有继承中，基类中的保护成员对派生类的对象是可见的；8.定义p并使p指向动态空间中的包含30个整数的数组所使用的定义语句为（A）。
A.int *p=new int[30];B.int *p=new int(30);C.int *p=new [30];D.*p=new int[30];9.在一个类中可以对一个运算符进行（D）重载。
面向对象程序设计复习题(专升本)
《面向对象程序设计》复习题（专升本）一、填空题1.当建立，程序自动调用该类的构造函数。
2.3.模板对处理数据的类型的要求不同可以分为两种类型：和。
4.5.6.面向对象程序设计的机制提供了重复利用程序资源的一种途径。
7.8.定义模板的关键字是。
9.对象的核心概念就是通常所说的、、。
10.面向对象的英文缩写是：。
11.在面向对象程序设计中，具有相同属性和服务的一组对象的集合称为。
12.已知X=2,y=3,x<y的值是：。
13.#include<iostream>命令中，include的意义是：。
14.C++语言中的每条基本语句以作为结束符。
15.假定一个一维数组的定义为char a[8]；则该数组所含元素的个数为，所占存储空间的字节总数为。
16.条件1≤x＜10用逻辑表达式表示为。
17.C++程序主要有三种基本控制结构，分别是顺序结构、条件分支结构和。
18.对一个类中的数据成员的初始化，可以通过来实现，也可以通过来实现。
19.假定AB为一个类，则执行AB a（10）；语句时，系统自动调用该类的构造函数的次数为。
二、选择题1、 C++对C语言作了很多改进，下列描述中（）使得C语言发生了质变，从面向过程变成了面向对象。
A、增加了一些新的运算符；B、允许函数重载，并允许设置缺省参数；C、规定函数说明必须用原型；D、引进了类和对象的概念；2、所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是( )。
A.类B.对象C.函数体D.数据块3、关于new运算符的下列描述中，（）是错误的。
A、它可以用来动态创建对象和对象数组；B、使用它创建的对象或对象数组可以使用运算符delete删除；C、使用它创建对象时要调用构造函数；D、使用它创建对象数组时必须指定初始值；4、（）不是构造函数的特征。
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 】。
面向对象程序设计期末复习题及答案
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）函数。
面向对象程序设计技术复习题.docx
《面向对象程序设计技术》复习题一、单项选择题(将正确答案选项的字母填入答题纸的表格中，每小题2分，共20分)1．对象是构成现实世界的一个独立单位，它具有自己的静态特征和（）特征。
A. 颜色 B. 动态 C. 状态 D. 重量2．使用JDK编译Java程序时使用的命令是（）。
A. javaB. javacC. appletviewerD. javadoc3．在Java程序中包含主方法的类被称为主类，主方法的访问控制修饰符为（）。
A. privateB. protectedC. publicD. static4．在类的定义中，若需要把一个标识符定义为常量，则使用的修饰符为（）。
A. constB. finalC. staticD. class5．在程序中声明包的语句关键字为（）。
A. volatileB. packC. importD. package6．组成Java程序的最小单位是（）。
A. 类B. 方法C. 变量D. 常量7．在Java程序中包含主方法的类被称为主类，主方法名为（）。
A. MainB. mainC. voidD. args8．在Java程序中包含主方法的类被称为主类，主方法的访问控制修饰符为（）。
A. privateB. protectedC. publicD. static9．在程序中引入包的语句关键字为（）。
A. volatileB. packC. importD. package10．具有（）访问权限的成员能够被本类和任何其他类中的成员所访问。
A. publicB. protectdC. privateD. 缺省11. 具有相同属性和服务的一组对象的模板称为（）。
A. 程序B. 类C. 代码D. 概念12. 把对象的属性和服务组合成一个独立的整体，尽可能隐蔽其内部的细节，这称为对象的（）。
A. 封装性B. 多态性C. 继承性D. 开放性13．使用JDK编译Java程序时使用的命令是（）。
面向对象程序设计复习题(附参考答案)
【题目】【题型：单选题】【难度：中】【考核能力：理解】【漏选得分：是】【自动判分：是】【应用类别：终考】【特殊标签：】机器语言中的指令编码为（）编码。
[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程序时使用的命令是（）。
面向对象程序设计复习资料（可编辑修改word版）
面向对象程序设计复习资料（可编辑修改word版）面向对象程序设计期末总复习题一、单项选择题1.下面关于对象概念的描述中，是错误的。
（B）A.对象代表着正在创建的系统中的一个实体B.对象就是C 语言中的结构体变量C.对象是一个状态和操作(或方法)的封装体D.对象之间的信息传递是通过消息进行的2.继承机制的作用是：(C)A.信息隐藏B．数据封装C．定义新类D．数据抽象3.有关析构函数的说法不正确的是(D)A.析构函数有且只有一个B.析构函数无任何函数类型C.析构函数没有形参D.析构函数不能是虚函数4.友元的作用之一是(A)A.提高程序的运行效率B.加强类的封装性C.实现数据的隐藏性D.增加成员函数的种类5.通常拷贝构造函数的参数是。
(C)A.某个对象名B.某个对象的成员名C.某个对象的引用名D.某个对象的指针名6.如果在基类中将show 声明为不带返回值的纯虚函数，正确的写法是。
(C)A.irtual show()=0；B.virtual void show()；C.virtual void show()=0；D.void show=0 virtual；7.下面关于友元的描述中，错误的是。
(D)A.友元函数可以访问该类的私有数据成员B.一个类的友元类中的成员函数都是这个类的友元函数C.友元可以提高程序的运行效率D.类与类之间的友元关系可以继承8.在C++中，运算符不能重载。
(B)A. +B.？：C.-D.<=9.下列关于运算符重载的描述中，是正确的。
(D)A.运算符重载可以改变操作数的个数B.运算符重载可以改变优先级C.运算符重载可以改变结合性D.运算符重载不可以改变语法结构10.在下列函数原型中，可以作为类AA 构造函数的是(D)A.void AA(int) ; B．int AA( ) ; C．AA(int)const; D．AA(int);11.在声明类时，下面的说法正确的是。
(C)A.可以在类的声明中给数据成员赋初值B.数据成员的数据类型可以是 registerC.private，public，protected 可以按任意顺序出现D.没有用private，public，protected 定义的数据成员是公有成员12.继承具有，即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。
面向对象程序设计复习题库
判断题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的值。
面向对象程序设计复习题及参考答案
网络數谋程考试复习题及参考答案面向对象程序设计一、填空题：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. 一个设计得好的面向对象系统具有（B）特征。
A 低内聚、低耦合B 高内聚、低耦合C 高内聚、高耦合D 低内聚、高耦合2. 面向对象程序设计的特点主要概括为（C）。
A 可分解性、可组合性、可分类性B 继承性、封装性、多态性C 抽象封装性、继承性、多态性D 封装性、易维护性、可扩展性、可重用性3. 关于C#程序的书写，下列不正确的说法是( D )。
A. 区分大小写B. 一行可以写多条语句C. 一条语句可写成多行D. 一个类中只能有一个Main()方法，因此多个类中可以有多个Main()方法4. 关于C#语言的基本语法，下列哪些说法正确的是（C）A. C#语言使用using 来引用需要用到的命名空间；B. 用C#编写的程序中，Main 函数是唯一允许的全局函数；C. C#语言中使用的名称严格区分大小写；D. C#中一条语句必须写在一行内；5 以下标识符中，正确的是（A）。
A._nNameB. typeofC. 6bD. x5#6.字符串连接运算符包括&和（A）。
A. +B. -C. *D. /7.拆箱是关于：（B）A、值类型到引用类型的转换B、引用类型到值类型的转换C、引用类型到引用类型的转换D、值类型到值类型的转换8.装箱是关于：（A）A、值类型到引用类型的转换B、引用类型到值类型的转换C、引用类型到引用类型的转换D、值类型到值类型的转换9．下列引用类型和值类型描述正确的是（A）。
A. 引用类型变量保存内存地址，值类型直接保存变量值B. 引用类型在变量中直接保存变量值，值类型保存内存地址C. 引用类型和值类型保存数据的方式相同D. .NET Framework不支持值类型，因为所有的类型都是引用类型了10.一个类中的静态方法的调用可以：(A)A、通过类名调用B、通过实例化的对象调用C、在主方法中直接调用D、在同一个类中的某一方法中直接调用11.以下数据类型中，属于引用类型的是：(A)A、string类型B、double类型C、int类型D、 char类型12.下列类型中为值类型的是(C)A. 字符串类型B. 树组类型C. 枚举类型D. 接口类型13.decimal类型和浮点类型都可以表示小数，正确说法：(C)A. 两者没有任何区别B. 小数类型比浮点类型取值范围大C.小数类型比浮点类型精度高D. 小数类型比浮点类型精度低14. 有定义语句：int [,]a=new int[5,6]; 则下列正确的数组元素的引用是(C)。
面向对象程序设计复习题
面向对象程序设计复习题一、概念填空题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 int16受保护受保护17class struct union 18 const19模板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{private: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>class Date{private:int year;int month;int day;public:Date(int y, int m,int d){year=y;month=m>0&&m<13?m:0;switch(month){case 0:d=0;break;case 1:case 3:case 5:case 7:case 8:case 10:case 12: day= (d>0&&d<32?d:0);break;case 4:case 6:case 9:case 11: day= (d>0&&d<31?d:0);break;case2: day= (isleapyear()?(d>0&&d<30?d:0):( d>0&&d<29?d:0));break;}}int isleapyear(){return !(year%4!=0||year%400==0&&year%100!=0);}void print(){if(year<0)cout<<"公元前"<<-year<<"年";elsecout<<"公元"<<year<<"年";if(month)cout<<month<<"月";elsecout<<"月份不详！";if(day)cout<<day<<"日";elsecout<<"日期不详！";cout<<endl;}};void main(){Date d1(1949,10,1),d2(2004,2,29),d3(-996,4,31);d1.print();d2.print();d3.print();}输出结果：公元1949年10月1日公元2004年2月29日公元前996年4月日期不详！7．#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>class Point{private:int xcord,ycord;public:Point (int x, int y){ xcord =x; ycord =y; }void move(int x1,int y1){xcord +=x1;ycord +=y1;}void show(){cout<<"("<< xcord <<","<< ycord <<")";}};class Circle: public Point{private:int radius;public:Circle (int x, int y,int r): Point (x,y){ radius=r; }void show(){ cout<<"圆心坐标："; Point::show();cout<<"半径："<< radius <<endl;} };void main(){Circle c(10,20,5);c.show ();c.move(-5,5);c.show();}输出结果：圆心坐标：(10,20)半径：5圆心坐标：(5,25)半径：510. #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 A {public:virtual void f() { cout<<″A::f()\n″; }};class B:public A{private:char *buf;public:B(int i) {buf=new char［i］;}void f() {cout<<″B::f()\n″;}～B() { delete ［］buf; }};void main(){ A *a=new A;a->f(); delete a;a=new B(15); a->f();}输出结果：A::f()B::f()12. #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 B {public:virtual int f() { return 0; }};class D: public B {public:int f() { return 100; }};void main() {D d;B& b = d;cout << b.f() << endl;cout << b.B::f() << endl;}输出结果：100三、程序填空1.菲波纳齐数列为：1，1，2，3，5，8，13，……；下面是实现计算该数列前10项的程序，请在空白处填入合适的内容。
面向对象程序设计复习题汇总.doc
A、对象是类的一个实例B、任何一个对象只能属于一个具体的类C、一个类只能有一个对象D、类与对象的关系和数据类型和变量的关系相似19、有以下类的说明，请指出错误的地方（）。
面向对象程序设计考前复习题及答案
简答题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．以下叙述中错误的是（）。
面向对象程序设计复习题
一选择题（共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.publicB. protectedC.privateD. 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->aD. x.a √9. 对于一个类的构造函数，其函数名与类名( )。
A. 完全相同√B. 基本相同C. 不相同D. 无关系10. 一个类的构造函数通常被定义为该类的( )成员。
A. 公有√B. 保护C. 私有D. 友元11. 一个类的析构函数通常被定义为该类的( )成员。
A. 私有B. 保护C. 公有√D. 友元12. 一个类的静态数据成员所表示属性 ( )。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
0) -a a.operator - ( ) (4) (2) operator +(a,b) 1. 答案: (1) a.operator+(b) (3) a.operator++(0) (4) operator –(0)
2. 下列程序执行后的输出结果是12,21,22，请将下列程序补充完整。 #include <iostream.h> 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=b 3. 下列程序执行后的输出结果是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)________________________// Constructor
《面向对象程序设计》复习题
1、 单项选择题 1. （ A ）是面向对象系统包含的要素。 A、类 B、多态 C、友元 D、重载 2. 下列对常量的定义中，错误的是（ C ）。 A、MyClass const obj(3,4); B、char * const p="hello"; C、int i=1; const int &ref=i; 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. 下列对继承的描述中，正确的是（ C ）。 A、派生类对象能够访问基类的公有成员 B、派生类继承了基类的公有成员和保护成员 C、派生类对象不能访问基类的保护成员 D、派生类不改变基类成员的访问权限 7. 程序中，编译时出错的语句是（B ）。 class Base{ };
Test a(8.9,2.5,3.1416); a.Show(); const Test b(2.5,8.9,3.14); b.Show(); } 答案：8.9 2.5 p=3.1416 2.5 8.9 const p=3.14 const 2. #include <iostream.h> class A{ public: A(int i){ cout<<"Constructor"<<endl; p=new int(i);} A(A& r){cout<<"Copy constructor"<<endl; p=new int(*r.p);} ~A(){cout<<"Destructor"<<endl; delete p;} A& 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(*r.p); return *this; }; void main(){ A a(5); A b=a; A c(6);
__________________(2)________________________// Destructor }; void main() { Derived obj1; Derived obj2(1,2,3); } 3. 答案：(1) Derived(int a=0,int b=0,int c=0): Base(a) { y=b; z=c; cout<<'D'<<y<<z<<' ';} (2) ~Derived() { cout<<"~D "; } 3、 阅读程序题 1. #include <iostream.h> 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() {
class Derived : public Base { }; Derived objD1; Base objB=objD1; //A Base *pb=&objD1; //B Base &refB=objD1; //C Derived objD2=objB; //D 8. 下面对派生类的描述中，正确的是（ B ）。 A、派生类是对基类的具体化 B、一个派生类可以作为另一个派生类的基类 C、派生类只能有一个直接基类 D、派生类的缺省继承方式是public 9. 实现动态联遍必须通过（A ）调用虚函数。 A、对象引用 B、成员名限定 C、对象名 D、构造 函数 10. C++流中重载的运算符>>，是一个（B ）。 A、用于输出操作的非成员函数 B、用于输入操作的非成 员函数 C、用于输出操作的成员函数 D、用于输入操作的成员函 数 11. （ A ）不是面向对象系统包含的要素。 A、多态 B、对象 C、类 D、继承 12. 下列对常量的定义中，错误的是（ C ）。 A、int const size=10; B、char * const p="Good Luck"; C、void const print(); D、const MyClass obj(10,10); 13. 设Address表示整型变量x的地址，则下列语句执行后的输出结果为 （D ）。 int x=100,&r=x; cout<<x<<'-'<<r<<endl; A、Address-100 B、100-Address C、Address-Address D、100-100 14. 若函数原型为void Fun(int x=9,int y=8,char z='7')，则下列调用错误