《C++程序设计》财大成教原题及答案
1、( )年正式取名为C++
A.1983
B.1986
C.1978
D.1999
答案：A
2、int类型占用（）字节存储空间。
A.1
B.2
C.4
D.8
答案：C
3、使用if—else语句嵌套最多可以实现（）分支
A.1
B.2
C.4
D.无数多条
答案：D
4、（）循环语句至少会被执行一次。
A.while
B.do_while
C.for
D.都不是
答案：B
5、for循环的判断条件是（）
A.第一个表达式
B.第二个表达式
C.第三个表达式
D.以上都不对
答案：B
6、定义结构体使用的关键字是（）
A.virtual
B.union
C.private
D.struct
答案：D
7、下列说法错误的是（）
A.函数可以嵌套定义
B.函数可以嵌套调用
C.函数可以没有参数
D.函数可以有多个参数
答案：A
8、要把一个函数定义为内联函数，应该使用关键字（）
A.void
B.important
C.inline
D.line
答案：C
9、重载函数的必须满足（）
A.形参个数或类型不同
B.返回值不同
C.函数名不同
D.形参名不同
答案：A
10、类中（）修饰的成员可以在类外访问。
A.private
B.protected
C.public
D.以上都不对
答案：C
11、构造函数（）时候被自动调用。
A.对象销毁
B.对象创建
C.对象引用
D.对象赋值
答案：B
12、析构函数（）时候被自动调用。
A.对象销毁
B.对象创建
C.对象引用
D.对象赋值
答案：A
13、UML语言是一种可视化的的面向对象（）语言。
A.编程
B.编辑
C.建模
D.设计
答案：C
14、在函数内部声明静态生存期对象，要冠以关键字（）
A.static
B.virtual
C.class
D.public
答案：A
15、静态生存期与程序的（）相同。
A.编辑期
B.编译期
C.运行期
D.连接期
答案：C
16、友元函数是在类声明中由关键字（）修饰说明的非成员函数。
A.friend
B.virtual
C.private
D.public
答案：A
17、包含指令使用的关键字是()
A.#include
B.#define
C.#if
D.#undef
答案：A
18、一维数组的下标从（）开始。
A.0
B.1
C.2
D.3
答案：A
19、定义二维数组int a],一共定义了（）个元素。
A.3
B.4
C.12
D.24
答案：C
20、假设有定义int *p，则p=p+1后，p中地址值会（）
A.加1
B.加2
C.加4
D.加8
答案：C
21、存放字符串“china”需要占用（）个字节内存空间。
A.1
B.5
C.6
D.8
答案：C
22、下面哪一个不是类的继承方式（）。
A.public
B.protected
C.private
D.inline
答案：D
23、下列说法错误的是（）
A.基类的构造函数不被继承
B.声明构造函数时，只需要对本类中新增成员进行初始化
C.派生类的构造函数需要给基类的构造函数传递参数
D.声明构造函数时，不但需要对本类中新增成员进行初始化，而且要为基类成员初始化
答案：D
24、定义虚基类需要使用关键字（）。
A.private
B.class
C.virtua1
D.static
答案：C
25、函数重载实现了面向对象的（）。
A.抽象性
B.封装性
C.多态性
D.继承
答案：C
26、静态联编是在（）阶段实现的。
A.编辑
B.编译
C.连接
D.运行
答案：B
27、下列关于抽象类说法错误的是（）。
A.抽象类只能作为基类来使用
B.可以声明抽象类的对象
C.构造函数不能是虚函数
D.析构函数可以是虚函数
答案：B
阶段练习
阶段测验一
一、 单选
1、设有函数T Sum(T x，T y){return x+y；}，其中T为模板类型，则下列语句中对该函数错误的使用是( )
A.Sum(1，2)；
B.Sum(3.0，2.2)；
C.Sum(‘A’，‘C’)；
D.Sum(
答案：D
2、使用值传递方式将实参传给形参，下列说法正确的是（ ）
A.形参是实参的备份
B.实参是形参的备份
C.形参和实参是同一对象
D.形参和实参无联系
答案：A
3、在函数调用时，如某一默认参数要指明一个特定值，则有（ ）
A.其之前所有参数都必须赋值
B.其之后所有参数都必须赋值
C.其前、后所有参数都必须赋值
D.其前、后所有参数都不必赋值
答案：A
4、下列哪个类型函数不适合声明为内联函数（ ）
A.函数体语句较多
B.函数体语句较少
C.函数执行时间较短
D.函数执行时间过长
答案：A
5、int Func(int，int)；不可与下列哪个函数构成重载（ ）
A.int Func(int，int，int)；
B.double Func(int，int)；
C.double Func(double，double)；
D.double Func(int，double)；
答案：B
6、编写C++程序一般需经过的几个步骤依次是( )
A.编译、编辑、连接、调试
B.编辑、编译、连接、调试
C.编译、调试、编辑、连接
D.编辑、调试、编译、连接
答案：B
7、以下哪个基类中的成员函数表示纯虚函数？ ( )
A.virtual void vf(int)
B.void vf(int) = 0
C.virtual void vf()=0
D.virtual void yf(int){}
答案：C
8、假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “Ax(4,5);”语句后，x.a和x.b的值分别为( )
A.4和5
B.5和4
C.4和20
D.20和5
答案：C
9、一个C++源程序文件的扩展名为( )
A..h
B..c
C..cpp
D..cp
答案：C
10、内联函数的特点是( )
A.减少代码量，加快访问速度
B.减少代码量，减缓访问速度
C.增加代码量，减缓访问速度
D.增加代码量，加快访问速度
答案：A
11、一个类的静态数据成员所表示属性( )
A.是类或对象的属性
B.只是对象的属性
C.只是类的属性
D.是类和友元的属性
答案：C
12、关于类的静态成员函数描述错误的是( )
A.在创建对象前不存在
B.不能说明为虚函数
C.不能直接访问非静态函数
D.不是对象的成员
答案：A
13、设存在函数int max(int，int)返回两参数中较大值，若求22，59，70三者中最大值，下列表达式不正确的是（ ）
A.int m = max(22，max(59，70))；
B.int m = max(max(22，59)，70)；
C.int m = max(22，59，70)；
D.int m = max(59，max(22，70))；
答案：C
14、一个类可包含析构函数的个数是（ ）
A.0个
B.1个
C.至少一个
D.0个或多个
答案：B
15、对于友元描述正确的是（ ）
A.友元是本类的成员函数
B.友元不是本类的成员函数
C.友元不是函数
D.友元不能访问本类私有成员
答案：B
16、函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为( )
A.1
B.2
C.4
D.5
答案：B
17、假定AB为一个类，则执行 “AB a(2), b［3］, *p［4］;”语句时共调用该类构造函数的次数为( )
A.3
B. 4
C.5
D.9
答案：B
18、假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete ［］px;”语句时共调用该类析构函数的次数为( )
A. 0
B.1
C. n
D.n+1
答案：C
19、如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为( )
A.a.operator++(1)
B.operator++(a)
C.operator++(a,1)
D.a.operator++()
答案：D
20、继承机制的作用是( )
A.信息隐藏
B. 数据封装
C.定义新类
D.数据抽象
答案：C
阶段测验二
一、 单选 1、解决二义性问题的方法有( )A.只能使用作用域分辨操作符B.使用作用域分辨操作符或赋值兼容规则C.使用作用域分辨操作符或虚基类D.使用虚基类或赋值兼容规则答案：C
2、在C++程序中，对象之间的相互通信通过( )A.继承实现B.调用成员函数实现C.封装实现D.函数重载实现答案：B
3、对于任意一个类，析构函数的个数最多为( )A.0B.1C.2D.3答案：B
4、语句ofstream f(″SALARY.DAT″,ios::app｜ios::binary);的功能是建立流对象f，试图打开文件SALARY.DAT并与之连接，并且( )A.若文件存在，将文件写指针定位于文件尾；若文件不存在，建立一个新文件B.若文件存在，将其置为空文件；若文件不存在，打开失败C.若文件存在，将文件写指针定位于文件首；若文件不存在，建立一个新文件D.若文件存在，打开失败；若文件不存在，建立一个新文件答案：A
5、下面说法正确的是( )A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方B.内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方C.类的内联函数必须在类体内定义D.类的内联函数必须在类体外通过加关键字inline定义答案：B
6、可以用p.a的形式访问派生类对象p的基类成员a，其中a是( )A.私有继承的公有成员B.公有继承的私有成员C.公有继承的保护成员D.公有继承的公有成员答案：D
7、在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是( )A.派生类的对象可以赋给基类的对象B.派生类的对象可以初始化基类的引用C.派生类的对象可以直接访问基类中的成员D.派生类的对象的地址可以赋给指向基类的指针答案：C
8、对于类定义 class A{ public: virtual void func1( ){ } void func2( ){ } }; class B:public A{ public: void func1( ){cout<″class b="" func="">A.A::func2( )和B::func1( )都是虚函数B. A::func2( )和B::func1( )都不是虚函数C.B::func1( )是虚函数，而A::func2( )不是虚函数D.B::func1( )不是虚函数，而A::func2( )是虚函数答案：C
9、所谓多态性是指 ( )A.不同的对象调用不同名称的函数B.不同的对象调用相同名称的函数C.一个对象调用不同名称的函数D. 一个对象调用不同名称的对象答案：B
10、类MyA的拷贝初始化构造函数是 ( )A.MyA()B.MyA(MyA*)C.MyA(MyA&)D.MyA(MyA)答案：C
11、下面运算符中，不能被重载的运算符是( )A.<=B.－C.?:D.[]答案：C
12、假设类X以类Y作为它的一个基类，并且X类的名字func()支配Y类的名字func()，obj为类X的对象，则obj.func()语句实现的功能为 ( )A.先执行类X的func()，再执行访问类Y的func()B.先执行类Y的func()，再执行访问类X的func()C.执行类X的func()D.执行类Y的func()答案：C
13、下列有关模板和继承的叙述正确的是 ( )A.模板和继承都可以派生出一个类系B.从类系的成员看，模板类系的成员比继承类系的成员较为稳定C.从动态性能看， 继承类系比模板类系具有更多的动态特性D.相同类模板的不同实例一般没有联系，而派生类各种类之间有兄弟父子等关系答案：D
14、友元关系不能( )A.继承B.是类与类的关系C.是一个类的成员函数与另一个类的关系D.提高程序的运行效率答案：A
15、有如下程序段： int *p,a={-1,0,1,2,3,4}; p=a+3; 执行该程序段后，*p的值为 ( )A.4B.2C.1D.NULL答案：B
16、一个函数功能不太复杂，但要求被频繁调用，则应把它定义为 ( )A.内联函数B.重载函数C.递归函数D. 嵌套函数答案：A
17、以下有关继承的叙述正确的是 ( )A. 构造函数和析构函数都能被继承B.派生类是基类的组合C.派生类对象除了能访问自己的成员以外，不能访问基类中的所有成员D. 基类的公有成员一定能被派生类的对象访问答案：B
18、以下叙述正确的是( )A.构造函数调用虚函数采用动态联编B.构造函数可以说明为虚函数C.当基类的析构函数是虚函数时，它的派生类的析构函数也是虚函数D.析构函数调用虚函数采用动态联编答案：C
19、以下关于抽象类的描述正确的是 ( )A.不能说明指向抽象类对象的指针或引用B.可以说明抽象类对象C.抽象类的纯虚函数的实现可以由自身给出，也可以由派生类给出D.抽象类的纯虚函数的实现由派生类给出答案：D
20、在下面格式化命令的解释中，错误的是 ( )A.ios::skipws 跳过输入中的空白字符B.ios::fill() 获得当前的填充字符C. ios::hex 转换基数为八进制形式D.ios::precision 返回当前的精度答案：C
阶段测验三
一、 单选1、下列说法中正确的是( )A.类定义中只能说明函数成员的函数头，不能定义函数体B.类中的函数成员可以在类体中定义，也可以在类体之外定义C.类中的函数成员在类体之外定义时必须要与类声明在同一文件中D.在类体之外定义的函数成员不能操作该类的私有数据成员答案：B
2、面向对象的程序设计语言必须具备的关键要素是( )A.抽象和封装B.抽象和多态性C.抽象、封装、继承和多态性D.抽象、封装和继承性答案：C
3、类的构造函数被自动调用执行的情况是在定义该类的( )A.成员函数时B.数据成员时C.对象时D.友元函数时答案：C
4、如果表达式++i*k中的“++”和“*”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为( )A.operator*(i.operator++(),k)B.operator*(operator++(i),k)C.i.operator++().operator*(k)D.k.operator*(operator++(i))答案：B
5、设存在函数int min(int，int)返回两参数中较小值，若求15，26，47三者中最小值，下列表达式中错误的是( )A.int m=min(min(15，26)，min(15，47))；B.int m=min(15，26，47)；C.int m=min(15，min(47，26))；D.int m =min(min(47，26)，16)；答案：B
6、在下列成对的表达式中，运算结果类型相同的一对是( )A.7／2和7.0／2.0B.7／2.0和7／2C.7.0／2和7／2D.7.0／2.0和7.0／2答案：D
7、关于类的静态成员函数描述错误的是( )A.在创建对象前不存在B.不能说明为虚函数C.不能直接访问非静态函数D.不是对象的成员答案：A
8、派生类的对象可以访问以下那种情况继承的基类成员( )A.私有继承的私有成员B.公有继承的私有成员C.私有继承的保护成员D.公有继承的公有成员答案：D
9、所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是( )A.类B.对象C.函数体D.数据块答案：B
10、设有函数模板 template Q Sum(Qx,Qy){ return(x)+(y); } 则下列语句中对该函数模板错误的使用是( )A.Sum(10,2);B.Sum(5.0,6.7)；C.Sum(15.2f,16.0f);D.Sum(″AB″,″CD″);答案：D
11、如果类A被声明成类B的友元，则( )A.类A的成员即类B的成员B.类B的成员即类A的成员C.类A的成员函数不得访问类B的成员D.类B不一定是类A的友元答案：D
12、类B是类A的公有派生类，类A和类B中都定义了虚函数func(),p是一个指向类A对象的指针，则p->A::func()将( )A.调用类A中的函数func()B.调用类B中的函数func()C.根据p所指的对象类型而确定调用类A中或类B中的函数func()D.既调用类A中函数，也调用类B中的函数答案：A
13、有关C++编译指令，以下叙述正确的是（ ）A.C++每行可以写多条编译指令B.#include指令中的文件名可含有路径信息C.C++的编译指令可以以#或//开始D.C++中不管＃if后的常量表达式是否为真，该部分都需要编译答案：B
14、在C++中把不返回任何类型的函数应该说明为（ ）A.intB. charC.voidD.double答案：C
15、若Sample类中的一个成员函数说明如下：voidset(Sample&a)，则Sample&a的含义是（ ）A.指向类Sample的名为a的指针B.a是类Sample的对象引用，用来作函数Set（）的形参C.将a的地址赋给变量SetD.变量Sample与a按位与的结果作为函数Set的参数答案：B
16、以下叙述错误的是（ ）A.基类的保护成员在公有派生类中仍然是保护成员B.基类的保护成员在派生类中仍然是保护成员C.基类的保护成员在私有派生类中是私有成员D.基类的保护成员不能被派生类的对象访问答案：D
17、假设ClassY:publicX，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为（ ）A.X,Y；Y,XB.X,Y；X,YC.Y,X；X,YD.Y,X；Y,X答案：A
18、包含自定义头文件file.h的预处理指令是( )A.#defineB.#include file.hC.#define file.hD.#include答案：D
19、用于标识十六进制前缀或后缀是( )A.无B.后缀L或eC.前缀零D.前缀0x答案：D
20、类的构造函数在以下什么情况下会被自动调用( )A.定义成员函数时B.定义对象时C.定义数据成员时D.定义友元函数时答案：B
阶段测验四
一、 单选
1、设函数void swap(int&，int&)将交换两形参的值，如两整型变量int a=10；int b=15； 则执行swap(a，b)后，a、b值分别为( )
A.10，10
B.10，15
C.15，10
D.15，15
答案：C
2、派生类的对象可以访问以下那种情况继承的基类成员( )
A.私有继承的私有成员
B.公有继承的私有成员
C.私有继承的保护成员
D.公有继承的公有成员
答案：D
3、设存在整型变量int x，则下列句与其它三项含义不同的是( )
A.int* p=&x；
B.int& p=x；
C.int & p=x；
D.int &p=x；
答案：A
4、在下列成对的表达式中，运算结果类型相同的一对是( )
A.7／2和7.0／2.0
B.7／2.0和7／2
C.7.0／2和7／2
D.7.0／2.0和7.0／2
答案：D
5、对使用关键字new所开辟的动态存储空间，释放时必须使用（ ）
A.free
B.create
C.delete
D.realse
答案：C
6、对类中声明的变量，下列描述中正确的是（ ）
A.属于全局变量
B.只属于该类
C.属于该类，某些情况下也可被该类不同实例所共享
D.任何情况下都可被该类所有实例共享
答案：C
7、this指针存在的目的是（ ）
A.保证基类公有成员在子类中可以被访问
B.保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码
C.保证基类保护成员在子类中可以被访问
D.保证基类私有成员在子类中可以被访问
答案：B
8、在哪种派生方式中，派生类可以访问基类中的protected成员（ ）
A.public和private
B.public和protected
C.protected和private
D.仅protected
答案：B
9、在C++中使用流进行输入输出，其中用于屏幕输出的对象是（ ）
A.cerr
B.cin
C.cout
D.cfile
答案：C
10、对使用关键字new所开辟的动态存储空间，释放时必须使用（ ）
A.free
B.create
C.delete
D.realse
答案：C
11、如没有使用private关键字定义类的数据成员，则默认为（ ）
A.private
B.public
C.protected
D.friend
答案：A
12、下列哪个编译指令属于条件编译指令( )
A.#include
B.#define
C.#else
D.#pragma
答案：C
13、如果类A被声明成类B的友元，则( )
A.类A的成员即类B的成员
B.类B的成员即类A的成员
C.类A的成员函数不得访问类B的成员
D.类B不一定是类A的友元
答案：D
14、如没有使用private关键字定义类的数据成员，则默认为（ ）
A.private
B.public
C.protected
D.friend
答案：A
15、类的私有成员可在何处访问（ ）
A.通过子类的对象访问
B.本类及子类的成员函数中
C.通过该类对象访问
D.本类的成员函数中
答案：D
16、如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（ ）
A.编译器总是自动创建一个不带参数的构造函数
B.这个类没有构造函数
C.这个类不需要构造函数
D.该类不能通过编译
答案：A
17、下列关于类的权限的描述错误的是（ ）
A.类本身的成员函数只能访问自身的私有成员
B.类的对象只能访问该类的公有成员
C.普通函数不能直接访问类的公有成员，必须通过对象访问
D.一个类可以将另一个类的对象作为成员
答案：A
18、设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（ ）
A.A类构造函数先执行
B.成员构造函数先执行
C.两者并行执行
D.不能确定
答案：B
19、下列描述错误的是（ ）
A.在创建对象前，静态成员不存在
B.静态成员是类的成员
C.静态成员不能是虚函数
D.静态成员函数不能直接访问非静态成员
答案：A
20、对C++语言和C语言的兼容性，描述正确的是（ ）
A.C++兼容C
B.C++部分兼容C
C.C++不兼容C
D.C兼容C++
答案：A
阶段测验五
一、 单选
1、通常情况下，函数模板中的类型参数个数不能是( )
A.0
B.2
C.4
D.3
答案：A
2、如果类A被声明成类B的友元，则( )
A.类A的成员即类B的成员
B.类B的成员即类A的成员
C.类A的成员函数不得访问类B的成员
D.类B不一定是类A的友元
答案：D
3、关于类的静态成员函数描述错误的是( )
A.在创建对象前不存在
B.不能说明为虚函数
C.不能直接访问非静态函数
D.不是对象的成员
答案：A
4、设有函数T Sum(T x，T y){return x+y；}，其中T为模板类型，则下列语句中对该函数错误的使用是( )
A.Sum(1，2)；
B.Sum(3.0，2.2)；
C.Sum(‘A’，‘C’)；
D.Sum(
答案：D
5、下列关于析构函数描述正确的是( )
A.可以重载
B.函数体中必须有delete语句
C.返回类型必须是void类型
D.不能指定返回类型
答案：D
6、类的构造函数在以下什么情况下会被自动调用( )
A.定义成员函数时
B.定义对象时
C.定义数据成员时
D.定义友元函数时
答案：B
7、类的私有成员可在何处被访问( )
A.本类的成员函数中
B.本类及子类的成员函数中
C.通过对象名在任何位置
D.不可访问
答案：A
8、内联函数的特点是( )
A.减少代码量，加快访问速度
B.减少代码量，减缓访问速度
C.增加代码量，减缓访问速度
D.增加代码量，加快访问速度
答案：A
9、下列函数不能和函数void print(char)构成重载的是( )
A.int print(int)；
B.void print(char，char)；
C.int print(char)；
D.void print(int，int)；
答案：C
10、下列特性中，C与C++共有的是( )
A.继承
B.封装
C.多态性
D.函数定义不能嵌套
答案：D
11、下面叙述不正确的是( )
A.派生类一般都用公有派生
B.对基类成员的访问必须是无二义性的
C.赋值兼容规则也适用于多重继承的组合
D.基类的公有成员在派生类中仍然是公有的
答案：D
12、当一个类的某个函数被说明为virtual时，该函数在该类的所有派生类中( )
A.都是虚函数
B.只有被重新说明时才是虚函数
C.只有被重新说明为virtual时才是虚函数
D.都不是虚函数
答案：A
13、在C++中实现封装是借助于( )
A.枚举
B.类
C.数组
D.函数
答案：B
14、所有在函数中定义的变量，都是( )
A.全局变量
B.局部变量
C.静态变量
D.寄存器变量
答案：B
15、派生类的对象可以访问以下那种情况继承的基类成员( )
A.私有继承的私有成员
B.公有继承的私有成员
C.私有继承的保护成员
D.公有继承的公有成员
答案：D
16、下列哪个编译指令属于条件编译指令( )
A.#include
B.#define
C.#else
D.#pragma
答案：C
17、在下列成对的表达式中，运算符“+”的意义不相同的一对是( )
A.5.0+2.0和5.0+2
B.5.0+2.0和5+2.0
C.5.0+2.0和5+2
D.5+2.0和5.0+2
答案：C
18、类的指针成员的初始化是通过函数完成的，这个函数通常是( )
A.析构函数
B.构造函数
C.其它成员函数
D.友元函数
答案：B
19、要禁止修改指针p本身，又要禁止修改p所指向的数据，这样的指针应定义为( )
A.const char *p=“ABCD”；
B.char const *p=“ABCD”；
C.char *const p=“ABCD”；
D.const char * const p=“ABCD”；
答案：D
20、静态成员函数没有( )
A.返回值
B.this指针
C.指针参数
D.返回类型
答案：B
简答练习
练习题一
一、 分析1、给出下面程序的输出结果#include<iostream>using namespace std;void main(){int num=300;int &ref=num;cout<<ref;ref=ref-100;cout<<" "<<num;num=num-50;cout<<" "<<ref<<endl;}答案：300 200 150
2、给出下面程序的输出结果#include<iostream>using namespace std;class Simple{int x,y;public:Simple(){x=y=0;}Simple(int i,int j){x=i;y=j;}void copy(Simple&s);void setxy(int i,int j){x=i;y=j;}void print(){cout<<"x="<<x<<",y="<<y<<endl;}};void Simple::copy(Simple&s){x=s.x;y=s.y;}void func(Simple s1,Simple&s2){s1.setxy(30,40);s2.setxy(70,80);}void main(){Simple obj1(1,2),obj2;obj2.copy(obj1);func(obj1,obj2);obj1.print();obj2.print();}答案：x=1,y=2x=70,y=80
二、 完成 3、完成下面程序，使其输出l0，并在退出运行时正确释放分配给指针的存储空间。#include using namespace std；void main(){int*a，*p；a=new int(10)；p=______；cout<<*p<<>< strong="">__________}答案：a delete p
4、 #include using namespace std;class base{private:int x;public:base(int a){x=a;} int get(){return x;} void showbase(){cout<<"x="<<><>< strong="">};class Derived:public base{private:int y;public:Derived(int a,int b):base(a){y=b;} void showderived() {cout<<"x="<<get()<<",y="<<><>< strong="">};void main(){ base b(3); Derived d(6,7); b.showbase(); d.showderived(); b=d; b.showbase(); b1.showbase(); ________________________ base* pb=&b1; pb->showbase(); d.showderived(); b.showbase();}输出结果如下：x=3x=6，y=7x=6x=6x=6x=6，y=7x=6答案：Derived b1(d);（或Derived b1(6,7); 或base b1(6);或base b1(d);）
5、下面程序的运行结果如下：B：：display()C：：display()在下划线处填上缺少的部分。源程序如下： #include<iostream>using namespace std;class B{public: _______display( ){cout<<"B：：display( ) "<<endl;}};class C:public B{public: void display(){cout<<"C：：display()"<<endl;}};void fun(B*p){ p->display();}void main(){ B b,*pb; C c; pb=&b; fun(pb); pb=&c; fun(pb);}答案：virtual void
6、#include<iostream>using namespace std；template<class T> T fun(T x) { _____y； y=x*x-T(5)； return y； } void main() { float a=2； cout<<fun(a)； }答案：T
7、下面程序的运行结果如下： This is line1 This is line2 This is line3 在下划线处填上缺少的部分。源程序如下：#include #include using namespace std;void main(){ fstream fin, fout; fout.open("my.txt",ios::out); if(!fout.is_open()) return; for(int i=0;i<3;i=i+1) fout<<"This is line"<<><>< strong=""> fout.close(); fin.open("my.txt",ios::in); if(! fin.is_open()) return; char str; while(!fin.eof()) { fin.getline(str,100); cout<<><>< strong=""> } fin.close();}答案：<fstream>
三、 改错8、下面有一处错误，请给出修改意见。#include class test{ private：int x； public：test(int a){x=a；} void set(int a){x=a；} void get(){cout<<><>< strong="">} main(){ const test a(3)；a.set(5)；a.get()； } 答案：缺少分号;
9、下面有一处错误，请给出修改意见。#include class point{ private：float x，y； public：f1(float a，float b){x=a；y=b；} point(){x=0；y=0；} void getx(){cout<<><>< strong=""> void gety(){cout<<><>< strong=""> }；void print(point a){cout<<><>< strong="">main(){ point a；a.f1(3.0，5.0)； print(a)； }答案：应将print函数说明为point类的友元函数
10、下面有一处错误，请给出修改意见。#includeclass f{ private：int x，y； public：fl(int a，int b){x=a；y=b；} void print(){cout<<><><>< strong="">} ；main(){ f a; a.f1(1.5，1.8)；a.print()；}答案：实际参数类型与f1函数的形参，应修改为一致。
11、 下面有一处错误，请给出修改意见。#includemain(){int x=6；const int*p=x；cout<<*p<<>< strong="">}答案：应改为const int*p=&x；
12、下面有一处错误，请给出修改意见。#include class f{ private：float x，y； public：f(float a，float b){x=a；y=b；} float max(){return(x<>< strong=""> }； main( ){ f a(1.5，3.8)； cout<<><> }答案：应改为float max(){return(x>y)?x：y；}
四、 填空 13、 若使用标准输出流把整型变量a的值输出到屏幕上，实现此操作的C++语句是______。答案：cout<<a;
14、 C++将数据从一个对象流向另一个对象的流动抽象为“流”，从流中获取数据的操作称为______。答案：提取
15、 执行下列代码int b=100；cout<<"hex："<<><>程序的输出结果是______。<>答案：Hex:64
16、 静态联编所支持的多态性称为______的多态性。答案：编译时
17、 C++程序必须有且只有一个主函数，其函数名为______。答案：main
18、 写出声明一个复数对象的语句，并使该对象被初始化为2.2+1.3i，此声明语句是______。答案：complex c(2.2,1.3);
19、 若有函数定义为：int add(int ml=0，int m2=2，int m3=4){return ml+m2+m3；}在主函数中有int s=add(1)+add(0，1)+add(0，1，2)；则执行此语句后s的值为______。答案：15
20、 C++中使用______关键字说明函数为内联函数。答案：inline
21、 在源程序中有宏定义：#define PI 3.14，则若不想使该宏定义影响到程序的其它地方，可以使用_____删除该宏定义。答案：#undef PI
22、 类和其它数据类型不同的是，组成这种类型的不仅可以有数据，还可以有对数据进行操作的_______。答案：函数
23、 有下列代码int a=0；double b=0；cin>>a>>b；当用键盘输入1.25时，b=______。答案：0.25
24、 对于类Point而言，其析构函数的定义原型为______。答案：~Point();
25、 对象成员构造函数的调用顺序取决于这些对象在类中说明的顺序，与它们在成员初始化列表中给出的顺序______。答案：无关
26、 类的简单成员函数是指声明中不含______、volatile、static关键字的函数。答案：const
27、 与操作对象的数据类型相互独立的算法称为______。答案：泛型算法
28、 从一个或多个以前定义的类产生新类的过程称为______。答案：派生
29、 在vector类中向向量尾部插入一个对象的方法是______。答案：push_back()
30、 C++中用于动态创建对象，并返回该对象的指针的关键字是______。答案：new
31、 C++的流类库预定义的与标准输出设备相联接的流是__ ____。答案：cout
32、 执行下列代码cout<<><>程序输出结果是______。<>答案：123
练习题二
一、 分析1、给出下面程序的输出结果。#includetemplateclass Sample{T n；public：Sample(T i){n=i;}int operator==(Sample &)；}；templateint Sample:: operator==(Sample＆s){if(n==s.n)return 1；else return 0； }void main( ){Samplesl(2)，s2(3)；cout<<″s1与s2的数据成员″<<(sl==s2 ?″相等″：″不相等″)<<>< p="">Samples3(2.5)，s4(2.5)；cout<<″s3与s4的数据成员″<<(s3==s4 ? ″相等″：″不相等″)<<>< p="">}答案：S1与S2的数据成员不相等S3与S4数据成员相等
2、给出下面程序的输出结果。#include<iostream>using namespace std；template<class T>T max(T ml，T m2){return(m1>m2)?ml:m2:}void main( ){cout<<max(1，7)<< ″\t″<<max(2.0，5.0)<<endl；cout<<max(′y′,′b′<<″＼t″<<max(″A″，″a″)<<endl；}答案：7 5y a
二、 完成 3、完成下面类中的成员函数的定义。 class point { private： int m，n； public： point(int，int)； point(point&)； }； point::point(int a，int b) { m=a；__=b；} point::point(point&t) { m=t.m； n=t.n； }答案：n
4、下面是一个输入半径，输出其面积和周长的C++程序，在下划线处填上正确的语句。#include using namespace std；const double pi=3.14159；void main( ){double r； cout<<″r=″； _______; double l=2.0*pi*r；double s=pi*r*r；cout<<″＼n The long is：″<<><>< p=""> cout<<″The area is：″<<><>< p=""> }答案：cin>>r
5、在下划线处填上缺少的部分。 #include #include using namespace std； class complex { public： int real； int imag； complex(int r=0，int i=0) { real=r； imag=i； } }； complex operator+( _________，complex& b) { int r=a.real+b.real； int i=a.imag+b.imag； return complex(r,i); } void main( ) { complex x(1，2)，y(3，4)，z； z=x+y； cout<<><><><><>< p=""> }答案：complex& a
6、程序的输出结果如下：1，950，30请根据输出数据在下面程序中的下划线处填写正确的语句。源程序如下：#includeusing namespace std；class base{private：int m；public：base( ){ }；base(int a):m(a){}int get( ){return m;}void set(int a){m=a;}}；void main(){base*ptr=new base；ptr- >set(30)；ptr=_______ ;ptr- >set(50)；base a={1，9}；cout<<>< p=""><>cout<get( )<<″，″；ptr=ptr-1；cout<get()<<>< p="">delete[ ]ptr；}答案：ptr+1
7、在下面横线处填上求两个浮点数之差的cha函数的原型声明、调用方法。#includeusing namespace std；void main( ){float a，b；float cha(float,float);／／函数cha的原型声明a=12.5；b=6.5；float c= ； ／／调用函数cha cout<<><>< p="">}float cha(float x，float y){float w；w=x-y；return w；}答案：cha(a,b)
三、 改错 8、#includevoid main( ) {int x=5，y=6；const int * p=＆x；*p=y；cout<<*p<<>< p="">} 答案：*p=y; 指针p所指向的为一常量，不能进行左值操作
9、#includeclass f{private：int x，y；public：f1( ){x=0；y=0；}print( ){cout<<><><><>< p="">};void main( ){f a；a.f1(1,1)；a.print( )；}答案：a.f1(1,1); f1( )调用时实参与形参数量不一致
10、#include class f{ private：int x=0，y=0； public：void f1(int a，int b){x=a；y=b；} void get( ){cout<<><><><>< p=""> }；voidmain( ){ f a； a.f1(1,3)； a.get ( )； } 答案：private:int x=0,y=0; 数据成员声明时不允许直接赋值
11、#includeclass point{private：float x； public：void f(float a){x=a;} void f( ){x=0;} friend float max(point& a，point& b)； }； float max(point& a，point& b){return(a.x>b.x)? a.x：b.x；}void main( ){ point a，b； a.f(2.2)；b.f(3.3)； cout<<>< p=""> }答案：cout<不能调用
12、#include templateclass f{private：T x，y；public：void f1(T a，T b){x=a；y=b；}T max( ){retum(x>y)?x:y;}}；void main( ){f a；a.f1(1.5,3.8)； ’cout<<><><>< p="">}答案：cout<
四、 填空13、 设要把一个文件输出流对象myFile与文件“f：＼myText.txt相关联，所用的C++语句是：（）。答案：myFile.open(“f:\myText.txt”);
14、 C++中ostream类的直接基类是（） 类。答案：ios
15、 运算符[ ]只能用( )运算符来重载，不能用友元运算符来重载。答案：成员
16、 定义虚函数所用的关键字是()。答案：virtual
17、 vector类中用于返回向量中第1个对象的方法是front( )。答案：front()
18、 在C++中，利用向量类模板定义一个具有20个char的向量E，其元素均被置为字符‘t’，实现此操作的语句是()答案：vectorE(20,‘t’)
19、 类的继承是指子类继承基类的()和成员函数。答案：数据成员
20、 不同对象可以调用相同名称的函数，但可导致完全不同的行为的现象称为()。答案：多态性
21、 ()指令指示编译器将一个源文件嵌入到带该指令的源文件之中。答案：#include
22、 设类A有成员函数void Fun(void)；若要定义一个指向类成员函数的指针变量pafn来指向Fun，该指针变量的声明语句是：()答案：void(A::*pafn)(void);
23、 设在程序中使用如下语句申请了一个对象数组：Point * ptr = new Point；则在需要释放ptr指向的动态数组对象时，所使用的语句是()答案：delete[ ]ptr;
24、 在保护派生中，基类权限为Private的成员在派生类()中 。答案：不可访问
25、 类A有如下成员函数int A::fun(double x){return (int) x／2；}int A::fun(int x){return x*2；}设a为类A的对象，在主函数中有int s=a．fun(6.0)+a.fun(2)，则执行该语句后，s的值为 () 。答案：7
26、 对象传送的消息一般由3部分组成：接收对象名、调用操作名和()。答案：必要的参数
27、 将指向对象的指针作为函数参数，形参是对象指针，实参是对象的()。答案：地址值
28、 在使用string类的find成员函数来检索主串中是否含有指定的子串时，若在主串中不含指定的子串，find函数的返回值是() 。答案：-1
29、 在C++中，声明布尔类型变量所用的关键字是() 。答案：bool
30、 执行下列代码int a=29，b=100；cout <程序的输出结果是：()。答案：29100
31、 执行下列代码cout <<″hex：″<< hex=答案：Hex:ff
32、 C++语言中可以实现输出一个换行符并刷新流功能的操控符是()。答案：endl
练习题三
一、 分析 1、写出下面程序的输出结果： # include class FunArray{ int*pa;//指向一个数组空间 int size;//数组元素个数 public: FunArray(int a[ ],int thesize):pa(a),size(thesize){ } int Size( ){return size;} int& operator[ ](int index){return pa;} }; void main( ){ int s[ ]={3,7,2,1,5,4}; FunArray ma(s,sizeof(s)/sizeof(int)); ma=9; for(int i=1;i<=ma.Size( );i++) cout<<><>< p=""> }答案：3,7,9,1,5,4,
2、写出下面程序的输出结果： # include template class Tclass{ T x,y; public: Tclass(T a,T b):x(a){y=b;} Tclass(T a){y=(T)0,x=a;} void pr( ){ char c; c=(y>=(T)0?′+′:′-′); cout<<><><(y>(T)0? y:-y)<<″i″<<>< p=""> } }; void main( ){ Tclassa(10.5,-5.8); a.pr( ); Tclassb(10); b.pr( ); }答案：10.5-5.8i10+0i
二、 完成3、在下面程序横线处填上适当内容，以使该程序执行结果为： 12 88 # include template class Tany{ public: ; void pr(){ if(sizeof(int)==sizeof x） count<<(x>y? x:y)<<>< p=""> else cout<<(x>y? y:x)<<>< p=""> } }; void main( ){ Tanydobj={12.0,88.0}; dobj.pr( ); Tany iobj={12,88}; iobj.pr( ); }答案：T x,y
4、在下面的横线处填上适当内容，使程序完整。 # include<iostream.h> # include<math.h> class loc{ private: float x,y; public; loc() {float x1,float y1； x=x1; y=y1; } float getx( ){return x;} float gety( ){return y;} ② float dis(loc&,loc&); }; float loc::dis(loc&a,loc&b) { flost dx=a.x-b.x; flost dy=a.y-b.y; return sqrt(dx*dx+dy*dy); } void main( ) { loc pl(3.5,4.5),p2(5.5,6.5); float d=loc::dis(p1,p2); cout<<“The distance is”<<d; }答案：static
5、在下面程序中的横线处填上适当内容，使程序完整。 # include class vehicle { protected: int size; int speed; public; void setSpeed(int s){speed=s;} virtual int getSpeedLevel( ){return speed/10;} }; class car:public vehicle { public: int getSpeedLeve( ){return speed/5;} }; class truck:public vehicle { public: int getspeedLevel( ){return speed/15;} }; int maxSpeedLevel(vehicle &v1 ,vehicle ) { if(v1.getSpeedLevel( )>v2.getSpeedLevel( )) return 1; else reutrn 2; } void main() { turck t; car c; t.setSpeed(130); c.setSpeed(60); cout<<><> }答案：&v2
6、在下面横线处填上合适内容，完成类B的定义。 # include class A{ public:A( ){a=0;} A(int i){a=i;} void print( ){cout<<><>< p=""> private:int a; }; class B:public A{ public:B( ){b1=b2=0} B(int i){b1=i;b2=0;} B(int i,int j,int k): {b1=j;b2=k;}//使a的值为i void print( ){A::print( );cout<<><><><>< p=""> private:int b1,b2; }答案：A(i)
7、根据注释在空白处填写适当内容。 class Location{ private: int X,Y; public: void init(int initX,int initY); int GetX( ); int GetY( ); }; void Location::init(int initX,int initY) { X=initX; Y=initY; } int Location::GetX( ) { reutrn X; } int Location::GetY( ) { reutrn Y; } # include void main( ) { Location A1;A1.init(20,90); Location &rA1 =A1；//定义一个指向A1的引用rA1 //用rA1在屏幕上输出对象A1的数据成员X和Y的值 }答案：cout<
三、 改错8、下面的类定义有一处错误，请用下横线标出错误所在行并改正错误。 class A{ int a; public; A(int aa):a=aa{ } };答案：第4行有错“:a=aa”有错，应改为“：a（aa）”或等价的写法
9、下面的程序先把字符串“Look out!”输出到一个文件中，然后再从该文件输入，并显示在屏幕上，显示效果为Look out!。程序中有一处错误，请用下横线标出错误所在行，并给出更改意见。 # include void main(){ ofstream outf(“D:\\tem.dat”,ios::trunc); outf<<“Look out!”; outf.close( ); ifsteam inf(“D:\\tem.dat”); char k;inf>>k;count<<>< p=""> inf.close( ); }答案：第7行错，应改为：char k;while(inf.get(k)) cout<
10、下面的程序有一处错误，请用下横线标出错误所在行并改正错误。 # include class Test{ public; static int x; }; int x=20;//对类成员初始化 void main ( ) { cout<<>< p=""> }<>答案：程序中第6行错误，该行应为: int Test::x=20
11、下面的程序类B的定义中有一处错误，请用下横线标出错误所在行并说明错误原因。 # include # include class A{ public:A(const char *nm){strcpy(name,nm);} private:char name; }; class B:public A{ public:B(const char *nm):A(nm){ } void PrintName( )const; }; void B:: PrintName( )const{ cout<<“name:”<<><>< p=""> } void main( ){ B b1(“wang li”); b1.PrintName( ); }答案：第12行有错，因为在类B中，name是由类A私有成员继承来的，不能被派生类访问。
12、用下横线标出下面程序main函数中的错误所在行，并说明错误原因。 # include class Location{ private: int X,Y; public; void init(int initX,int initY); int sumXY( ); }; void Location::init(int initX,int initY) { X=initX; Y=initY; } int Location::sumXY( ) { return X+Y; } void main( ) { Location A1; int x,y; A1.init(5,3); x=A1.X;y=A1.Y; cout<<><”p=""><><> }答案：第24行语句x=A1.X;y=A1.Y;有错，因为main函数不能访问对象A1的私有成员。
四、 填空 13、 重载“<<”操作符时，应声明为 ____ 函数。答案：友元
14、 在C++中，编译指令都是以____________（符号）开始。答案：＃
15、假定要把aa定义为AB类中的一个引用整数型数据成员，则定义语句为____________。答案：int &aa
16、C++支持两种多态性，编译时的多态性和____________时的多态性。答案：运行
17、假定用户为类AB定义了一个构造函数“AB(int aa=0):a(aa){}”，则定义该类的对象时，可以有____________种不同的定义格式。答案：2
18、若p指向x，则____________与x的表示是等价的。答案：*p
19、C++的流库预定义了4个流，它们是cin、cout、cerr和____________。答案：clog
20、当函数参数表用____________保留字表示时，则表示该参数表为空。答案：void
21、每个对象都是所属类的一个____________。答案：实例
22、作为类的成员函数重载一个运算符时，参数表中只有一个参数，说明该运算符有____________个操作数。答案：2
23、设函数max是由函数模板实现的，并且max(3.5,5)和max(10,5)都是正确的函数调用，则该模板具有______个类型参数。答案：2
24、在单继承和多继承方式中，面向对象的程序设计应尽量使用______继承。答案：单一（或单）
25、语句序列 ifstream datafile； datafile.open(“data.dat”)； 的功能可用一个语句实现，这个语句是______。答案：ifstreamdatafile(“data.dat”)
26、将关键字const写在函数头之后，函数体之前，说明该函数是一个const成员函数。此时const不是指定函数的返回值，而是修饰______指针。答案：this
27、一个抽象类的派生类可以实例化的必要条件是实现了所有的______。答案：纯虚函数
28、在C++中，虚函数帮助实现了类的______性。答案：多态
29、通过C++语言中类的______，可以扩充和完善已有类以适应新的需求。答案：继承机制
30、为了在对象生存期结束时释放其指针成员所指向的动态存储空间，通常需要为该类定义______。答案：析构函数
31、在联合中，所有数据成员具有______的地址，任一时刻只有一个数据成员有效。答案：相同
32、在已经定义了整型指针ip后，为了得到一个包括10个整数的数组并由ip所指向，应使用语句______。答案：ip = new int;
练习题四
一、 分析 1、当从键盘上输入1.510时，写出下面程序的执行结果。 #include<iostream.h> void mian() { int a,b,c; char ch; cin>>a>>ch>>b>>c;//从键盘上输入1.510 cout<<a<<endl<<ch<<endl<<b<<endl<<c; } 输出为：答案：1 . 5 10
2、写出下面程序的输出结果。#include class FUN{friend ostream& operator <<(ostream&,FUN);}fun; ostream& operator<<(ostream& os,FUN f){os.setf(ios::left);return os; } void main() {cout<<><><><>< p="">cout<<><><><>< p=""> } 输出为：答案：* * * * * 12345 54321 * * * * *
二、 完成 3、在下面程序段横线处填上适当的内容。 class A{ ________ int n; public: A(int nn=0):n(nn){ if(n==0)a=0; else a=new int; } ～A(){delete［］a；} //定义析构函数，释放动态数组空间 };答案：int *a；
4、在下面程序横线处填上适当内容，使程序执行结果为： 200_ _ 100 程序如下： #include template ＜class T＞ Tf(Tx,Ty){ if(sizeof(T)==__________) return x+y; else return x*y; } void main(){cout <<><><><>< p=""> }答案：sizeof（double）
5、下面程序三次调用同一函数sum，在横线处填上适当内容，使输出结果为： S=2 S=5 S=9 程序如下： #include void sum(int i) { static int s; s＋＝2＋i; cout<<″S=″<<><>< p=""> } void main (void) { int i; for (i=0;________) sum(i); }答案：i＜3；i++
6、请在下面横线处填上适当的内容，使程序的输出为： 7.00000 7程序如下： #include viod main(){double x=7;cout<<><>cout<<><><>< p=""> }答案：resetiosflags(ios::showpoint)
7、在下面程序横线处填上适当的内容，使该程序输出结果为： Creating B end of B end of A 程序如下： #include class A {public: A(){} virtual ～A() {cout<<″end of A″<<>< p=""> }; calss B:public A {public: B(){________} ～B(){cout<<″end of B″<<>< p=""> }; void main() {A*pa=new B;delete pa }答案：cout<<”creating B”<
三、 改错 8、此类定义有一处错误，请指出错误并改正。 class ABC{ int a; public: ABC(int aa)a(aa){} };答案：ABC（int aa）与a（aa）｛｝之间少一个冒号，应改为ABC（tnt lla）：a（aa）{}
9、下面程序通过调用函数模板实现计算两个正整数的最大公约数，把main函数中错误找出并改正过来。 #include template T gcd(Tx,Ty){ while(x! =y)if(x>y)x-=y;else y-=x; return x; } void main() { int a; double d; cin>>a>>d; cout<<><>< p=""> }答案：main函数中的gcd（a，d）改为gcd（a，（int）d） （或把double d；改为int ; 或把gcd(a，d)改为gcd＜int>（a，d）或把gcd(a，b)改为gcd（a，int (a)）＝
10、指出下面程序中的错误，并说明出错原因。 #include class ConstFun{ public:void ConstFun(){}const int f5()const{return 5;}int Obj() {return 45;}int val;int f8(); }; int ConstFun::f8(){return val;} void main() {const ConstFun s;int i=s.f5();cout<<″Value=″<<><>< p=""> }答案：程序中第4行“void ConstFun（）{}”错误，因为声明构造函数时不能指定返回类型。
11、指出下面程序中的错误，并说明错误原因。 #include class A{ public:void fun(){cout<<″a.fun″<<>< p=""> }; class B{ public:void fun(){cout<<″b.fun″<<>< p="">void gun(){cout<<″b.gun″<<>< p=""> }; class C:public A,public B{ private:int b; public:void gun(){cout <<″c.gun<<″endl;} };void main(){ c obj; obj.fun(); obj.gun(); }答案：第15行 obj.fun()；语句错误，因为用C类的对象obj对函数fun（）的访问是两义的,应使用成员名限定来消除两义性。
12、指出下面程序段中的错误，并说明出错原因。
class Location {int X,Y; protected:int zeroX,zeroY;int SetZero(int zeroX,int zeroY){X=zeroX;Y=zeroY;} private:int length,height; public:float radius;void init(int initX,int initY){length=initX;height=initY;}int GetX(){return X;}int GetY(){return Y;} }; int main(){ Location retangleA={25,20,3,5,6,7,3}; return 0; }答案：location retangleA＝{25，20，3，5，6，7，3}；语句错误，因为数据成员不都是公有成员，不能用初始化列表初始化
四、 填空13、 在用C＋＋进行程序设计时，最好用___________________代替malloc。答案：new
14、 函数模板中紧随template之后尖括号内的类型参数都要冠以保留字________________。答案：class
15、 在ios类中定义的用于控制输入输出格式的枚举常量中，用于代表十进制、八进制和十六进制的3个枚举常量是dec、oct和___________________。答案：hex
16、 如果重载了运算符＋，则相应的运算符函数名是___________________。答案：operator+
17、 由static修饰的数据成员为该类的所有对象___________________。答案：共享
18、 为了实现多态性，派生类需重新定义基类中的___________________。答案：虚函数
19、 编译时的多态性通过___________________函数实现。答案：重载
20、 在派生类中实现基类成员的初始化，需要由派生类的构造函数调用_________________来完成。答案：基类的构造函数
21、 在C＋＋中，访问指针所指向的对象的成员使用运算符___________________。答案：->
22、 重载函数在参数类型或参数个数上不同，但___________________相同。答案：函数名
23、 模板定义中标识类型的参数必须用关键字_________修饰。答案：class（或typcname）
24、 假定用户没有给一个名为AB的类定义析构函数，则系统自动给出的缺省析构函数定义为__________。答案：～AB（）｛｝
25、 表达式count<<hex还可表示为_________。答案：cout，sctf（ios：：hex，ios：：basefield）
26、 通过C++语言中的_________机制，可以从现存类中构建其子类。答案：继承（或派生）
27、 要在调用虚函数的时候强制进行静态联编，可以通过在调用中对虚函数加_________实现。答案：域名限制（或其它含义等价的描述）
28、 封装要求一个对象应具备明确的功能，并具有_________以便和其它对象相互作用。答案：接口〈或界面．或公有成员〉
29、 在删除一个动态对象时，将自动调用该动态对象所属类的_________函数。答案：析构
30、 静态成员函数、友元函数、构造函数和析构函数中，不属于成员函数的是_________。答案：友元函数
31、在下面的类定义中，私有成员有_________。 class Location {int X,Y; protected: int zeroX,zerxY; int SetZero(intzeroX, intzeroY); private: int length,height; public: void init(int initX,int initY); int GetX(); int GetY(); };答案：X,Y,length，height
32、类的私有成员只能被它的成员函数和_________访问。答案：友元类（或友元函数，或友元）
练习题五
一、 分析1、＃include <iostream.h> void main( ) { int *a; int *&p=a; int b=10; p=&b; cout<<*a; } 输出为：答案：10
2、＃include template Tf(T*a,T*b,int n){Ts=(T)0;for(int i=0;i<>< p="">s+=a*b；return s; } void main() { double c ={1.1,2.2,3.3,4.4,5.5},d={10.0,100.0,1000.0}; cout<<><>< p=""> } 输出为：答案：3531
二、 完成3、在下面横线处填上适当字句，完成类中成员函数的定义。class A{int * a; public:A(int aa=0) { a=new int(aa);//用aa初始化a所指向的动态对象}～A(){_________;}//释放动态存储空间};答案：delete a
4、下面是一个函数模板，用于计算两个向量的和。在下面横线处填上适当字句，完成函数模板定义。＃includetemplateT* f(T* a,T* b,int n){T* c=_________;for(int i=0;i<>< p="">c=a+b;return c;}void main(){int a={1,2,3,4,5},b={10,20,30,40},*p;p=f(a,b,5);for(int i=0;i<5;i++)cout<<><>< p="">}答案：new int
5、下面是一个用户口令检查程序，在横线处填上适当语句完成程序功能。＃include＃includeconst char *PASS=″wolleh″;//定义由PASS指针所指向的口令wolleh。void main(){char user;//用于存放输入的口令cout<<″please input your password:″<<>< p="">_________//输入口令if((strcmp(user,PASS))==0) cout<<″your password is correct″<<>< p="">else cout<<″your password is error″<<>< p="">}答案：cin>>user;
6、下面是类fraction(分数)的定义，其中重载的运算符<<以分数形式输出结果，例如将三分之二输出为2/3。在横线处填上适当字句。class fraction{ int den; //分子 int num; //分母 friend ostream& operator<<(ostream&,fraction); …};ostream& operator <<(ostream& os,fraction fr){ os<<fr.den<<′/′<<fr.num; return _________;}答案：os
7、在下面程序横线处填上适当的字句，使其输出结果为0，56，56。＃include <iostream.h>class base{ public:在下面程序横线处填上适当的字句，使其输出结果为0，56，56。＃include <iostream.h>class base{ public:_________func( ){return 0;}};class derived:public base{ public: int a,b,c; _________ setValue(int x,int y,int z){a=x;b=y;c=z;} int func( ){return(a+b)*c;}};void main(){base b;derived d;cout<<b.func( )<<′,′;d.setValue(3,5,7);cout<<d.func( )<<′,′;base& pb=d;cout<<pb.func( )<<end1;}func( ){return 0;}};class derived:public base{ public: int a,b,c; _________ setValue(int x,int y,int z){a=x;b=y;c=z;} int func( ){return(a+b)*c;}};void main(){base b;derived d;cout<<b.func( )<<′,′;d.setValue(3,5,7);cout<<d.func( )<<′,′;base& pb=d;cout<<pb.func( )<<end1;}答案：void
三、 改错8、指出下面程序段中的错误，并说明出错原因。class A{int a,b;public：A(int aa,int bb) {a=aa;b=bb;}};Ax(2,3),y(4);答案：Ax(2,3),y(4);语句出错，因为没有单参数的构造函数(或者y(4)少写了一个参数)。
9、指出并改正下面利用类模板的对象定义中的错误。templateclass Tany{ T x,y;public: Tany(T a,T b){x=a,y=b;} T sum( ){return x+y;}};Tany (int) obj(10,100);答案：Tany(int) obj(10,100);出错，应为Tany obj(10,100);语句。
10、指出下面程序段中的错误，并说明出错原因。class one{ private:int a; public:void func(two&);};class two{ private:int b;friend void one::func(two&);};void one::func(two& r){ a=r.b;}答案：void func(two&);出错，two尚未声明(或应在class one前加声明语句class two；)。
11、指出下面程序段中的错误，并说明出错原因。＃includeclass A{public:void fun( ){cout<<″a.fun″<<>< p="">};class B{public:void fun( ){cout<<″b.fun″<<>< p="">void gun( ){cout<<″b.gun″<<>< p="">};class C:public A,public B{private:int b;public:void gun( ){cout<<″c.gun″<<>< p=""> void hun( ){fun( );}};答案：void hun(){fun();}出错，C：：fun()有二义性。
12、指出下面程序段中的错误，并说明出错原因。class Location { int X,Y=20;protected: int zeroX,zeroY; int SetZero(int ZeroX,int ZeroY);private: int length,height;public: float radius; void init(int initX,int initY); int GetX( ); int GetY( );};答案：int X,Y=20;出错，不能采用这种方式初始化。
四、 填空13、 对象的四大基本特性是多态性、继承性、______和封装性。答案：抽象性
14、 为了使类中的成员不能被类外的函数通过成员操作符访问，则应把该成员的访问权限定义为______。答案：private
15、 C++程序的源文件扩展名为______。答案：cpp
16、 所有模版都是以______关键字和一个形参表开头的。答案：template
17、 定义类的动态对象数组时，系统只能够自动调用该类的_________构造函数对其进行初始化。答案：无参
18、 在C++程序设计中，建立继承关系倒挂的树应使用_________继承。答案：单
19、 表达式cout<<end1还可表示为_________。答案：cout<<′\n′
20、 基类的公有成员在派生类中的访问权限由_________决定。答案：访问控制
21、 C++支持的两种多态性分别是编译时的多态性和_________多态性。答案：运行时的(或动态，或虚函数)
22、 C++中语句const char * const p=″hello″；所定义的指针p和它所指的内容都不能被_________。答案：改变(或重新赋值)
23、 假定AB为一个类，则语句AB(AB&x)；为该类_________构造函数的原型说明。答案：复制初始化(或拷贝)
24、 将关键字const写在成员函数的函数头和_________之间时，所修饰的是this指针。答案：函数体
25、 在C++中，访问一个对象的成员所用的运算符是成员选择运算符，访问一个指针所指向的对象的成员所用的运算符是_________。答案：成员访问运算符(或“->”)
26、 派生类从一个或多个以前定义的该类的_________继承数据和函数。答案：基类
27、 在#include命令中所包含的头文件，可以是系统定义的头文件，也可以是______定义的头文件。答案：用户
28、 一个const对象只能访问______成员函数。答案：const
29、 C++是通过引用运算符______来定义一个引用的。答案：&
30、 若y是x的引用，则对y的操作就是对______的操作。答案：x
31、执行______操作将释放由p所指向的动态分配的数据空间。答案：delete p
32、C++的流库预定义了4个流，它们是cin、cout、______和clog。答案：cerr综合作业
一、 设计
1、编写一个三角形类，有计算面积，显示面积的功能等，并测试。要求有参数的构造函数及复制构造函数。
答案：class|~|;|(|)|float|{|}
2、下面是定义二次多项式ax2+bx+c所对应的类#include#includeclass Quadratic { double a,b,c;public: Quadratic(){a=b=c=0;} Quadratic(double aa,doble bb,double cc); Quadratic operator +(Quadratic&x); Quadratic operator -(Quadratic&x); double Compute(double x); int Root(double& r1,doble& r2); void Print();};其中：加、减操作符重载函数完成*this和x的加或减运算，并将运算结果返回；Compute函数根据x的值计算二次多项式ax2+bx+c=0的根，要求当不是二次方程（即a=0）时返回-1，当有实根时返回 1，并由引用参数r1和r2带回这两个实根，当无实根时返回0；Print函数按ax**2+bx+c的格式(x2用x**2表示)输出二次多项式，并且当b和c的值为负时，其前面不能出现加号。试写出在类定义中声明的每个成员函数在体外的定义。
答案：main|Root|Print|;|(|)|{|}
3、在三角形类TRI实现两个函数，功能是输入三个顶点坐标判断是否构成三角形 #include #include class point{ private：float x，y； public：point(float a，float b){x=a;y=b;} point( ){x=0；y=0；} ， void set(float a，float b){x=a;y=b;} float getx( ){return x;} float gety( ){return y;} }； class tri{ point x，y，z； float s1，s2，s3； public;．．．settri(．．．．)；／／用于输入三个顶点坐标 ．．．．test(．．．．)；／／用于判断是否构成三角形 }；请写出两个函数的过程(如果需要形式参数，请给出形参类型和数量，以及返回值 类型)
答案：settri|sqrt|;|(|)|float|{|}
4、请定义一个矩形类(Rectangle),私有数据成员为矩形的长度(len)和宽度(wid),无参构造函数置len和wid为0，带参构造函数置len和wid为对应形参的值，另外还包括求矩形周长，求矩形面积、取矩形长度、取矩形宽度、修改矩形长度和宽度为对应形参的值，输出矩形尺寸等公用成员函数。要求输出矩形尺寸的格式为”length:长度，width:宽度”。
答案：class|main|;|(|)|float|{|}
5、定义堆栈类模板Stack(先进后出)，栈的大小由使用者确定。要求该类模板对外提供 如下二种基本操作： (1)push入栈(2)pop出栈，用数组来实现 #include using namespace std； template class Stack{ T x； int current； public： Stack(){current=0；} ....push(....)； ....pop(....)； }; 请写出两个函数的过程(如果需要形式参数，请给出形参类型和数量，以及返回值类型)
答案：template|Push|Pop|;|(|)|int|{
页:
[1]