面向对象程序设计复习题
面向对象程序设计复习题
一、单项选择题。
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.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）选择题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、重载的意义在于丰富了动作的多样性，但是并不加重程序员的负担。
面向对象程序设计期末复习题资料
面向对象程序设计期末复习题一、单项选择题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 】。
面向对象程序设计复习题及参考答案
20.Java语言中，通常把可能发生异常的方法调用语句放到try块中，并用紧跟其后的块来捕
获和处理异常。
21.多态是指。
22.声明常量时使用修饰符。
23.Java中异常抛出使用保留字。
24.一个类成员或者方法前面加上了修饰符，那说明该数据成员和方法可以直接通过类名
来访问和调用。
25.如果类成员前面没有访问权限修饰符，则该类成员具有访问权限。
4.构造器方法有什么特点和作用？
5.保留字throw和throws有什么区别？
6.将下面的while循环改写为for循环
int count=1,sum= 0;
while ( cou nt <= 30 ) {
sum += count;
count +=3;
}
7.Java语言编译和执行的过程是？
8.检查型异常和非检查型异常有何区别？
9.请改造下面的构造方法，使第一个构造方法调用第二个构造方法。
public Class On e(i nt alpha) {
this.alpha = alpha;
this.beta = 0;
}
public Class On e(i nt alpha , int beta) {
this.alpha = alpha;
}
public int getCount(){
return count;
}
}
2.int gradeLevel;
switch (gradeLevel){
case1:System.out.print("Go to the101");
case2:System.out.print("Go to202");
面向对象程序设计期末复习题及答案
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＋＋的控制结构（）A 顺序结构B 选择结构C 循环结构D 判断结构答： D2、下列是C++语言中合法标识符的是（）。
A．3three B.ifC._1oneD.while答：C3、下列是合法的C++语言语句的是（）。
A.if(x>0) then x=x-1;else x=x+1;B.if(x>0) x=x-1;else x=x+1;C.if x>0 x=x-1;else x=x+1;D.if x>0 x=x-1;答：B4、下面那一种不是计算机内部表示整数的方法（）A 二进制码B原码C 补码D反码答：A5、在C++语言中，下列数为合法的实数的是（）。
A.5E-3B.5E-3.5C. E5D.-3.5E答：A6、C++语言中数据类型最大的是（）A longB floatC intD char7、如果一个函数可以在定义中直接或间接的调用自己，这样的函数称为（）。
A.函数声明B.嵌套函数C.定义函数D.递归函数答：D8、表达式0x55^0xB4的结果为（）。
A.0xF5B.0x15C.0xE1D.0x1E答：C9、C＋＋中，源代码文件后缀为（）A .cppB .objC .exeD .c答： A10、0X5A&0XB7结果是（）A 0X13B 0X12C 0X14D 0X15答： B二、填空题1、程序的基本控制结构包括（）、（）和（）。
答：顺序结构，选择结构，循环结构2、用来解决问题的，与有限多个步骤组成的具体过程称为（）。
答：算法3、整数类型变量a和b被初始化为3和10，则循环语句while(a<=b) a=a+2;共执行（）次，执行完语句后a的值为（），b的的值为（）。
答：4，11，10）。
答：警告信息，致命错误5、计算机中的数据可以分为（）和（）两大类。
答：数值型、字符型6、字符型数据有两种编码方法：（）和（）答：有美国国家标准局制定的ASCII码、IBM公司提出的EBCDIC码7、通过C++ 语言中的（）机制，可以从现存类中构建其子类。
面向对象程序设计复习题及参考答案
网络數谋程考试复习题及参考答案面向对象程序设计一、填空题：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.引用：某个对象或变量的别名，它不占内存空间它与指针的区别：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. 运算符能够用来访问与局部变量同名的全局变量。
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项的程序，请在空白处填入合适的内容。
《面向对象程序设计》期末复习带答案
一、单项选择题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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、填空题（10题，共10分）1. 行尾使用注释的开始标记符为 // 。
2. 多行注释的开始标记符和结束标记符分别为 /* 和 */ 。
3. 用于输出表达式值的标准输出流对象是 cout 。
4. 用于从键盘上为变量输入值的标准输入流对象是 cin 。
5. 在C++程序中包含一个头文件或程序文件的预编译命令为 #include 。
6. 程序中的预处理命令是指以 # 字符开头的命令。
7. 一条表达式语句必须以分号作为结束符。
8. C++语言的类是一种用户自己定义的数据类型，组成这种类型的不仅可以具有数据，而且可以有对数据进行操作的函数，具有这种类型的变量被称为对象。
9. C++支持两种多态性，即编译时的多态性和运行时的多态性、前者通过使用函数重载和运算符重载获得、后者通过使用继承和虚函数获得。
10. 在C++中，通过对象名访问一个对象的成员所用的运算符是 . ，访问一个指针所指向的对象的成员所用的运算符是 -> 。
11. 定义类的动态对象数组时，系统只能够自动调用该类的复制/拷贝构造函数对其进行初始化。
12. 无论是什么继承方式，派生类的成员不能访问基类 private 属性的成员。
13. 基类的公有成员在派生类中的访问权限由继承方式决定。
14. C++中，构造函数的名字和类的名字相同。
15. 假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为 10次。
16. 表达式cout<<end1还可表示为cout<<” /n ”;。
17. C++中语句const char * const p=〃hello〃；所定义的指针p和它所指的内容都不能被修改。
18. 派生类从一个或多个以前定义的该类的基类继承数据和函数。
19. 设px是指向一个类的动态分配的对象的指针变量，则执行“delete px；”语句时，将自动调用该类的析构函数。
20. 若需要把一个函数“void F( )；”定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句： friend void F(); 。
二、单项选择题（每题2分，共30分）1. 定义一个类的友元函数的主要作用是( A )A 允许在类外访问类中的私有成员；B 允许在类外访问类中的所有成员；C 能够被类的成员函数调用；D 能够被类的派生类的成员函数调用；2. 设有以下定义：class Circle : public Point {double r ;public:… …}则正确得描述为( C )A Point 是 Circle 的派生类B r 是 Point 的数据成员C Circle 是 Point 的派生类D r 是类 Circle 和类 Point 共同的数据成员3. 若有类定义:class Term{……public:int addterm();};作用域运算符 :: 使用正确的是( B )。
A int::Term addterm(){ … }B int Term::addterm(){ … }C int Term addterm::(){ … }D int Term addterm()::{ … }4. 类的析构函数是一个对象被( B )时自动调用的。
A 建立B 撤消C 赋值D 引用5. 一个类的构造函数通常被定义为该类的( A )成员。
A 公用B 保护C 私有D 友元6. 一个类的析构函数通常被定义为该类的( C )成员。
A. 私有B. 保护C. 公用D. 友元7. 假定AB为一个类，则执行“AB x;”语句时将自动调用该类的( B )。
A 带参构造函数B 无参构造函数C 拷贝构造函数D 赋值重载函数8. 假定AB为一个类，则执行“AB r1=r2;”语句时将自动调用该类的( D )。
A 无参构造函数B 带参构造函数C 赋值重载函数D 拷贝构造函数9. 假定一个类的构造函数为“A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行“A x(4,5);”语句后，x.a和x.b的值分别为( C )。
A 4和5B 5和4C 4和20D 20和510. 假定一个类的构造函数为“A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行“A x(4);”语句后，x.a和x.b的值分别为( D )。
A 1和0B 1和4C 4和1D 4和011. 假定AB为一个类，则( B )为该类的拷贝构造函数的原型说明。
A AB(AB x); B AB(AB& x);C void AB(AB& x);D AB(int x);12. 对于任一个类，用户所能定义的析构函数的个数至多为( B )。
A 0B 1C 2D 任意个13. 设px是指向一个类对象的指针变量，则执行“delete px;”语句时，将自动调用该类的( C )。
A 无参构造函数B 带参构造函数C 析构函数D 拷贝构造函数14. 在多文件结构的程序中，通常把类的定义单独存放于( D )中。
A 主文件B 实现文件C 库文件D 头文件15. 在成员函数中进行双目运算符重载时，其参数表中应带有( B )个参数。
A 0B 1C 2D 316. C++源程序文件的默认扩展名为( A )。
A cppB exeC objD lik17. 由C++源程序文件编译而成的目标文件的默认扩展名为( C )。
A cppB exeC objD lik18. 由C++目标文件连接而成的可执行文件的默认扩展名为( B )。
A cppB exeC objD lik19. C++程序从上机到得到结果的几个操作步骤依次是( B )。
A 编译、编辑、连接、运行B 编辑、编译、连接、运行C 编译、运行、编辑、连接D 编辑、运行、编辑、连接20. 程序中主函数的名字为（ A ）。
A mainB MAINC MainD 任意标识符21. 程序运行中需要从键盘上输入多于一个数据时，各数据之间应使用( D )符号作为分隔符。
A 空格或逗号B 逗号或回车C 逗号或分号 D. 空格或回车22. 函数重载是指（ A ）。
A 两个或两个以上的函数取相同的函数名，但形参的个数或类型不同B 两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同C 两个以上的函数名字不同，但形参的个数或类型相同D 两个以上的函数取相同的函数名，并且函数的返回类型相同23. 为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（ A ）。
A 内联函数B 重载函数C 递归函数D 函数模板24. 采用重载函数的目的是（ D ）。
A 实现共享B 减少空间C 提高速度D 使用方便，提高可读性25. 当#include后面的文件名用双引号括起来时，寻找被包含文件的方式是( B )。
A 直接按系统设定的标准方式搜索目录B 先在源程序所在目录搜索，再按系统设定的标准方式搜索目录C 仅仅搜索源程序所在目录D 搜索当前逻辑盘上的所有目录26. 当#include后面的文件名用尖括号括起来时，寻找被包含文件的方式是( A )。
A 直接按系统设定的标准方式搜索目录B 先在源程序所在目录搜索，再按系统设定的标准方式搜索目录C 仅仅搜索源程序所在目录D 搜索当前逻辑盘上的所有目录27. 关于封装，下列说法中不正确的是（ D ）。
A 通过封装，对象的全部属性和操作结合在一起，形成一个整体B 通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）C 通过封装，每个对象都成为相对独立的实体D 通过封装，对象的属性都是不可见的28. 面向对象方法的多态性是指（ C ）。
A 一个类可以派生出多个特殊类B 一个对象在不同的运行环境中可以有不同的变体C 针对一消息，不同的对象可以以适合自身的方式加以响应D 一个对象可以是由多个其他对象组合而成的29. C++类体系中，不能被派生类继承的有( A )。
A 析构函数、构造函数B 构造函数、虚函数C 虚函数、静态成员函数D 静态成员函数、重载函数30. 以下哪个基类中的成员函数表示纯虚函数( C )A virtual void vf(int)B void vf(int)=0;C virtual void vf( )=0D virtual void vf(int){}三、程序改错题（每空2分，共10分）1、程序中有错误的地方已用“←（1）”到“←（5）”指出，在下面给出的①到⑤五条出错原因中，正确地填上对应号。
①私有继承后该函数是派生类的私有成员，外部函数不能访问。
对应号为“←（ 4 ）”②不论公有派生或私有派生，派生类都不能用基类私有成员。
对应号为“←（ 1 ）”③因为该类有构造函数，定义对象时不能缺省参数。
对应号为“←（ 2 ）”④派生类新增加的私有成员，外部函数不能直接访问。
对应号为“←（ 5 ）”⑤私有成员，外部函数不能直接访问。
对应号为“←（ 3 ）”#include<iostream.h>class x {private:int a,b;public:x(int a1=0, int b1=0) {a=a1; b=b1;}int get1( ) {return a+b;}};class y : private x {private:int c;public:y(int a1, int b1, int c1) : x(a1,b1){c=c1;}int get2( ) {return a+b+c;} ←（1）int get3( ) {return c;}};void main( ){ x x1;y y1; ←（2）y y2(3,4,5);cout << x1.a << “\n”; ←（3）x1.get1( );y1.get1( ); ←（4）y1.get3( );cout << y2.c <<“\n”; ←（5）}2、程序中有错误的地方已用“←（6）”到“←（10）”指出，在下面给出的①到⑤五条出错原因中，正确地填上对应号。
①指针指向对象时，不能直接用对象名，要加地址符“&”。
对应号为“←（ 6 ）”②不允许派生类的指针指向基类对象。
对应号为“←（ 10 ）”③基类指针不允许指向私有派生类的对象。
对应号为“←（ 9 ）”④调用指针的对象的成员函数时，写法出错。
对应号为“←（ 7 ）”⑤基类指针允许指向派生类的对象，但不能访问派生类新成员。
对应号为“←（ 8 ）”#include<iostream.h>class base {public: virtual void show( ) {……}};class derive1 : public base {public:void show( ) {……}void print( ) {……}};class derive2 : private base {public:void show( ) {……}};void main( ){ base obj1, obj2, *prt1;derive1 obj3, obj4, *prt2;derive2 obj5;prt1=obj1; ←（6）prt1->show( );prt1=&obj3;prt1.show( ); ←（7）prt1->print( ); ←（8）prt1=&obj5; ←（9）prt2=&obj4;prt2→show( );prt2=&obj2; ←（10）prt2→show( );}四、输出程序结果（每题10分，共30分）1. #include <iostream.h>class Time {private:char a[9];int hours;int minutes;int seconds;public:Time(int s=0, int m=0, int h=0){hours=h;minutes=m;seconds=s;}void show( ){cout<<"时间:"<<hours<<":"<<minutes<<":"<<seconds<<endl;}friend Time operator + (Time &t1, Time &t2);};Time operator + (Time &t1, Time &t2){Time temp;temp.hours = t1.hours + t2.hours;temp.minutes = t1.minutes + t2.minutes;temp.seconds = t1.seconds + t2.seconds;if(temp.seconds > 60){ temp.seconds = temp.seconds - 60; temp.minutes++; } if(temp.minutes > 60){ temp.minutes = temp.minutes - 60; temp.hours++;}if(temp.hours >=24) temp.hours = temp.hours - 24;return temp;}void main( ){Time T, T1(20, 23, 21), T2(10, 25, 15), T3(5, 10, 15);T = T1 + T2;T.show( );T = T1 + T3;}参考答案：时间：12:48:30时间：12:33:252. #include <iostream.h>#include <string.h>template <class T>void swap(T& x, T& y){T temp;temp = x;x = y;y = temp;}void main(){int i= 0, j=1;double a=1.25, b=-2.5;char ch1='A', ch2='B';cout << "\n " << i << '\t' << j;cout << "\n " << ch1<< '\t' << ch2; cout << "\n " << a << '\t' << b;swap(i, j);swap(a, b);swap(ch1, ch2);cout << "\n " << i << '\t' << j;cout << "\n " << a << '\t' << b;cout << "\n " << ch1 << '\t' << ch2; }参考答案：0 1A B1.25 -2.51 0-2.5 1.25B A3、#include <iostream>#include <string>using namespace std;class Student{public:Student(int n,string nam,char s)name=nam;sex=s;cout<<"Constructor called."<<num<<endl;}~Student(){cout<<"Destructor called."<<num<<endl;}void display(){cout<<"num:"<<num<<endl;cout<<"name:"<<name<<endl;cout<<"sex:"<<sex<<endl<<endl;}private:int num;string name;char sex;};int main(){Student stud1(10010,"Wang_li",'f');stud1.display();Student stud2(10011,"Zhang_fun",'m');stud2.display();return 0;}参考答案：五、编程题 (共20分) （应严格按照题目的要求定义类）1、Ex12、Shape。