一：填空题：
（1）在用class定义一个类时，数据成员和成员函数的默认访问权限是 【1】 。
（2）含有纯虚函数的类称为 【2】 。
（3）已知一个类AA，其默认构造函数的函数原型是 【3】 。
（4）对一个类中的数据成员的初始化可以通过构造函数中的 【4】 实现，也可以通过构造函数中的 【5】 实现。
（5）假定AB为一个类，则执行“AB a[10]；”语句时，系统自动调用该类的构造函数的次数为 【6】 。
（6）假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为 【7】 。
（7）在#include命令中所包含的头文件，可以是 【8】 定义的头文件，也可以是 【9】 定义的头文件。
（8）已知类AA有一个构造函数为：AA（int val），现在要在动态分配1个AA对象，初始值为2，用pw存放其地址,语句为 【10】 。
（9）在每个非静态成员函数中，都包含一个隐含的参数，其的参数名为 【11】 。
（10）静态数据成员在定义或说明时，要加关键字 【12】 。
（11）假定用户没有给一个名为AB的类定义析构函数，则系统为其隐含定义的析构函数为 【13】 。
（12）C++支持两种多态性：编译时的多态性和 【14】 时的多态性。
（13）C++支持两种多态性： 【15】 的多态性和运行时的多态性。
（14）假定类AB中有一个公用属性的整型静态数据成员bb，那么在类体外对其进行初始化为0的语句为 【16】 。
（15）假定利用new运算符动态为类AB分配了10个对象元素，并且用pr指针指向，现在要释放这10个对象，使用的语句为 【17】 。
（16）对于派生类（包含子对象）的构造函数，在定义对象时的构造函数的执行顺序为：先执行 【18】 ，在执行 【19】 ，后执行 【20】 。
（17）派生类可以分为 【21】 、 【22】 、和保护派生。由 【23】 得到的派生类，其基类的所有公有成员都只能成为它的私有成员，而由 【24】 得到的派生类，基类的所有公有成员在派生类中也是公有的。
（18） 【25】函数不是类的成员函数，但是它可以访问类的私有数据成员。
（19）如果一个指针变量Pr指向类AA的对象a，现在要通过Pr访问AA的成员函数void fun（）；其语句为 【26】 。
（20）已知类AB有两个构造函数，函数原型分别是AB（int）；和AB（int，int）；现在要创建一个属性值为2对象a，其定义语句为 【27】 。
（21）已知类AA，现在要定义它的复制构造函数。则其函数原型为 【28】 。
（22）已知类AA，有下面的语句：AA a；和AA b=a；那么创建对象b是通过调用 【29】 来完成的。
（23）在C++中，可以把具有相同内部存储结构和相同操作的对象看成属于同一类。在指定一个类后，往往把属于这个类的对象称为类的 【30】 。从语言角度来说，类是一种数据类型，而 【31】 是具有这种类型的变量。
（24）在C++中，动态多态性是通过定义 【32】 来实现的。
（25）C++允许一个派生类同时继承多个基类，这种行为称为 【33】 。
（26）C++提供 【34】 ，使得在继承间接共同基类时只保留一份成员。
（27）现在要实现将double类型的数据转换为类Complex类型的对象，则在类Complex中实现的方法原型语句是 【35】 。
（28） 【36】 的作用是将一个类的对象转换成另一类型的数据。
（29） 【37】 的作用是将一个其他类型的数据转换成一个类的对象。
（30）用户定义的类型的数据，是不能直接用“〈〈”输出的，现在要实现输出类Complex（其数据成员为私有）的对象，则用户需要定义的“〈〈”重载函数原型为 【39】 。它必须是类Complex的 【39】 函数。
（31）对双目运算符，重载为成员函数时，需要 【40】 参数，重载为友元函数时需要 【41】 参数。
（32）如果把双目运算符“+”定义为某个类Complex的运算符重载成员函数，C1和C2是Complex的对象，如果有表达式C1+C2；则编译程序对该表示式给出的解释语句为 【42】 。
（33）cin是 【43】 的一个对象，处理标准输入。cout是 【44】 的对象，处理标准输出。
（34）进行文件操作时，需要包含 【45】 文件。
（35）使用如setw()的操作对数据进行格式输出时，应包含 【46】 文件。
（36）可以用来说明类中保护成员的关键字是 【47】 。
（37） 【48】 的功能是对对象进行初始化。
（38）在基类中用关键字 【49】 声明的成员函数为虚函数。
（39）静态多态性是通过 【50】 来实现的。
（40）类AA的复制构造函数的函数原型为 【51】 。
（41）设px是指向一个类动态对象的指针变量，则执行“delete px；”语句时，将自动调用该类的 【52】 。
（42）若需要把一个函数“void F( )；”定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句 【53】 。
（43）若要在程序文件中进行标准输入输出操作，则必须在开始的#include 命令中使用 【54】 头文件。
（44）执行语句序列 int x=10, &r=x; cout< （45）派生类中的成员不能直接访问基类中的 【56】 成员。 （46）多数运算符既能作为类的成员函数重载，也能作为类的非成员函数重载，但[ ]运算符只能作为类的 【57】 函数重载。 （47）请将下列类定义补充完整。 class Base { public: void fun( ){ cout<<"Base::fun"< public: void fun( ) { 【58】 //显式调用基类的fun函数 cout<<"Derived::fun"< （48）非成员函数应声明为类的 【59】 函数才能访问这个类的private成员。 （49）算法复杂度主要包括时间复杂度和 【60】 复杂度。 （50）要利用new动态分配一个int数据，并用pr指向，将该数据初始化为2，其定义语句为 【61】 。 （51） 【62】 属于静态多态性。 （52）面向对象程序设计有4个特点【63】、【】、【65】 、【66】 。 （53）已知一个函数的原型为 int fun（int=10，int=20）；如果有如下调用语句fun（）；等价于调用 【67】 语句。 （54）如果有如下函数原型语句 int max（int=10，int）；应修改为 【67】 才能保证该语句正确。 （55）重载函数至少在 【68】 、 【69】 或参数顺序上有所不同。 （56）已知int a=10，b=20；现在要设置a和b都以5个宽度输出，其正确的输出语句为 【70】 。 （57）现在要对D:\\abc.txt文件进行输入操作，可以定义 【71】 语句来实现。 （58）已知基类AA的公有成员方法为void fun()；通过【72】继承方式其在派生类内成为不可访问成员。 （59）如果某个类中包含有子对象，则该类对象被创建，首先调用 【73】 ，然后调用 【74】 。 （60）如果要将基类Shape中的方法float Area（）声明为纯虚函数，使用的语句为 【75】 。 二：选择题： 下列各题ABCD四个选项中，只有一个是正确答案，请将正确答案填在相应的括号内。 1、C++语言是从早期的C语言逐渐发展演变而来的.与C语言相比，它在求解问题方法上进行的最大改进是（） A)面向过程 B)面向对象 C)安全性 D)复用性 2、下列高级语言中，（ ）是面向对象的程序设计语言。 A：BASIC B：C++ C：C D：PASCAL 3、下列关于C++函数的叙述中正确的是：（） A：每个函数至少要有一个参数 B：每个函数都必须返回一个值 C：函数在调用之前必须先声明 D：函数不能自己调用自己 4、下列关于类和对象叙述错误的是：（） A：一个类只能有一个对象 B：对象是类的具体实例 C：类是对某一类对象的抽象 D：类和对象的关系是一种数据类型与变量的关系 5、有关类的说法不正确的是（） A：类是一种用户定义的数据类型 B：只有类中的成员函数才能存取类中的私有数据 C：在类中，如果不作特别说明，所有的数据均为私有数据类型 D：在类中，如果不作特别说明，所有的数据均为公有数据类型 6、有以下类的说明，指出错误的地方有（）处 class csample { int a=2； public： csample（int val）； ~ csample（int val）； } A：1 B：2 C：3 D：4 7、有关构造函数说法不正确的是（ ） A：构造函数名和类名相同 B：构造函数在说明类的对象时自动执行 C：构造函数没有任何函数类型 D：构造函数有且只有一个 8、下列关于构造函数的描述中，错误的是（ ） A)构造函数可以设置默认参数； B)构造函数在定义类对象时自动执行 C)构造函数可以是内联函数； D)构造函数不可以重载 9、有关析构函数说法不正确的是（ ） A) 析构函数有且只有一个； B) 析构函数在类对象被撤消时自动执行 C) 析构函数没有任何函数类型；D) 析构造函数可以有参数 10、（ ）是析构函数的特征 A：一个类中只能定义一个析构函数 B：析构函数名与类名不同 C：析构函数的定义只能在类体内 D：析构函数可以有一个或多个参数 11、（ ）函数的功能是对对象初始化 A：析构函数B：数据成员C：构造函数D：静态成员函数 12、如有下列类的声明： CLASS FOO{int bar；}；则类的成员bar是（ ） A：公有数据成员B：公有成员函数：私有数据成员D：私有成员函数 13、下列关于运算符重载叙述中，正确的是（ ） A：通过运算符重载可以定义新的运算符 B：有的运算符只能作为成员函数重载 C：若重载运算符—，则相应的函数名为— D：重载一个2元运算符时，必须声明2个参数 14、考虑函数原型void test(int a,int b=7,char="*"),下面的函数调用中，属于不合法调用的是（ ） A)test(5); B)test(5,8); C)test(6,"#") D)test(0,0."*"); 15、对于语句 cout< C）“x”是一个变量 D）“<<”称作提取运算符 16、下面有关重载函数的说法中正确的是（ ） A)重载函数必须具有不同的返回值类型； B)重载函数形参个数必须不同； C)重载函数必须有不同的形参列表 D)重载函数名可以不同； 17、下面描述中，表达错误的是（ ） A)公有继承时基类中的public成员在派生类中仍是public的 B)公有继承时基类中的private成员在派生类中仍是private的 C)公有继承时基类中的protected成员在派生类中仍是protected的 D)私有继承时基类中的public成员在派生类中是private的 18、应在下列程序划线处填入的正确语句是（ ） #include class Base { public: void fun(){cout<<"Base::fun"< class Derived:public Base { void fun() {_______ ______ //显示调用基类的函数fun() cout<<"Derived::fun"<< endl; } }; A)fun(); B)Base.fun(); C)Base::fun(); D) Base->fun(); 19、下列字符串中，正确的C++标识符是（ ） A）foo-1 B）2b C）new D）_256 20、在C++中用于实现运行时多态性的是（ ） A：内联函数 B：重载函数 C：模板函数 D：虚函数 21、（ ）只能访问静态成员变量，静态成员函数和类以外的函数和数据不能访问类中的非静态成员变量。 A：静态函数 B：虚函数 C：构造函数 D：析构函数 22、局部变量可以隐藏全局变量，那么在有同名全局变量和局部变量的情形时，可以用（ ）提供对全局变量的访问。 A：域运算符 B：类运算符 C：重载 D引用： 23、在下列关键字中，可以用来说明类中保护成员的是（ ）。 A：public B：private C：protected D：friend 24、下列的各类函数中，（ ）不是类的成员函数。 A：构造函数 B：析构函数 C：友元函数 D：复制构造函数 25、对于公有派生来说,派生类不可以直接访问基类的( )成员。 A：公有成员 B：保护成员 C：私有成员 D：都不是 26、C++中的类有两种用法:一种是类的实例化,另一种是通过( ),派生出新的类。 A： 复用 B：继承 C：单继承 D：多继承 27、假定AB为一个类,则该类的拷贝构造函数的声明语句为（ ）。 A： AB&(AB x) B： AB(AB x) C：AB(AB & x) D： AB(AB *x) 28、假定要对类AB定义加号操作符重载成员函数,实现两个AB类对象的加法,并返回相加结果,则该成员函数的声明语句为( ) A：AB operator+(AB&,AB&)； B：AB operator+(AB&)； C：operator+(AB)； D：AB operator+( )； 29、假定AB为一个类，则执行“AB A[10]；”语句时，系统自动调用该类的构造函数的次数为（ ）。 A：10 B：9 C：8 D：7 30、假定AB为一个类，则执行“AB a(4) , b[3] , * p[2] ；”语句时，自动调用该类构造函数的次数为 （ ）。 A: 3 B: 4 C: 6 D: 9 31、假定AB为一个类，则执行“AB *P；”语句时，系统自动调用该类的构造函数的次数为（ ）。 A：10 B：9 C：8 D：0 32、友元的作用（ ）。 A:提高程序的运行效率 B:加强类的封装性 C:实现数据的隐藏性 D:增加成员函数的种类 33、下列关键字中，（ ）不是类定义中使用的关键字 。 A:class B:public C:switch D:private 34、关于类的定义格式的描述，（ ）是错误的 。 A：类中的成员函数既可以在类内实现，也可以在类外实现 B：一般类中包含有数据成员和成员函数 C：类中成员有三种访问权限：公有，私有和保护 D：成员函数都应是公有的，数据成员都应是私有的 35、类模板的使用实际上是将类模板实例化成一个具体的（ ）。 A：类 B：对象 C：函数 D：模板类 36、下列静态数据成员的的特性中，（ ）是错误的。 A:说明静态数据成员时，前边要加修饰符static B:静态数据成员要在类体外进行初始化 C:引用静态数据成员时，要在静态数据成员名前加类名和作用域运算符 D:静态数据成员不是所有对象所共有的 37、已知一个类AA，其成员函数是int fun（），p是指向成员函数int fun（）的指针，采用（ ）定义p是正确的。 A：int *p=fun B：int *p=AA：：fun C：int （AA：：*P）（）=&AA：：fun D：int （AA：：*P）（）=& fun 38、已知print（）函数是一个类的常成员函数，它没有返回值，函数体为空下列表示中，（ ）是正确的。 A：void print（）const{} B：const void print（）{} C：void const print（）{} D：void print const（）{} 39、关于new运算符，下列描述中，（ ）是错误的。 A：它可以用来动态创建对象和对象数组 B：使用它创建的对象或对象数组，可以通过运算符delete删除 C：使用它创建对象时要调用构造函数 D：使用它创建对象数组必须指定初始值 40、关于delete运算符，下列描述中，（ ）是错误的。 A它必须用于new返回的指针 B它也适用于空指针 C对一个指针可以使用多次该运算符 D指针名前只用一对方括号符，不管所删除的数组维数 41、已知：类A中一个成员函数的说明如下：void Set（A&a）;其中，A&a的含义是（ ）。 A：指向类A的指针为a B：将a的地址赋值给变量Set C：a是类A对象的引用，用来作函数Set（）的形参 D：变量A与a按位相与作为函数Set（）的参数 42、已知类AA的成员函数为void fun（int a，int b），下面哪个函数能够作为它的重载函数（ ）。 A：void fun（int a=0，int b） B：void fun（int a，int b=0） C：void fun（int a） D：void fun（int m，int n） 43、下列关于对象数组的描述，（ ）是错误的。 A对象数组的下标是从0开始的 B对象数组的数组名是一个常量指针 C对象数组的每一个元素是同一个类的对象 D对象数组只能赋初值，而不能在定义后赋值 44、在下列函数原型中，可以作为类AA构造函数的是（ ）。 A：void AA（int）； B：int AA（）； C：AA（int）const； D：AA（int）； 45、下列关于this指针叙述，正确的是（ ）。 A：任何与类相关的函数都有this指针 B：类的成员函数都有this指针 C：类的友元函数都有this指针 D：类的非静态成员函数才有this指针 46、对于语句cout< B：“endl“的作用是输出回车换行 C：“x“是一个变量 D：“〈〈“称为提取运算符 47、运算符重载是对已有的运算符赋予多重含义，因此（ ）。 A：可以对基本类型（如int类型）的数据，重新定义“+”运算符的含义 B：可以改变一个已有运算符的优先级和操作个数 C：只能重载C++中已有的运算符，不能定义新运算符 D：C++中已经有的所有运算符都可以重载 48、下面是重载非成员函数的运算符函数原型，其中错误的是（ ） A：Fraction operator+（Fraction，Fraction）； B：Fraction operator-（Fraction）； C：Fraction operator=（Fraction&，Fraction）； D：Fraction operator+=（Fraction&，Fraction）； 49、模板对类型的参数化提供了很好的支持，因此（ ）。 A：类模板的主要作用是生成抽象类 B：类模板实例化时，编译器将根据给出的模板生成一个类 C：在类模板中的数据成员都具有同样类型 D：类模板中的成员函数没有返回值 50、下列关于派生类的描述中，（ ）是错误的。 A：一个派生类可以作另一个派生类的基类 B：派生类至少有一个基类 C：派生类的成员除了它自己的成员外，还包含了它的基类的成员 D：派生类中继承的基类成员的访问权限到派生类中不变 51、（ ）不是构造函数的特征。 A：构造函数名和类名相同 B：构造函数可以重载 C：构造函数可以设置默认参数 D：构造函数必须指定类型说明 52、派生类的对象对它基类成员中（ ）是可以访问的。 A）公有继承的公有成员 B）公有继承的私有成员 C）公有继承的保护成员 D）私有继承的公有成员 53、对基类和派生类的关系描述中，（ ）是错误的。 A）派生类是基类的具体化 B）派生类是基类的子集 C）派生类是基类的延续 D）派生类是基类的组合 54、派生类的构造函数的成员初始化列表中，不能包含（ ）。 A）基类的构造函数 B）派生类中子对象的初始化 C）基类的子对象的初始化 D）派生类中一般数据成员的初始化 55、关于多继承二义性的描述中，（ ）是错误的。 A）一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性 B）解决二义性的最常用的方法是对成员名的限定法 C）基类和派生类中同时出现的同名函数，也存在二义性问题 D）一个派生类是从两个基类派生来的，而这两个基类又有共同的基类，对该基类成员进行访问时，也可能出现二义性 56、设置虚基类的目的是（ ）。 A）简化程序 B）消除二义性 C）提高运行效率 D）减少目标代码 57、带有虚基类的多层派生类构造函数的成员函数初始化列表中都要列出虚基类的构造函数，这样将对虚基类的子对象初始化（ ）。 A）1次 B）2次 C）与下面的派生类的个数有关 D）多次 58、在C++语言中，若类C中定义了一个方法int f（int a，int b），那么下面（ ）方法与该方法不能同时存在于类中。 A）int f（int x，int y） B）int f（float a，int B） C）float f（int x，float y） D）int f（int X，float y） 已知3个类O、P、Q，类O中定义了一个私有方法F1、一个公有方法F2和一个受保护的方法F3；类P和类Q是类O的派生类，其继承方式如下所示： class P：protected O{}； class Q：public O{…}；作答下面3题。 59、关于方法F1的描述中正确的是 )。 A）方法F1无法被访问 B）只有在类O内才能访问方法F1 C）只有在类P内才能访问方法F1 D）只有在类Q内才能访问方法F1 60、关于方法F2描述中正确的是（ ）。 A）类O、P、Q的对象都可以访问方法F2 B）类P和Q的对象都可以访问方法F2 C）类O和Q的对象都可以访问方法F2 D）只有在类P内才可以访问方法F2 61、关于方法F3描述中正确的是（ ）。 A）类O、P、Q的对象都可以访问方法F3 B）类O、P、Q的对象都不可以访问方法F3 C）类O和Q的对象都可以访问方法F3 D）类P和Q的对象都可以访问方法F3 62、下列关于一个类的静态成员的描述中，不正确的是（ ）。 A）该类的对象共享其静态成员变量的值 B）静态成员变量可被该类的所有方法访问 C）该类的静态方法只能访问该类的静态成员变量 D）该类的静态数据变量的值不可修改 63、下列运算符中，（ ）运算符在C++中不能重载。 A）？： B）+ C）— D）〈= 、关于动态联编的下列描述中，（ ）是错误的。 A）动态联编是以虚函数为基础的 B）动态联编是在运行时确定所调用的函数代码的 C）动态联编调用函数操作是指向对象的指针或对象引用 D）动态联编是在编译时确定操作函数的 65、关于虚函数的描述中，（ ）是正确的。 A：虚函数是一个static类型的成员函数 B：虚函数是一个非成员函数 C：基类中说明了虚函数后，派生类中与其对应的函数可不必说明为虚函数 D：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 66、关于纯虚函数和抽象类的描述中，（ ）是错误的。 A：纯虚函数是一种特殊的虚函数，它没有具体的实现 B：抽象类是指具有纯虚函数的类 C：一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类 D：抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出 67、下列描述中，（ ）是抽象类的特性。 A：可以说明虚函数 B：可以进行构造函数重载 C：可以定义友元函数 D：不能说明其对象 68、（ ）是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。 A：虚析构函数 B：虚构造函数 C：纯虚函数 D：静态成员函数 69、如果一个类至少有一个纯虚函数，那么就称该类为（ ）。 A：抽象类 B：虚基类 C：派生类 D：以上都不对 70、进行文件操作时需要包含（ ）文件。 A：iostream.h B：fstream.h C：stdio.h D：stdlib.h 71、在下面的函数声明中，存在着语法错误的是( )。 A: void BC(int a , int) B: void BD(int , int) C: void BE(int , int=5) D: int BF(int x ; int y) 72、通过（ ）调用虚函数时，采用动态束定。 A、 对象指针 B、 对象名 C、 成员名限定 D、 派生类名 73、已知在一个类体中包含如下函数原型: VOLUME operator-(VOLUME)const;，下列关于这个函数的叙述中，错误的是( ) A）这是运算符-的重载运算符函数 B）这个函数所重载的运算符是一个一元运算符 C）这是一个成员函数 D）这个函数不改变类的任何数据成员的值 74、在下列函数原型中，可以作为类AA构造函数的是（ ） A）void AA(int); B）int AA( ); C）AA(int)const; D）AA(int); 三、判断题：（每题1分） 1、运算符重载可以改变运算符的个数。（ ） 2、纯虚函数是一种特殊的虚函数，它没有具体的实现。（ ） 3、一个派生类可以作为另一个派生类的基类。（ ） 4、对象数组的下标是从0开始的。（ ） 5、使用new创建的对象，可以使用delete删除。（ ） 6、友元的作用是加强类的封装性。（ ） 7、成员函数可以设置参数的默认值（ ） 8、类和对象的关系和数据类型和变量的关系相似（ ） 9、进行文件操作时，需要包含fstream.h文件（ ） 10、静态成员函数不能访问类的非静态数据成员（ ） 11、在C++中，标识符的大小写没有区分（ ） 12、面向对象的程序设计是将数据与对数据的操作放在一起，作为一个互相依存，不可分割的整体类来实现的（ ） 13、类是一个抽象的概念，而对象则是一个具体的概念（ ） 14、控制格式I/O操作，可以通过setw（）来设置域宽（ ） 15、动态联编是在编译时就已确定要操作的函数（ ） 16、析构函数不能够重载（ ） 17、重载函数在被调用时，可以根据函数名称来确定要调用的函数（ ） 18、设置虚基类的目的是消除二义性（ ） 19、静态成员函数可以访问类的非静态数据成员（ ） 20、已知print（）函数是类的友元函数，则可以访问类的私有数据成员（ ） 21、C++语言和C语言都是面向对象的程序设计语言。（ ） 22、类是具有共同行为的若干对象的统一描述体。（ ） 23、常成员函数可以访问并修改非const数据成员。（ ） 24、C++中任意的运算符都可以进行重载。（ ） 25、构造函数可以返回值。（ ） 26、只有在派生类中对基类的所有纯虚函数都进行重新定义，否则，该派生类仍为抽象类（ ） 27、静态成员函数不能访问类的非静态数据成员（ ） 28、所有的C++运算符都可以重载。（ ） 29、如果一个类至少有一个纯虚函数，那么就称该类为抽象类。（ ） 30、动态联编是在程序运行时确定操作数的。（ ） 31、析构函数不能重载。（ ） 32、对象数组只能赋初值，而不能在定义后赋值。（ ） 33、构造函数可以返回值。（ ） 34、结构体中的数据和成员函数默认类型为私有（ ） 35、通过虚基类可以实现动态多态性（ ） 36、在多继承中，公有派生和私有派生对于基类成员的可访问性与单继承的规则不同（ ） 37、派生类的对象可以访问基类中任何成员（ ） 38、构造函数可以声明为虚函数（ ） 39、包含虚函数的类就称为抽象类（ ） 40、抽象类不可以定义对象（ ） 41、静态成员函数不受限于某个对象，故而静态成员函数不能是虚函数( ) 42、只有类的成员函数才有可能声明为虚函数( ) 43、内联函数不能声明为虚函数（ ） 44、在类体内定义的成员函数，系统会自动把它当作内联函数来处理（ ） 45、要实现文件操作，可以包含文件iostream（ ） 46、在类内部定义的成员函数默认为内联函数（ ） 47、C++系统提供的默认构造函数函数体一定为空，但是其复制构造函数函数体可能不为空（ ） 48、要想实现动态多态性，必须要用基类的指针或引用去调用虚函数（ ） 49、构造函数不能声明为虚函数（ ） 四、写出程序运行结果： 评分标准：每题与参的数据和显示格式完全相同者得满分，否则酌情给分。 (1)# include class A { int a,b; public : A() { a=b=0; cout < a=aa; b=bb; cout < }; void main() { A x,y(2,3),z(4,5); } （2）# include class A { int a,b; public : A(int aa,int bb) { a=aa; b=bb; cout <<＂Constructor!＂< }; void main() { A y(2,3),z(4,5); } （3）# include class A { int a; public : A(int aa) {a=aa; cout <<"Constructor!"< ~A(){cout<<"Destructor!"< void main() { A y(2),z(5); } (4) #include class Sample { int A; static int B; public: Sample(int a){A=a,B+=a;} static void func(Sample s); }; void Sample::func(Sample s) { cout<<"A="< int Sample::B=0; void main() { Sample s1(2),s2(5); Sample::func(s1); Sample::func(s2); } (5) #include using namespace std; class Sample { public: int x,y; Sample(){x=y=0;} Sample(int a,int b){x=a;y=b;} void disp() { cout<<"x="< }; void main() { Sample s1(2,3),s2; s1.disp(); s2.disp(); } (6) #include using namespace std; class Sample { public: int x,y; Sample(){x=y=0;cout<<"Constructor1"< { cout<<"x="< }; void main() { Sample s1(2,3),s2; s1.disp(); s2.disp(); } (7) #include class Tdate{ public: Tdate(){ Init(4,15,1995); } Tdate(int d){ Init(4,d,1996); } Tdate(int m,int d){ Init(m,d,1997); } Tdate(int m,int d,int y){ Init(m,d,y); } protected: int month; int day; int year; void Init(int m,int d,int y) { month=m; day=d; year=y; cout < }; void main() { Tdate aday; Tdate bday(10); Tdate cday(2,12); Tdate dday(1,2,1998); } (8) #include class AA{ private: int i; static int k; public: AA(){i=0;k++;cout<<"Constructor"< int AA::k=0; void main() { AA a,b; a.display(); b.display(); } (9) #include void main() { int a=10; int&b=a; cout<<”a=”< cout<<”a=”< (10) #include class AA{ int i; public: AA(){i=0;cout<<"i="< void main() { AA a,b(10); } (11) #include class AA{ int i; public: AA(){i=0;cout<<"i="< void main() { AA a,b(10); } (12) #include class MyClass{ public: MyClass(); MyClass(int); ~MyClass(); void Display(); protected: int number; }; MyClass::MyClass(){number =0;cout <<"Constructing normally.\\n"; } MyClass::MyClass(int m):number(m) { cout <<"Constructing with a number: " < void MyClass::Display(){ cout <<"Display a number: " < void main() { MyClass obj1; MyClass obj2(20); obj1.Display(); obj2.Display(); } (13) #include class AA{ public: AA(){cout<<"constructor1"< }; class BB{ public: BB(){cout<<"constructor2"< AA a; }; void main() { BB b; } (14) #include class AA{ public: AA(){cout<<"constructorAA"< }; class BB{ public: BB(){cout<<"constructorBB"< AA a; }; void main() { AA a; BB b; } (15) #include class AA{ public: AA(int a){i=a;cout<<"constructor1"< private: int i; int j; }; void main() { AA a[2]={AA(3),AA(4,5)}; } (16) #include class AA{ public: AA(int a){i=a;cout<<"constructor1"< private: int i; int j; }; void main() { AA *p=new AA(2),*q=new AA(3,4); delete p; delete q; } (17) #include class Sample { int i; double d; public: void setdata(int n){i=n;d=0;} void setdata(int n,double x) { i=n;d=x; } void disp() { cout<<"i="< }; void main() { Sample s; s.setdata(10); s.disp(); s.setdata(2,15.6); s.disp(); } (18) #include class base { public: base(){cout<<"constructing base class"< class subs:public base { public: subs(){cout<<"constructing sub class"< void main() { subs s; } (19)#include class base { int n; public: base(int a) { cout<<"constructing base class"< cout<<"n="< ~base(){cout<<"destructing base class"< class subs:public base { base bobj; int m; public: subs(int a,int b,int c):base(a),bobj(c) { cout<<"constructing sub cass"< cout<<"m="< ~subs(){cout<<"destructing sub class"< void main() { subs s(1,2,3); } (20) #include class A { public: int a; }; class B:virtual public A { public: int b; }; class C:virtual public A { public: int c; }; class D:public B,public C { public: int d; void print() { cout<<"a="< }; void main() { D d; d.a=1; d.b=3; d.c=5; d.d=7; d.print(); } (21) #include 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); } (22) #include class A { int a; public: A(int i) { a=i;cout << "constructing class A" << endl; } void print() { cout << a << endl; } ~A() { cout << "destructing class A" << endl; } }; class B1:public A { int bl; public: B1(int i,int j):A(i) { bl=j;cout << "constructing class B1" << endl; } void print() { A::print (); cout << bl << endl; } ~B1(){ cout << "destructing class B1" << endl; } }; class B2:public A { int b2; public: B2(int i,int j):A(i) { b2=j;cout << "constructing class B2" << endl; } void print() { A::print (); cout << b2 << endl; } ~B2() { cout << "destructing class B2" << endl; } }; class C:public B1,public B2 { int c; public: C(int i,int j,int k, int l,int m) :B1(i,j),B2(k,l),c(m) { cout << "constructing class C" << endl; } void print() { B1::print(); B2::print(); cout << c << endl; } ~C( ){ cout << "destructing class C" << endl; } }; void main() { C c1(1,2,3,4,5); c1.print(); } (22)#include 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 } (23) #include class Tadd{ private: int x,y; public: Tadd(int a,int b) { x=a;y=b; cout<<"constructor1"< Tadd(Tadd&p) { x=p.x; y=p.y; cout<<"constructor2"< ~Tadd() { cout<<"destructing"< }; void main() { Tadd p1(2,3),p2=p1; } 五、指出下列程序错误并改正。 1、本程序共有4出错误,请改正10分(注意!只需修改// ERROR **********found**********的下一行语句,不要改动程序中的其他内容)使程序的输出结果为 constructor! The value is10 #include using namespace std; class AA{ // ERROR **********found********** int value=10; public: // ERROR **********found********** void AA(int val){ value= val; cout<<"constructor!"< void GetValue(){ return value; } }; int main() { AA obj(10); // ERROR **********found********** cout << "The value is " << value << endl; return 0; } 2、本程序共有4出错误,请改正(注意!只需修改// ERROR **********found**********的下一行语句,不要改动程序中的其他内容) 10分 #include using namespace std; #include using namespace std; class MyClass { public: // ERROR **********found********** void MyClass(int i) { value = i; cout << "Constructor called." << endl; } int Max(int x, int y) { return x>y ? x : y; } // 求两个整数的最大值 // ERROR **********found********** int Max(int x, int y, int z = 0) // 求三个整数的最大值 { if (x > y) return x>z ? x : z; else return y>z ? y : z; } int GetValue() const { return value; } ~MyClass() { cout << "Destructor called." << endl; } private: // ERROR **********found********** int value=10; }; int main() { MyClass obj(10); // ERROR **********found********** cout << "The value is " << value() << endl; cout << "Max number is " << obj.Max(10,20) << endl; return 0; } 3、本程序共有4出错误,请改正(注意!只需修改// ERROR **********found**********的下一行语句,不要改动程序中的其他内容,使程序的输出结果为1 2 3 4 5 6 7 8 9 10) 10分 #include using namespace std; class MyClass { public: MyClass(int len) { array = new int[len]; arraySize = len; for(int i = 0; i < arraySize; i++) array[i] = i+1; } ~MyClass() { // ERROR **********found********** delete array[]; } void Print() const { for(int i = 0; i < arraySize; i++) // ERROR **********found********** cin << array[i] << ' '; cout << endl; } private: int *array; // ERROR **********found********** int arraySize=10; }; int main() { // ERROR **********found********** MyClass obj; obj.Print(); return 0; } 4、本程序共有4出错误,请改正(注意!只需修改// ERROR **********found**********的下一行语句,不要改动程序中的其他内容)使程序的输出结果为: Constructor 2,3 Destructor #include using namespace std; class Csample{ public: // ERROR **********found********** Csample(int a;int b){x=a;y=b;cout<<"Constructor"< void ~ Csample(){ cout<<"Destructor"< private: int x; int y; }; // ERROR **********found********** void display(){cout< { Csample cs(2,3); // ERROR **********found********** display(); return 0; } 5、本程序共有4出错误,请改正(注意!只需修改// ERROR **********found**********的下一行语句,不要改动程序中的其他内容)使程序的输出结果为: Constructor 2,3 Destructor #include using namespace std; class Add{ public: // ERROR **********found********** void Add(int a,int b){x=a;y=b; cout<<"Constructor"< // ERROR **********found********** void display(Add&); private: int x; int y; }; // ERROR **********found********** ~Add(){cout<<"Destructor"< // ERROR **********found********** int Main() { Add a(2,3); display(a); return 0; } 六、编写程序：每题（15分） 1、从建立的数据文件E:\\\\f1.txt中读入10个整数放在数组中，找出并输出10个数中的最大者和它在数组中的序号。 2、定义一个复数类Complex，数据成员为：实数部分（real），虚数部分（imag），均为double 数据。成员函数包含构造函数，求复数相加的运算符重载函数（使之能用于复数的加法运算。参加运算的的两个操作数可以都是类对象，也可以其中有一个是整数，顺序任意），输出复数函数（display），编写程序，分别求两个复数之和，整数和复数之和，复数和整数之和，并将每次的结果输出。 例如：已知三个复数C1=3+4i，C2=5-10i，C3=0；求C3=C1+C2，C3=5+C1，C3=C1+5； 3、写一个程序，定义抽象类Shape，由它派生出3个类，Circle（圆类）、Rectangle（矩形类）、Triangle（三角形类）,用一个函数printArea()分别输出以上3者的面积,3个图形的数据在定义对象时给定. 参: 4、定义一个矩形类Rectangle，数据成员为：长（width），高（high）为double 数据，成员函数包含构造函数（初始化数据成员），求矩形面积函数（Area），打印矩 形面积函数（Display），主函数中要求创建一个长10，宽5的对象a1，并将a1的面积输出。 (15分) 参: 5、定义一个学生类（Student），数据成员为：姓名（pname）为char型数组（占10个字节空间）；语文（yw），数学（sx），平均成绩(averager)为double 数据。成员函数包含:构造函数实现创建对象(初始化成员,不包含平均成绩),求平均成绩(语文,数学)的函数(Averager),输出数据成员的函数(Display)。 编程实现如下功能：创建一个姓名为TOM，语文为80.5，数学为90.5的对象，调用成员求出平均成绩，并将学生的信息输出。(15分) 6、设计一个圆类circle和一个桌子类table，另设计一个圆桌类roundtable，它是从前两个类派生的，要求输出一个圆桌的高度、面积和颜色等数据。 7、定义一个复数类Complex，数据成员为：实数部分（real），虚数部分（imag），均为double 数据。重载流插入”<<”和流提取” >>”能够实现复数类类的输入和输出. 参:下载本文
