Question

C++期末考试题

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;
}

追问

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

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

追答

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

追问

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

追答

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

追问

哦哦。谢谢了