面向对象程序设计形成性考核册作业四
一、填空题：
1. 设px是指向一个类对象的指针变量，则执行 "delete px;"语句时，将自动调用该类的( C )。
A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 拷贝构造函数
2. 假定AB为一个类，则执行 "AB a[10];"语句时调用该类无参构造函数的次数为( D )。
A. 0 B. 1 C. 9 D. 10
3. 假定AB为一个类，则执行 "AB a(2), b[3], *p[4];"语句时共调用该类构造函数的次数为( B )。
A. 3 B. 4 C. 5 D. 9
4. 假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行"delete []px;"语句时共调用该类析构函数的次数为( C )。
A. 0 B. 1 C. n D. n+1
5. 对类中引用成员的初始化是通过构造函数中给出的( C )实现的。
A. 函数体 B. 参数表 C. 初始化表 D. 初始化表或函数体
6. 一个类的静态数据成员所表示属性 ( C )。
A. 是类的或对象的属性 B. 只是对象的属性
C. 只是类的属性 D. 类和友元的属性
7. 被非静态成员函数访问的类的数据成员(A )。
A. 可以是非静态数据成员或静态数据成员 B. 不可能是类的静态数据成员
C. 只能是类的非静态数据成员 D. 只能是类的静态数据成员
8. 引入友元的主要目的是为了（ C ）。
A. 增强数据安全性 B. 提高程序的可靠性
C. 提高程序的效率和灵活性 D. 保证类的封装性
9. 在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（ B ）。
A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符
C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符
10. 如果表达式a+b中的"+"是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ A ）。
A. a.operator+(b) B. b.operator+(a)
C. operator+(a,b) D. operator(a+b)
11. 如果表达式++a中的"++"是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ D ）。
A. a.operator++(1) B. operator++(a)
C. operator++(a,1) D. a.operator++()
12. 一个程序中数组a和变量k定义为"int a[5][10],k;"，且程序中包含有语句"a(2,5)=++k*3;"，则此语句中肯定属于重载操作符的是（ A ）。
A. ( ) B. = C. ++ D. *
13. 下面是重载双目运算符+的普通函数原形，其中最符合+原来含义的是（ A ）。
A. Value operator+(Value, Value); B. Value operator+(Value,int);
C. Value &operator+(Value, Value); D. Value &operator+(Value&, Value&);
14. 关于插入运算符<<的重载，下列说法不正确的是（ B ）。
A. 运算符函数的返回值类型是ostream & 。
B. 重载的运算符必须定义为类的成员函数。
C. 运算符函数的第一个参数的类型是ostream & 。
D. 运算符函数有两个参数。
15. C++的继承性允许派生类继承基类的（ C ）。
A. 部分特性，并允许增加新的特性或重定义基类的特性
B. 部分特性，但不允许增加新的特性或重定义基类的特性
C. 所有特性，并允许增加新的特性或重定义基类的特性
D. 所有特性，但不允许增加新的特性或重定义基类的特性
16. 对于公有继承，基类中的私有成员在派生类中将 ( C )。
A. 能够直接使用成员名访问 B. 能够通过成员运算符访问
C. 仍然是基类的私有成员 D. 变为派生类的私有成员
17. 建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为（ C ）的构造函数。
A. 自己所属类、对象成员所属类、基类
B. 对象成员所属类、基类、自己所属类
C. 基类、对象成员所属类、自己所属类
D. 基类、自己所属类、对象成员所属类
18. 下列对派生类的描述中错误的说法是：（ D ）。
A. 派生类至少有一个基类
B. 派生类可作为另一个派生类的基类
C. 派生类除了包含它直接定义的成员外，还包含其基类的成员
D. 派生类所继承的基类成员的访问权限保持不变
二、填空题
1. 当一个队列为满时，不能对其做___插入_____元素的操作。
2．在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，当链队非空时，__ elemHead->next ___________指向队首结点的后继（即下一个）结点。
3. 在一个用链表实现的队列类中，若链队为空或只含有一个结点，则队首指针的值与队尾指针的值___相同_____。
4．一个类的___析构_______函数通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。
5．定义类动态对象数组时，其元素只能靠自动调用该类的___无参构造函数_________来进行初始化。
6. 假定 AB为一个类，则执行"AB a[10];"语句时，系统自动调用该类构造函数的次数为___10_____。
7．对类中引用成员的初始化只能通过在构造函数中给出的___初始化表_______来实现。
8. 假定要把aa定义为AB类中的一个引用整数型数据成员，则定义语句为_ int& aa;__。
9．假定用户为类AB定义了一个构造函数"AB(int aa) {a=aa;}"，则系统__不会_______为该类自动定义一个无参构造函数"AB() {}"。
10．假定用户为类AB定义了一个构造函数"AB(int aa=0):a(aa){}"，则定义该类的对象时，可以有____2____种不同的定义格式。
11．假定用户为类AB定义了一个构造函数"AB(int aa=0, int bb=0) {a=aa; b=bb;}"，则定义该类的对象时，可以有___3_____种不同的定义格式。
12．假定用户只为类AB定义了一个构造函数"AB():a(0),b(0){}"，则定义该类对象x的定义语句"AB x(5);"是___错误______(正确/错误)的。
13. 静态成员函数 只能____访问类的静态数据成员， _不能___ 访问类的非静态数据成员。
14. 重载运算符时，该运算符的__优先级______、结合性以及操作符的个数不允许改变。
15. 作为类的成员函数重载一个运算符时，参数表中只有一个参数，说明该运算符有____2____个操作数。
16. 重载抽取运算符>>时，其运算符函数的返回值类型应当是___ istream &_________。
17. 类型转换函数没有____返回值________类型，而且参数表为__空__________。
18. 当保护继承时，基类的_公有和保护__成员在派生类中成为保护成员，派生类对象不能直接访问基类的 任何 ____成员。
19. 引进虚基类的根本目的是为了消除____二义性________。
三、程序填空：
1. 已知一个利用数组实现栈的类定义如下：
const int ARRAY_SIZE=10;
class Stack {
public:
void Init() {top=-1;} //初始化栈为空
void Push(int newElem); //向栈中压入一个元素
int Pop(); //从栈顶弹出一个元素
bool Empty() { //判栈空
if(top==-1) return true;else return false;}
int Depth() {return top+1;} //返回栈的深度
void Print();
//按照后进先出原则依次输出栈中每个元素，直到栈空为止
private:
int elem[ARRAY_SIZE]; //用于保存堆栈元素的数组
int top; //指明栈顶元素位置的指针
};
该类的Pop和Print函数的实现分别如下：
___(1)___ {
if(top==-1) {
cout<<"栈空!"<
}
return ___(2)___;
}
void Stack::Print() {
while(!Empty())
cout<<___(3)___ <<' ';
}
(1) int Stack::Pop() (2) elem[top--] (3) Pop()
2. #include
#include
class A {
int *a; int n; int MaxLen;
public:
A(): a(0), n(0), MaxLen(0) {}
A(int *aa, int nn, int MM) {
n=nn;
MaxLen=MM;
if(n>MaxLen) exit(1);
___(1)___; //由a指向长度为MaxLen的动态数组
for(int i=0; i
~A() {delete []a;}
int GetValue(int i) ___(2)___ //函数体返回a[i]的值
};
void main()
{
int b[10]={1,2,3,4,5,6,7,8,9,10};
A r(b,10,10);
int i,s=0;
for(i=0; i<10; i++) ___(3)___ ; //把r对象的a数据成员中的每个
//元素值依次累加到s中
cout<<"s="<
(1) a=new int[MaxLen] (2) {return a[i];} (3) s+=r.GetValue(i)
3. 在下面一段类定义中， Derived类公有继承了基类Base。需要填充的函数由注释内容给出了功能。
class Base
{
private:
int mem1,mem2; //基类的数据成员
public:
Base(int m1,int m2) {
mem1=m1; mem2=m2;
}
void output(){cout<
};
class Derived: public Base
{
private:
int mem3; //派生类本身的数据成员
public:
//构造函数,由m1和m2分别初始化mem1和mem2，由m3初始化mem3
Derived(int m1,int m2, int m3);
//输出mem1,mem2和mem3数据成员的值
void output(){
___(1)___; cout<
//...
};
Derived::Derived(int m1,int m2, int m3): ___(2)___ {___(3)___;}
(1) Base::output() (2) Base(m1,m2) (3) mem3=m3
四、写出程序运行结果：
1. #include
class Franction { //定义分数类
int nume; //定义分子
int deno; //定义分母
public:
//把*this化简为最简分数，具体定义在另外文件中实现
void FranSimp();
//返回两个分数*this和x之和，具体定义在另外文件中实现
Franction FranAdd(const Franction& x);
//置分数的分子和分母分别0和1
void InitFranction() {nume=0; deno=1;}
//置分数的分子和分母分别n和d
void InitFranction(int n, int d) {nume=n; deno=d;}
//输出一个分数
void FranOutput() {cout<
void main()
{
Franction a,b,c,d;
a.InitFranction(6,15);
b.InitFranction(3,10);
c.InitFranction();
c=a.FranAdd(b);
d=c.FranAdd(a);
cout<<"a: "; a.FranOutput();
cout<<"b: "; b.FranOutput();
cout<<"c: "; c.FranOutput();
cout<<"d: "; d.FranOutput();
}
程序运行结果为：
a: 6/15
b: 3/10
c: 7/10
d: 11/10
2. #include
class A {
int a,b;
public:
A() {a=b=0;}
A(int aa, int bb) {a=aa; b=bb;}
int Sum() {return a+b;}
int* Mult() {
int *p=new int(a*b);
return p;
}
};
void main() {
int *k;
A x(2,3), *p;
p=new A(4,5);
cout<
}
程序运行结果为：
5 6
9 20
3. （此题作业本上缺漏）
#include
class Date
{
public:
Date(int y=2000,int m=1,int d=1){Year=y;Month=m;Day=d;}
void PrintDate(){cout<
int Year,Month,Day;
};
class Time
{
public:
Time(int h=0,int m=0,int s=0){Hour=h;Minutes=m;Seconds=s;}
void PrintTime(){cout<
int Hour,Minutes,Seconds;
};
class Date_Time : public Date, public Time
{
public:
Date_Time(){};
Date_Time(int y,int mo,int d,int h=0,int mi=0,int s=0):Date(y,mo,d),Time(h,mi,s){};
void PrintDate_Time(){PrintDate();PrintTime();}
};
void main()
{
Date_Time a,b(2002,10,1,23,59,59),c(2002,12,31);
a.PrintDate_Time();
b.PrintDate_Time();
c.PrintDate_Time();
}
程序运行结果为：
2000/1/1
0:0:0
2002/10/1
23:59:59
2002/12/31
0:0:0
4. （此题作业本上缺漏）
/**************** test.h **************************/
#include
class Point
{
public:
void InitP(float x0=0,float y0=0){X=x0,Y=y0;}
void Move(float xf,float yf){X+=xf;Y+=yf;}
float GetX(){return X;}
float GetY(){return Y;}
private:float X,Y;
};
class Rectangle:public Point
{
public:
void InitR(float x,float y,float w,float h){
InitP(x,y);W=w;H=h;
}
void ZoomR(float k){W*=k,H*=k;}
float GetH(){return H;}
float GetW(){return W;}
private:
float W,H;
};
//*********************************** test.cpp *******************
#include"test.h"
void main()
{
Rectangle rect;
rect.InitR(10,20,30,40);
cout<
cout<
cout<
程序运行结果为：
10,20,30,40
15,26,30,40
15,26,210,280
五、指出程序或函数的功能
1. int Count(IntNode *f)
{
if(!f) return 0;
int c=0;
while(f) {
c++;
f=f->next;
}
return c;
}
假定IntNode的类型定义为：
struct IntNode {
int data; //结点值域
IntNode* next; //结点指针域
};
函数的功能为：统计出以f为表头指针的链表中结点的个数。
2. int f(const char *s)
{
int i=0;
while(*s++)i++;
return i;
};
函数的功能为：求出并返回字符指针参数s所指向的字符串长度。
六、程序改错，请根据程序段或函数模块的功能改写个别地方的错误。
1. 下面是分数类fract的定义及测试主程序，在类定义及其友元函数定义中有两处错误，更正错误后程序应显示41/28，请指出错误所在行的行号并给出改正意见。
class fract{
int den; //分子
int num; //分母
public:
fract(int d=0,int n=1):den(d),num(n){} //1行
friend fract &operator+=(fract,fract&); //2行
void show(){ cout<
friend fract &operator+=(fract f1,fract f2) //5行
{ //7行
f1.den=f1.den*f2.num+f1.num*f2.den; //8行
f1.num*=f2.num; //9行
return f1; //10行
}
void main(){
fract fr(3,4);
fr+=fract(5,7);
fr.show();
}
错误行的行号为__2____和____5____。
分别改正为___ friend fract &operator+=(fract&,fract);__________
和___ fract &operator+=(fract &f1,fract f2);___。
七、编程：
1. 根据下面类中构造函数的原型和注释写出它的类外定义。
class Strings {
char *s; //指向动态分配的字符串数组空间
int n; //记录字符串长度
public:
Strings(char*str); //构造函数，利用str字符串长度初始化n，
//利用str字符串初始化s所指的字符串空间
Strings(Strings& str); //拷贝构造函数
Strings& Give(Strings& str); //实现str赋值给*this的功能
Strings Uion(Strings& str); //实现*this和str中的字符串合并的
//功能，把合并结果存入临时对象并返回
int Lenth() {return n;} //返回字符串长度
void Print() {cout<
类外定义如下：
Strings::Strings(Strings& str) //拷贝构造函数
{
n=str.n;
s=new char[n+1];
strcpy(s,str.s);
}
2. 下列程序段中，A_class的成员函数Variance()可求出两数的平方差，请改写该程序段，把Variance()函数从A_class类中分离出来，用友元函数来实现该函数的功能。
class A_class {
private:
int x,y,t;
public:
A_class(int i,int j):x(i),y(j) {
if(y>x){t=x;x=y;y=t;}
}
int Variance(){return x*x-y*y;}
//其它函数从略
};
void main() {
A_class A_obj(3,5);
cout<<"Result:"<}
改写后的程序如下：
class A_class {
private:
int x,y,t;
public:
A_class(int i,int j):x(i),y(j){
if(y>x){t=x;x=y;y=t;};
}
//其它函数从略
friend int Variance (A_class& ac); //参数名任意
};
int Variance (A_class& ac)
{
return ac.x*ac.x-ac.y*ac.y;
}
void main() {
A_class A_obj(3,5);
cout<<"Result:"<
3. （此题作业本上缺漏）
已知类定义如下，其中Shape为基类，Circle和Rectangle分别Shape的直接派生类，Square为Rectangle的直接派生类和Shape的间接派生类。请模仿Rectangle类，写出Circle类的所有成员函数。
/******************文件shape.h*************************/
const float PI=3.14159f; //定义圆周率常量
class Shape //几何图形抽象类
{
public:
virtual float GetPerimeter()=0; //纯虚函数，计算周长
virtual float GetAre()=0; //纯虚函数，计算面积
};
class Rectangle: public Shape //矩形类
{
public:
Rectangle (float len,float wid):length(len),width(wid){}
~Rectangle (){}
float GetPerimeter() {return 2*(length+width);} //计算矩形周长
float GetAre() {return length*width;} //计算矩形面积
private:
float length, width; //矩形的长和宽
};
class Circle: public Shape //圆类
{
public: //在下面编写每个成员函数
private:
float rad; //圆的半径
};
class Square: public Rectangle //正方形类
{
public:
Square(float len): Rectangle(len,len){}
~Square(){}
};
Circle类的所有成员函数如下：
Circle(float rad):rad(rad){}
~Circle(){}
float GetPerimeter() {return 2*PI*rad;} //计算圆形周长
float GetAre() {return PI*rad *rad;} //计算圆形面积
下一篇：暂无