2025年面向对象程序设计形成性考核册作业四.docx

面向对象程序设计形成性考核册作业四
一、填空题：
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 aa0, 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<<"栈空!"<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; i0);
int i,s=0;
for(i=0; i<10; i++) ___(3)___ ; //把r对象的a数据组员中的每个
//元素值依次累加到s中
cout<<"s="<
class Base
{
private:
int mem1,mem2; //基类的数据组员
public:
Base(int m1,int m2) {
mem1=m1; mem2=m2;
}
void output(){cout<始化mem1和mem2，由m3初始化mem3
Derived(int m1,int m2, int m3);
//输出mem1,mem2和mem3数据组员的值
void output(){
___(1)___; cout< 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< 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<Sum()<<' '<<*(k=p->Mult())<
class Date
{
public:
Date(int y=,int m=1,int d=1){Year=y;Month=m;Day=d;}
void PrintDate(){cout<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(,10,1,23,59,59),c(,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<GetW()<<','< 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< //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:"< 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:"<hape的直接派生类，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;} //计算圆形面积