C++期末考试题

Question

1.下面是一个整型数组类intArray的声明，请给出该类所有数据成员的类外定义。要求：
（1）能通过对“>>”、“<<”的重载实现数组元素的直接输入及其输出。输入时，第一次输入的值为数组长度，后面连续输入若干个数作为数组内容。输出时，首先提示该数组元素个数，然后依次输出该数组各元素；
（2）重载“=”、“+”、“-”运算符使之能对两个数组类对象进行直接赋值、加减运算。
（3）写出主函数对该类进行测试。要求：
1）先构造包含10个数组元素的数组对象a，再调用流提取运算符重载函数实现a的元素初始化（元素值分别为1—10），输出a数组；
2）并利用a来构造数组b，输出数组b，并调用get函数获取b中下标为奇数的各元素值并输出，然后调用set函数将上述元素值乘以2，输出b数组；
3）构造一个包含5个元素的数组c，其值全为1，输出该数组，再调用ReSize函数将其大小重置为10，调用“=”重载函数将a的值复制给c，输出数组c；
4）分别将b+c，b-c的值送给数组d和数组e，并输出结果。
class intArray
{public:
intArray(int size);//构造函数
intArray(const intArray &x);//复制构造函数
~intArray();//析构函数
bool Set(int i, int elem);//设置第i个数组元素的值，设置成功返回true，失败返回false
bool Get(int i, int &elem); //获取第i个数组元素的值，获取成功返回true，失败返回false
int Length( ) const;//获取数组的长度
void ReSize ( int size ); //重置数组
intArray &operator=(const intArray&other); //赋值运算符“=”重载函数
intArray &operator+(constintArray &other); //加运算符“=”重载函数
intArray &operator-(constintArray &other) ; //减运算符“=”重载函数
friend ostream &operator>>(ostream &, intArray &); //数组的整体输入
friend ostream & operator<<(ostream&, intArray &); //数组的整体输出
private:
int *element; //指向动态数组的指针
int arraysize; //数组的当前长度
};

Answer 1

// 你们老师给的头文件有点小问题：
// 1. operator+ 和 operator-不能返回intArray引用，局部对象在
//    函数调用结束后会被销毁。
// 2. Get()函数后面加上const，不然拷贝构造函数里的const对象调用不了。
// 3. operaror>>函数的istream错写为ostream.

// 下面的代码已通过VS2008编译，其他编译器应该都可以。
// Update: 2014-04-22 

#include <iostream>
#include <assert.h>

using namespace std;

class intArray
{
public:
intArray(int size);//构造函数
intArray(const intArray &x);//复制构造函数
~intArray();//析构函数
bool Set(int i, int elem);//设置第i个数组元素的值，设置成功返回true，失败返回false
bool Get(int i, int &elem) const; //获取第i个数组元素的值，获取成功返回true，失败返回false
int Length( ) const;//获取数组的长度
void ReSize ( int size ); //重置数组
intArray &operator=(const intArray&other);  //赋值运算符“=”重载函数
intArray operator+(const intArray &other);   //加运算符“=”重载函数
intArray operator-(const intArray &other) ;  //减运算符“=”重载函数
friend istream &operator>>(istream &, intArray &);  //数组的整体输入
friend ostream & operator<<(ostream&, intArray &);  //数组的整体输出
private:
int *element;            //指向动态数组的指针
int arraysize;            //数组的当前长度
};

intArray::intArray(int size)
:arraysize(size)
,element(NULL)
{
assert(this->arraysize >= 0);
if (this->arraysize>0)
element = new int[size];

memset(element, 0, sizeof(int)*arraysize);
}

intArray::intArray(const intArray &x)
{
this->arraysize = x.Length();
if (arraysize > 0)
{
element = new int[arraysize];
for (int i=0; i<arraysize; ++i)
{
int nValue = 0;
x.Get(i, element[i]); 
}
}
}

intArray::~intArray()
{
if (arraysize > 0 && element != NULL)
{
delete[] element;
}
}

//设置第i个数组元素的值，设置成功返回true，失败返回false
bool intArray::Set(int i, int elem)
{
if (i >= this->arraysize)
return false;

if (!this->element)
{
assert(0);
return false;
}

this->element[i] = elem;
return true;
}

//获取第i个数组元素的值，获取成功返回true，失败返回false
bool intArray::Get(int i, int &elem) const
{
if (i >= this->arraysize)
return false;

if (!this->element)
{
assert(0);
return false;
}

elem = this->element[i];
return true;
}

//获取数组的长度
int intArray::Length( ) const
{
return this->arraysize;
}

//重置数组（旧数据丢弃） 
void intArray::ReSize ( int size )
{
if (size == this->arraysize)
return;

if (this->element != NULL)
delete[] element;

this->arraysize = size;
element = new int[size];
assert(element);
memset(element, 0, sizeof(int)*size);
}

//赋值运算符“=”重载函数
intArray& intArray::operator=(const intArray& other)
{
if (arraysize <= 0 || other.Length()<=0 || element==NULL)
return *this;

int nOpCount = min(other.Length(), this->arraysize);
for (int i=0; i<nOpCount; ++i)
{
other.Get(i, element[i]);
}

return *this;
}

//加运算符“+”重载函数
// 如果两个数组大小不一样，直接返回 
intArray& intArray::operator+(const intArray &other)
{
if (arraysize <= 0 || other.Length()<=0 || element==NULL || arraysize!=other.Length())
{
assert(0);
return *this;
}

int nOpCount = this->Length();
intArray temp(nOpCount);
for (int i=0; i<nOpCount; ++i)
{
int nOtherElement = 0;
other.Get(i, nOtherElement);
temp.Set(i. this->element[i] + nOtherElement);
}
return temp;
}

//减运算符“-”重载函数
// 创建一个和this对象相同尺寸的数组 
intArray& intArray::operator-(const intArray &other)
{
if (arraysize <= 0 || other.Length()<=0 || element==NULL || arraysize!=other.Length())
{
assert(0);
return *this;
}

int nOpCount = this->Length();
intArray temp(nOpCount);
for (int i=0; i<nOpCount; ++i)
{
int nOtherElement = 0;
other.Get(i, nOtherElement);
temp.Set(i. this->element[i] - nOtherElement);
}
return temp;
}

//数组的整体输入
istream &operator>>(istream &is, intArray &arr)
{
int nLength = 0;
is >> nLength;
if (nLength != arr.Length())
{
arr.ReSize(nLength);
}

int nValue = 0;
for (int i=0; i<nLength; ++i)
{
is >> nValue;
arr.Set(i, nValue);
}

    return is;
} 

//数组的整体输出
ostream & operator<<(ostream& os, intArray &arr)
{
os << "该数组元素个数为：" << arr.Length() << endl;
int nValue = 0;
for (int i=0; i<arr.Length(); ++i)
{
arr.Get(i, nValue);
os << nValue << " ";
}
os << endl;

    return os;
}


int main()
{
//（1）先构造包含10个数组元素的数组对象a，再调用流提取运算符重载函数实现a的元素初始化
//（元素值分别为1—10），输出a数组；
intArray a(10);
cin >> a;
cout << a;

// 2）并利用a来构造数组b，输出数组b，并调用get函数获取b中下标为奇数的各元素值并输出，
// 然后调用set函数将上述元素值乘以2，输出b数组；
intArray b(a);
cout << b;
for (int i=0; i<b.Length(); ++i)
{
if (i%2 != 0)//积数
{
int nElement = 0;
b.Get(i, nElement);
b.Set(i, nElement*2);
cout << nElement << " ";
}
}
cout << endl;
cout << b;

// 3）构造一个包含5个元素的数组c，其值全为1，输出该数组，再调用ReSize函数将其大小重置
//  为10，调用“=”重载函数将a的值复制给c，输出数组c；
intArray c(5);
for (int i=0; i<c.Length(); ++i)
c.Set(i, 1);
cout << c;
c.ReSize(10);
c = a;
cout << c;

// 4）分别将b+c，b-c的值送给数组d和数组e，并输出结果。
intArray d = b+c;
cout << d;
intArray e = b-c;
cout << e;

return 0;
}

追问

可是有人做出来了啊。。😳

可是有人做出来了啊。。😳

追答

做出来是做出来，但是肯定有问题。要么编译不过，要么编译过了运行时崩溃。

追问

不知道。老师要我们下次交

追答

你就交这个就行，要是我就直接跟老师说你头文件写的有问题。老师一看就知道有问题了，很明显的错误。

追问

哦哦。谢谢了