应用题 使用VC6打开考生文件夹下的工程test34_3。此工程包含一个test34_3.cpp，其中定义了表示栈的类stack。源程序中stack类的定义并不完整，请按要求完成下列操作，将程序补充完整。
(1)定义类stack的私有数据成员sp和size,它们分别为整型的指针和变量，其中sP指向存放栈的数据元素的数组，size为栈中存放最后一个元素的下标值。请在注释“//**1**”之后添加适当的语句。
(2)完成类stack的构造函数，该函数首先从动态存储空间分配含有100个元素的int型数组，并把该数组的首元素地址赋给指针sp，然后将该数组的所有元素赋值为0，并将size赋值为-1(size等于-1表示栈为空)。请在注释“//**2**”之后添加适当的语句。
(3)完成类stack的成员函数push的定义。该函数将传入的整型参数x压入栈中，即在size小于数组的最大下标情况下， size自加1，再给x赋值。请在注释“//**3**”之后添加适当的语句。
(4)完成类stack的成员函数pop的定义，该函数返回栈顶元素的值，即在size不等于-1的情况下，返回数组中下标为size的元素的值，并将size减1。请在注释“//**4**”之后添加适当的语句。
程序输出结果如下：
the top elem：1
the pop elem：1
the stack is empty
注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。
源程序文件test34_3.cpp清单如下：
#include＜iostream.h＞
class stack
{
//** 1 **
public:
stack ( );
bool empty(){return size==-1;}
bool full() {return size==99;}
void push(int x);
void pop();
void top();
};
stack::stack()
{
//** 2 **
for(int i=0; i＜100; i++)
*(sp+i)=0;
size=-1;
}
void stack::push(int x)
{
//** 3 **
cout＜＜'the stack is full'＜＜end1;
else
{
size++;
*(sp+size) = x;
}
}
void stack::pop()
{
//** 4 **
cout＜＜'the stack is empty'＜＜end1;
else
{
cout＜＜'the pop elem:'＜＜*(sp+size)＜＜end1;
size--;
}
}
void stack::top()
{
if iempty() )
cout＜＜'the stack is empty'＜＜end1;
else
{
cout＜＜'the top elem:'＜＜*(sp+size)＜＜end1;
}
}
void main ( )
{
stack s;
s.push(1);
s.top();
s.pop();
s.top()；
}
应用题
请打开考生文件夹下的解决方案文件proj2，该工程中含有一个源程序文件proj2.cpp。其中定义了类Set和用于测试该类的主函数main。类Set是一个用于描述字符集合的类，在该字符集合中，元素不能重复(将“a”和“A”视为不同元素)，元素最大个数为100。为该类实现一个构造函数Set(char*s)，它用一个字符串来构造一个集合对象，当字符串中出现重复字符时，只放入一个字符。此外，还要为该类实现另一个成员函数InSet(char c)，用于测试—个字符c是否在一个集合中，若在，则返回true；否则返回false。
构造函数Set和成员函数InSet的部分实现代码已在文件proj2.cpp中给出，请在标有注释“//TODO:”的行中添加适当的代码，将这两个函数补充完整，以实现其功能。
提示：在实现构造函数时，可以调用InSet函数来判断一个字符是否已经在集合中。
注意：只在指定位置编写适当代码，不要改动程序中的其他内容，也不要删除或移动“//****found****”。
//prcoj2.cpp
#inelude＜iostream＞
using namespace std;
const int NAXNUM=100;
class Set{
private:
int num; //元素个数
char setdata[NAXNUM]; //字符数组，用于存储集合元素
public:
Set(char*s); //构造函数，用字符串s构造一个集合对象
bool InSet(char c);
//判断一个字符c是否在集合中，若在，返回true，否则返回false
void Print()const; //输出集合中所有元素
};
Set::Set(char*s)
{
mum=0;
while(*s){
//**********found**********
if(______)//TODO：添加代码，测试元素在集合中不存在
//**********found**********
______;//TODO：添加一条语句，加入元素至集合中
s++;
}
}
bool Set::InSet(char c)
{
for(int i=0; i＜num; i++)
//**********found**********
if(______)//TODO：添加代码，测试元素c是否与集合中某元素相同
//**********found**********
______;//TODO：添加一条语句，进行相应处理
return false;
}
void Set::Print()const
{
cout＜＜'Set elements:'＜＜endl;
for(int i=0; i＜num; i++)
cout＜＜setdata[i] ＜＜';
cout＜＜endl;
}
int main()
{
char s[MAXNUM];
cin.getline(s, MAXNUM-1); //从标准输入中读入一行
Set setobj(s); //构造对象setobj
setobj.Print();//显示对象setobj中内容
return 0;
}
应用题 请使用VC6或使用【答题】菜单打开proj2下的工程proj2，其中在编辑窗口内显示的主程序文件中定义有类Base和Derived，以及主函数main。程序文本中位于每行“// ****found****”下面的一行内有一处或多处下画线标记，请在每个下画线标记处填写合适的内容，并删除下画线标记。经修改后运行程序，得到的输出应为：
sum=55。
注意：只在横线处填写适当的代码，不要改动程序中的其他内容。
#include ＜iostream＞
using namespace std;
class Base
{
public:
Base(int m1,int m2) {
mem1 = m1; mem2 = m2;
}
int sum() {return mem1 + mem2;}
private:
int mem1, mem2; //基类的数据成员
};
//派生类Derived从基类Base公有继承
// *******found*******
class Derived:______
{
public:
Derived (int m1, int m2, int m3);
//sum函数定义，要求返回mem1、mem2和mem3之和
// *******found*******
int sum() {return______ + mem3;}
private:
int mem3; //派生类本身的数据成员
};
//构造函数的类外定义,要求由m1和m2分别初始化mem1和mem2,由m3初始化mem3
// *******found*******
______Derived (int m1, int m2, int m3):
, mem3 (m3) {}
// *******found*******
int main() {
Base a(4,6);
Derived b (10,15,20);
int sum=a.sum()+b.sum();
cout ＜＜ 'sum =' ＜＜ sum ＜＜ endl;
return 0;
}
应用题 请使用VC6或使用【答题】菜单打开proj3下的工程proj3，其中声明了MiniComplex是一个用于表示复数的类。请编写这个operator+运算符函数，以实现复数的求和运算。两个复数的和是指这样一个复数：其实部等于两个复数的实部之和，其虚部等于两个复数的虚部之和。例如，(23+34i)+(56+35i)等于(79+69i)。
要求：
补充编制的内容写在“// *******333*******”与“// *******666*******”之间，不得修改程序的其他部分。
注意：程序最后将结果输出到文件out.dat中。输出函数writeToFile已经编译为obj文件，并且在本程序中调用。
//Minicomplex.h
#include ＜iostream＞
using namespace std;
class MiniComplex //复数类
{
public:
friend ostream operator ＜＜ (ostream osObject, const MiniComplex complex)
{
osObject ＜＜ '(' ＜＜ complex.realPart ＜＜ '+' ＜＜ complex.imagPart ＜＜ 'i' ＜＜ ')';
return osObject;
}
friend istream operator ＞＞ (istream isObject, MiniComplex complex)
{
char ch;
isObject ＞＞ complex, realPart ＞＞ ch ＞＞ complex.imagPart ＞＞ ch;
return isObject;
}
MiniComplex (double real = 0, double imag = 0);
//构造函数
MiniComplex operator + (const MiniComplex otherComplex) const;
//重载运算符+
private:
double realPart; //存储实部变量
double imagPart; //存储虚部变量
};
void writeToFile(char *);
//main.cpp
#include 'MiniComplex.h'
MiniComplex::MiniComplex (double real, double imag){realPart=real;imagPart=imag;}
MiniComplex MiniComplex::operator+(const MiniComplex otherComplex) const
{
// ********333********
// ********666********
}
int main()
{
void writeToFile(char * );
MiniComplex num1 (23,34),num2 (56,35);
cout ＜＜ 'Initial Value of Num1 =' ＜＜ num1 ＜＜ '\nInitial Value of Num2 =' ＜＜ num2 ＜＜ endl;
cout ＜＜ num1 ＜＜ '+' ＜＜ num2 ＜＜ '=' ＜＜ num1 + num2 ＜＜ endl; //使用重载的加号运算符
writeToFile (' ');
return 0;
}
应用题
使用VC++2010打开考生文件夹下“proj3”文件夹中的工程proj3.sln。阅读下列函数说明和代码，补充空出的代码。函数convert (cha* des,char* str)实现的功能是：
(1)如果字符串最后面有空格，则全部删除；
(2)转换后的数据放到des，并且指针作为返回值返回。
注意：不能修改程序的其他部分，只能补充convert()函数。
#include ＜iostream.h＞
#include ＜ctype.h＞
#define MAXLEN 1024
char* convert(char* des,char*str)
{
}
void main()
{
char dest[MAXLEN];
char *string=' abc def ';
cout ＜＜ string ＜＜'＜--' ＜＜ endl;
cout＜＜convert(dest,string) ＜＜'＜--'＜＜endl;
return;
}
应用题
请打开考生文件夹下的解决方案文件proj2，该工程中含有一个源程序文件proj2.cpp。其中定义了类Set和用于测试该类的主函数main。类Set是一个用于描述字符集合的类，在该字符集合中，元素不能重复(将“a”和“A”视为不同元素)，元素最大个数为100。为该类实现一个构造函数Set(char*s)，它用一个字符串来构造一个集合对象，当字符串中出现重复字符时，只放入一个字符。此外，还要为该类实现另一个成员函数InSet(char c)，用于测试—个字符c是否在一个集合中，若在，则返回true；否则返回false。
构造函数Set和成员函数InSet的部分实现代码已在文件proj2.cpp中给出，请在标有注释“//TODO:”的行中添加适当的代码，将这两个函数补充完整，以实现其功能。
提示：在实现构造函数时，可以调用InSet函数来判断一个字符是否已经在集合中。
注意：只在指定位置编写适当代码，不要改动程序中的其他内容，也不要删除或移动“//****found****”。
//prcoj2.cpp
#inelude＜iostream＞
using namespace std;
const int NAXNUM=100;
class Set{
private:
int num; //元素个数
char setdata[NAXNUM]; //字符数组，用于存储集合元素
public:
Set(char*s); //构造函数，用字符串s构造一个集合对象
bool InSet(char c);
//判断一个字符c是否在集合中，若在，返回true，否则返回false
void Print()const; //输出集合中所有元素
};
Set::Set(char*s)
{
mum=0;
while(*s){
//**********found**********
if(______)//TODO：添加代码，测试元素在集合中不存在
//**********found**********
______;//TODO：添加一条语句，加入元素至集合中
s++;
}
}
bool Set::InSet(char c)
{
for(int i=0; i＜num; i++)
//**********found**********
if(______)//TODO：添加代码，测试元素c是否与集合中某元素相同
//**********found**********
______;//TODO：添加一条语句，进行相应处理
return false;
}
void Set::Print()const
{
cout＜＜'Set elements:'＜＜endl;
for(int i=0; i＜num; i++)
cout＜＜setdata[i] ＜＜';
cout＜＜endl;
}
int main()
{
char s[MAXNUM];
cin.getline(s, MAXNUM-1); //从标准输入中读入一行
Set setobj(s); //构造对象setobj
setobj.Print();//显示对象setobj中内容
return 0;
}
应用题 请使用VC6或使用【答题】菜单打开proj3下的工程proj3，其中声明了一个单向链表类sList。sList的成员函数Prepend的功能是在链表头部加入一个新的元素。请编写成员函数Prepend。在main函数中给出了一组测试数据，此时程序的输出应为：
B-＞A-＞
###
A-＞
###
A-＞
###
exiting inner block
exiting outer block
注意：只在函数Prepend的“// *******333*******”和“// *******666*******”之间填入若干语句，不要改动程序中的其他内容。
//SList.h
struct sListItem {
char data;
sListItem * next;
};
class sList {
public:
sList(): h(0) {}
//0表示空链表
～sList();
void Prepend (char c);
//在链表前端加入元素
void Del();
//删除链表首元素
sListItem * First() const {return h;}
//返回链表首元素
void Print() const;
//打印链表内容
void Release();
//销毁链表
private:
sListItem * h;
//链表头
};
void writeToFile (const char *);
//main.cpp
#include ＜iostream＞
#include 'sList.h'
using namespace std;
sList:: ～sList()
{
Release();
}
void sList::Prepend (char c)
{
// *******333*******
// *******666*******
}
void sList::Del()
{
sListItem * temp = h;
h = h -＞ next;
delete temp;
}
void sList::Print() const
{
sListItem * temp = h;
while (temp != 0) //判断是否到达链表尾部
{
cout ＜＜ temp -＞ data ＜＜ '-＞';
temp = temp -＞ next;
}
cout ＜＜ '\n###' ＜＜ endl;
}
void sList::Release()
{
while (h != 0)
Del();
}
int main()
{
sList * ptr;
{
sList obj;
obj.Prepend('A');
obj.Prepend('B');
obj.Print();
obj.Del();
obj.Print();
ptr = obj;
ptr -＞ Print();
cout ＜＜ 'exiting inner block' ＜＜ endl;
}
cout ＜＜ 'exiting outer block' ＜＜ endl;
writeToFile(' ');
return 0;
}
应用题 使用VC++6.0打开下的源程序文件3.cpp。其中定义的类不完整，按要求完成下列操作，将类的定义补充完整。每卖出一个水果，则计算水果的重量，还要计算所有卖出水果的总重量以及总个数，同时允许退货，请按照以下的操作，把类补充完整。
(1)定义类TCFruit的私有静态数据成员float型变量AllWeight和int型变量AllNo，请在注释1后添加适当的语句。
(2)完成类TCFruit的带一个float型变量w的构造函数，并把这个w加到AllWeight中，并且AllNo自加。请在注释2后添加适当的语句。
(3)在析构函数中，在AllWeight中减去weight，然后AllNo自减，请在注释3后添加适当的语句。
(4)完成静态成员变量的初始化为0，请在注释4后添加适当的语句。
注意：增加或者修改代码的位置已经用符号表示出来，请不要修改其他的程序代码。
试题程序：
#include＜iostream.h＞
class TCFruit
{
private:
float Weight;
//********1********
static int AllNO;
public:
TCFruit(float w)
{
//********2********
AllWeight+=w;
AllNo++;
}
～TCFruit()
{
//********3********
AllWeight-=Weight;
}
void display()
{
cout＜＜'Sell a Fruit with'＜＜Weight＜＜'kg'＜＜endl;
cout＜＜'All sell number:'＜＜AllNo＜＜endl;
cout＜＜'All sell weight:'＜＜AllWeight＜＜'kg'＜＜endl＜＜endl;
}
};
//********4********
float TCFruit::AllWeight=0.0;
int main()
{
TCFruit Fruit1(1.2);
Fruit1.display();
TCFruit Fruit2(2.3);
Fruit2.display();
return 0;
}
应用题 使用VC++6.0打开下的源程序文件2.cpp。完成fun函数，使其功能为将两个按小到大排序的数组a和b，复制合并成一个有序整数序列c，其中形参n和m分别是数组a和b的元素个数。
注意：不能修改程序的其他部分，只能修改fun函数。
试题程序：
#include＜iostream.h＞
void fun(int a[], int n, int b[], int m, int*c)
{
}
void main()
{
int A[]={3, 5, 7, 9, 11, 18, 21};
int B[]={6, 15, 19, 21, 39);
int C[25], i;
for(i=0; i＜25; i++)C[i]=0;
cout＜＜'A[]=';
for(i=0; i＜7; i++)
cout＜＜A[i]＜＜',';
cout＜＜endl;
cout＜＜'B[]=';
for(i=0; i＜5; i++)
cout＜＜B[i]＜＜',';
cout＜＜endl;
fun(A, 7, B, 5, C);
cout＜＜'C[]=';
for(i=0; i＜12; i++)
cout＜＜C[i]＜＜',';
cout＜＜endl;
return;
}
应用题
请打开考生文件夹下的解决方案文件proj2，此工程中含有一个源程序文件proj2.cpp。函数char *GetNum(char *src，char *buf)从src开始扫描下一个数字字符序列，并将其作为一个字符串取出放入字符串空间bur中。函数返回扫描的终止位置，如果返回NULL表示没有扫描到数字字符序列。
运行程序时，如果输入的一行字符序列是
ABC012XYZ378MN274WS
则输出为：
Digit string 1 is 012
Digit string 2 is 378
Digit string 3 is 274
注意：只在横线处编写适当代码，不要删除或移动“//****found****”。
//proj2.cpp
#include＜iostream＞
using namespace std;
char *GetNum(char *src,char *buf)
{
while($src!='\0')
{
if(isdigit(*src))break;
src++;
}
if(*src=='\0')
//********found********
______;
while(*src!='\0' isdigit(*src))
{
//********found********
______;
buf++;
src++;
}
*buf='\0';
return src;
}
int main()
{
char str[100],digits[20];
cin.getline(str,100);
char *p=str;
int i=1;
while((p=GetNum(p,digits))!=NULL)
{
cout＜＜'Digit string'＜＜i＜＜'is'＜＜digits＜＜endl;
//********found********
______;
}
return 0;
}
应用题 请使用VC6或使用[答题]菜单打开考生文件夹proj2下的工程proj2，其中包含抽象类Shape的声明，以及在此基础上派生出的类Rectangle和Circle的声明，二者都有计算对象面积的函数GetArea()和计算对象周长的函数GetPerim()。程序中位于每个“//****found****”之后的一行语句有错误，请加以改正。改正后程序的输出结果应该是：
The area of the Circle is 78.5
The perimeter of the Circle is 31.4
The area of the Rectangle is 24
The perimeter of the Rectangle is 20
注意：只在横线处填写适当的代码，不要改动程序中的其他内容，也不要删除或移动“//****found****”。
#include ＜iostream＞
using namespace std;
class Shape
{
public:
Shape() {}
～Shape() {}
//********** found**********
______float GetArea () =0;
//********** found**********
______float GetPerim () =0;
};
class Circle : public Shape
{
public:
Circle (float radius): itsRadius (radius) {}
～Circle() {}
float GetArea () { return 3.14 * itsRadius * itsRadius; }
float GetPerim ()
{return 6.28 * itsRadius;}
private:
float itsRadius;
};
class Rectangle : public Shape
{
public:
//********** found**********
Rectangle(float len, float width):
______{};
～Rectangle(){};
virtual float GetArea()
{ return itsLength * itsWidth; }
float GetPerim ()
{ return 2 * itsLength + 2 * itsWidth;}
virtual float GetLength() { return itsLength; }
virtual float GetWidth () { return itsWidth; }
private:
float itsWidth;
float itsLength;
};
int main()
{
//********** found**********
______
sp = new Circle(5);
cout ＜＜ 'The area of the Circle is' ＜＜ sp-＞GetArea () ＜＜ endl;
cout ＜＜ 'The perimeter of the Circle is' ＜＜ sp-＞GetPerim () ＜＜ endl;
delete sp;
sp = new Rectangle(4, 6);
cout ＜＜ 'The area of the Rectangleis' ＜＜ sp-＞GetArea() ＜＜ endl;
cout ＜＜ 'The perimeter of the Rectangle is' ＜＜ sp -＞ GetPerim () ＜＜endl;
delete sp;
return 0;
}
应用题 请使用VC6或使用【答题】菜单打开proj2下的工程proj2，此工程中声明的Array是一个表示数组的类。一个Array对象可以包含多个整型元素。Array的成员说明如下：
成员函数add用于向数组的末尾添加一个元素；
成员函数get用于获取数组中指定位置的元素；
数据成员a表示实际用于存储数据的整型数组；
数据成员size表示数组的容量，数组中的元素个数最多不能超过size；
数据成员num表示当前数组中的元素个数。
SortedArray是Array的派生类，表示有序数组。SortedArray重新定义了Array中的add函数，以确保有序数组中的元素始终按照升序排列。请在程序中的横线处填写适当的代码，然后删除横线，以实现上述类定义。此程序的正确输出结果应为：
10，9，8，7，6，5，4，3，2，1，
1，2，3，4，5，6，7，8，9，10，
注意：只在横线处填写适当的代码，不要改动程序中的其他内容，也不要删除或移动“// ****found****”。
#include ＜iostream＞
using namespace std;
class Array {
public:
Array(unsigned int s)
{
size = s;
num= 0;
a = new int[s];
}
virtual ～Array() {delete[] a;}
virtual void add(int e)
{
if (num＜ size) {
// **********found**********
______
num ++;
}
}
int get(unsigned int i) const
{
if (i ＜ size)
return a[i];
return 0;
}
protected:
int * a;
unsigned int size, num;
};
class SortedArray : public Array {
public:
// **********found**********
SortedArray(unsigned int s)
:______{}
virtual void add(int e)
{
if (num ＞= size)
return;
int i =0, j;
while (i ＜num) {
if (e ＜ a[i]) {
for (j =num; j ＞ i; j--) {
// **********found**********
______;
}
// **********found**********
______;
break;
}
i++;
}
if (i == num)
a[i] = e;
num ++;
}
};
void fun(Array a)
{
int i;
for (i = 10; i ＞= 1; i--) {
a.add (i);
}
for (i = 0; i ＜ 10; i++) {
cout ＜＜ a.get(i) ＜＜ ', ';
}
cout ＜＜ endl;
}
int main()
{
Array a(10);
fun(a);
SortedArray sa(10);
fun(sa);
return 0;
}
应用题 使用VC++6.0打开下的源程序文件3.cpp，其中定义了类BA、PA1和PA2，其中PA1类由BA类公有派生，PA2类由PA1类公有派生。上述3个类的定义并不完整，请按要求完成下列操作，将程序补充完整。
程序输出结果如下：
10
5
10 5 7
(1)定义类BA的构造函数，该构造函数有一个整型的参数m，在构造函数中将m赋值给数据成员a。请在注释1之后添加适当的语句。
(2)定义类PA1的构造函数，该构造函数有两个整型的参数m和n，在构造函数中将m赋值给数据成员b，将n作为基类BA构造函数的参数值传入。请在注释2之后添加适当的语句。
(3)定义类PA2的构造函数，该构造函数有3个整型的参数m、n和k，在构造函数中请将m赋值给数据成员c，将n和k分别赋值给基类PA1构造函数的参数m和n。请在注释3之后添加适当的语句。
(4)完成类PA2的成员函数show的定义，该函数调用基类成员函数，输出基类私有成员a、b及类PA2自身的数据成员C的值，上述3个值在输出时用空格隔开。请在注释4之后添加适当的语句。
注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。
试题程序：
#include＜iostream.h＞
class BA
{
int a;
public:
//********1********
int geta()(return a;}
};
class PA1:public BA
{
int b;
public:
//********2********
int getb(){return b;)
};
class PA2:public PA1
{
int c;
public:
//********3********
void show()
{
//********4********
}
};
void main()
{
PA2 a(7,5,10);
cout＜＜a.geta()＜＜endl;
cout＜＜a.getb()＜＜endl;
a.show();
}
应用题 请使用【答题】菜单命令或直接用VC6打开考生文件夹下的工程proj3，其中声明的是一个人员信息类，补充编制程序，使其功能完整。在main函数中给出了一组测试数据，此种情况下程序的输出应该是：Zhang 20 Tsinghua。
注意：只能在函数address_change的“// ********333********”和“// ********666********”之间填入若干语句，不要改动程序中的其他内容。
程序最后将结果输出到文件out.dat中。输出函数writeToFile已经编译为obj文件，并且在本程序中调用。
//proj3.h
#include ＜iostream＞
#include ＜string＞
using namespace std;
class Person{
char name[20];
int age;
char * address;
public:
Person(){ age = 0;address = 0;}
void name_change (char *_name);
//名字修改函数
void age_change(int_age);
//年龄修改函数
void address_change (char *_add);
//地址修改函数
void info_display();
//人员信息显示
～Person();
//析构函数
};
void writeToFile(const char * path);
proj3.cpp
#include ＜iostream＞
#include ＜string＞
#include 'proj3.h'
using namespace std;
void Person::name_change(char*_name)
{
strcpy(name, _name);
}
void Person::age_change(int _age)
{
age = _age;
}
void Person::address _change (char * add)
{
if (address!=NULL) delete[]address;
// ********333********
// ********666********
}
void Person::info_display(){
cout ＜＜ name ＜＜ '\t'
＜＜ age ＜＜ '\t';
if(address!=NULL)
cout ＜＜ address ＜＜ endl;
cout ＜＜ endl;
}
Person::～Person(){
if(address!=NULL)
delete[] address;
}
void main()
{
Person p1;
p1.name_change('Zhang');
p1.age_change(20);
p1.address_change('Tsinghua University');
p1.address_change('Tsinghua');
p1.info_display();
writeToFile(' ');
}
应用题 请使用VC6或使用【答题】菜单打开proj3下的工程文件proj3，该文件中定义了用于表示日期的类Date、表示人员的类Person和表示职员的类Staff；程序应当显示：
张小丽123456789012345
但程序中有缺失部分，请按以下提示把缺失部分补充完整：
(1)在“// **1** ****found****”的下方是析构函数定义中的语句，它释放两个指针成员所指向的动态空间。
(2)在“//**2** ****found****”的下方是rename函数中的一个语句，它使指针name指向申请到的足够容纳字符串new_name的空间。
(3)在“// **3** ****found****”的下方是构造函数定义的一个组成部分，其作用是利用参数表中前几个参数对基类Person进行初始化。
注意：只在指定位置编写适当代码，不要改动程序中的其他内容，也不要删除或移动“****found****”。填写的内容必须在一行中完成，否则评分将产生错误。
//proj3.cpp
#include ＜iostream＞
using namespace std;
class Person
{
char * idcardno; //用动态空间存储的身份证号
char * name; //用动态空间存储的姓名
bool ismale; //性别：true为男，false为女
public:
Person(const char * pid, const char * pname, bool pmale);
～Person() {
// **1** *******found*******
______;
}
const char * getIDCardNO() const{return idcardno;}
const char * getName() const{return name;}
void rename(const char * new_name);
bool isMale() const{return is-male;}
};
class Staff: public Person
{
char * department;
double salary;
public:
Staff(const char * id_card_no, const char * p_name, bool is_male, const char * dept, double sal);
～Staff() {delete [] department;}
const char * getDepartment() const{return department;}
void setDepartment(const char * d);
double getSalary() const{return salary;}
void setSalary(double s) {salary = s;}
};
Person::Person (const char * id_card_no, const char * p_name, bool is_male):ismale(is_male)
{
idcardno = new char [strlen(id_card_no)+1];
strcpy (idcardno, id_card_no);
name = new char [strlen (p_name)+1];
strcpy(name,p_name);
}
void Person::rename (const char * new_name)
{
delete []name;
// **2** *******found*******
______;
strcpy(name,new_name);
}
Staff::Staff(const char * id_card_no, const char * p_name, bool is male,
// **3** *******found*******
const char * dept, double sal):______
{
department = new char [strlen(dept) +1];
strcpy(department,dept);
salary =sal;
}
void Staff::setDepartment(const char * dept)
{
delete []department;
department = new char [strlen(dept) +1];
strcpy(department,dept);
}
int main()
{
Staff Zhangsan('123456789012345','张三', false,'人事部',1234.56);
Zhangsan.rename('张小丽');
cout ＜＜ Zhangsan.getName() ＜＜ Zhangsan.getIDCardNO() ＜＜ endl; return 0;
}
应用题 使用VC++6.0打开下的源程序文件3.cpp，其中定义了类BA、PA1和PA2，其中PA1类由BA类公有派生，PA2类由PA1类公有派生。上述3个类的定义并不完整，请按要求完成下列操作，将程序补充完整。
程序输出结果如下：
10
5
10 5 7
(1)定义类BA的构造函数，该构造函数有一个整型的参数m，在构造函数中将m赋值给数据成员a。请在注释1之后添加适当的语句。
(2)定义类PA1的构造函数，该构造函数有两个整型的参数m和n，在构造函数中将m赋值给数据成员b，将n作为基类BA构造函数的参数值传入。请在注释2之后添加适当的语句。
(3)定义类PA2的构造函数，该构造函数有3个整型的参数m、n和k，在构造函数中请将m赋值给数据成员c，将n和k分别赋值给基类PA1构造函数的参数m和n。请在注释3之后添加适当的语句。
(4)完成类PA2的成员函数show的定义，该函数调用基类成员函数，输出基类私有成员a、b及类PA2自身的数据成员C的值，上述3个值在输出时用空格隔开。请在注释4之后添加适当的语句。
注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。
试题程序：
#include＜iostream.h＞
class BA
{
int a;
public:
//********1********
int geta()(return a;}
};
class PA1:public BA
{
int b;
public:
//********2********
int getb(){return b;)
};
class PA2:public PA1
{
int c;
public:
//********3********
void show()
{
//********4********
}
};
void main()
{
PA2 a(7,5,10);
cout＜＜a.geta()＜＜endl;
cout＜＜a.getb()＜＜endl;
a.show();
}
应用题 请使用VC6或使用【答题】菜单打开proj3下的工程proj3，其中声明IntSet是一个用于表示正整数集合的类。IntSet的成员函数Intersection的功能是求当前集合与另一个集合的交集。请完成成员函数Intersection。在main函数中给出了一组测试数据，此时程序的输出应该是：
求交集前：
1 2 3 5 8 10
2 8 9 11 30 56 67
求交集后：
1 2 3 5 8 10
2 8 9 11 30 56 67
2 8
要求：
补充编制的内容写在“// *******333*******”与“// *******666*******”之间，不得修改程序的其他部分。
注意：程序最后将结果输出到文件out.dat中。输出函数writeToFile已经编译为obj文件，并且在本程序中调用。
//Intset.h
#include ＜iostream＞
using namespace std;
const int Max=100;
class IntSet
{
public:
IntSet()
//构造一个空集合
{
end = -1;
}
IntSet (int a[], int size) //构造一个包含数组a中size个元素的集合
{
if (size ＞= Max)
end = Max - 1;
else
end = size - 1;
for (int i = 0; i ＜= end; i ++)
element[i] = a[i];
}
bool IsMemberOf (int a)
//判断a是否为集合中的一个元素
{
for (int i = 0; i ＜= end; i ++)
if (element[i] == a)
return true;
return false;
}
int GetEnd() {return end;}
//返回最后一个元素的下标
int GetElement (int i) {return element[i];}
//返回下标为i的元素
IntSet Intersection (IntSet set);
//求当前集合与集合set的交
void Print ()
//输出集合中的所有元素
{
for(int i=0;i＜=end;i++)
if((i+1)% 20==0)
cout ＜＜ element[i] ＜＜ endl;
else
cout ＜＜ element[i] ＜＜ '';
cout ＜＜ endl;
}
private:
int element[Max];
int end;
};
void writeToFile (const char *);
//main.cpp
#include 'IntSet.h'
IntSet IntSet::Intersection(IntSet set)
{
int a[Max],size=0;
// *******333*******
// *******666*******
return IntSet(a,size);
}
int main()
{
int a[] = {1,2,3,5,8,10};
int b[] = {2,8,9,11,30,56,67};
IntSet set1 (a, 6), set2 (b, 7), set3;
cout ＜＜ '求交集前:' ＜＜ endl;
set1.Print();
set2.Print();
set3.Print();
set3 = set1.Intersection (set2);
cout ＜＜ endl ＜＜ '求交集后:' ＜＜ endl;
set1.Print();
set2.Print();
set3.Print();
writeToFile (' ');
return 0;
}
应用题 使用VC++6.0打开下的源程序文件3.cpp。其中定义的类不完整，按要求完成下列操作，将类的定义补充完整。
(1)完成类TC1的成员函数seta的定义，定义seta对象，x为int 类型，请在注释1后添加适当的语句。
(2)完成类TC3多继承类TC1和TC2的定义，请在注释2后添加适当的语句。
(3)定义类TC3中的私有成员c为int型，请在注释3后添加适当的语句。
(4)完成setc中对基类的变量a的赋值，请在注释4后添加适当的语句。
注意：增加或者修改代码的位置已经用符号表示出来，请不要修改其他的程序代码。
试题程序：
#include＜iostream.h＞
class TC1
{
int a;
public:
//********1********
{
return a=x;
}
void showa()
{
cout ＜＜ a ＜＜ endl;
}
};
class TC2
{
int b;
public:
void setb(int x)
{
b=x;
}
void showb()
{
cout ＜＜ b ＜＜ endl;
}
};
//********2********
{
private:
//********3********public:
void setc(int x,int y,int z)
{
c=z;
//********4********
setb(y);
}
void showc()
{
cout ＜＜c ＜＜ endl;
}
};
void main()
{
TC3 c;
c.seta(5);
c.showa();
c.setc(5,7,4);
c.showc();
}
选择题 有如下程序：
#include＜iostream＞
#include＜iomanip＞
using namespace std;
int main(){
cOUt＜＜setw(10)＜＜serfill('x')＜＜setprecision(8)＜＜left;
cout＜＜12.3456793＜＜______＜＜98765;
return 0;
}
若程序的输出是12.345679x98765xxxxx，则划线处缺失的部分是______。
选择题 下列有关C++流的叙述中，错误的是______。