第十四周实验报告1

实验目的：

【任务1】建立专门的数组类处理有关数组的操作数组是几乎所支持的组织数据的方法。C和C++对数组类型提供了内置支持，使我们利用数组实现软件中需要的各种实用的能。
但是，这种支持仅限于用来读写单个元素的机制。C++不支持数组的抽象abstraction，也不支持对整个数组的操作。
例如：把一个数组赋值给另外一个数组，对两个数组进行相等比较或者想知道数组的大小size，等等。
对C++而言，数组是从C语言中继承来的，它反映了数据与对其进行操作的算法的分离，有浓厚的过程化程序设计的特征。
数组并不是C++语言的一等公民。所以在实际项目中，对一个C++程序员，更多的是使用标准库中提供的Vector类型实现数组功能。
这个任务也将从面向对象角度重新审视和理解数组，进而扫清自学Vector等标准类中可能存在的障碍。
在下面代码的基础上，完成支持数组操作的类的设计，增强C++内置数组类型功能。

实验代码：

#include <iostream> 

using namespace std;

class MyArray  
{  
private:  
    int *arr;       //用于存放动态分配的数组内存首地址   
    int size;       //数组大小   
public:  
    MyArray(int sz = 50);  
    MyArray(int a[], int sz);    //由一个内置类型的数组初始化   
    MyArray(const MyArray &A);  //复制构造函数   
    ~MyArray(void);             //析构函数，注意释放空间   
    MyArray &operator = (const MyArray &A); //重载“=”使得数组对象可以整体赋值   
    int &operator[](int i);     //重载[]，使得Array对象也可以如C++普通数组一样，用a[i]形式取出值【选做】   
    bool operator == (MyArray &A);  //重载==，使得Array对象能整体判断两个数组是否相等（size相等且对应元素相等）   
    MyArray operator + (MyArray &A);    //重载+，使两个Array对象可以整体相加（前提大小相等）【选做】   
    friend ostream &operator << (ostream &out,MyArray &A);    //重载<<，输出数组   
    int GetSize(void)const; //取数组大小；   
    void Resize(int sz);    //修改数组的大小，如果sz大于数组的原大小，增加的元素初始为；如果sz大于数组的原大小，舍弃后面的元素【选做】   
};  
  
//以下为类成员函数的定义   
  
//构造函数   
MyArray::MyArray(int sz)  
{  
    if(sz <= 0)  
    {  
        cout << "数组的大小不能为负";  
        exit(1);  
    }
	size = sz;            //将元素个数赋值给变量size 
    arr = new int[size]; //动态分配内存，将size个int类型的元素空间分配出来   
    for(int i = 0; i < size; ++i) 
	{
        *(arr + i) = 0; 
	}
}  
  
MyArray::MyArray(int a[],int sz) //由一个内置类型的数组初始化
{  
    if(sz <= 0)  
    {  
        cout << "数组的大小不能为负";  
        exit(1);  
    }  
    size = sz;//将元素个数赋值给变量size   
    arr = new int[size];//动态分配内存，将size个int类型的元素空间分配出来   
    for(int i = 0; i < size; ++i) 
	{
        *(arr + i) = *(a + i); 
	}
}  
MyArray::~MyArray(void)
{  
    delete []arr;  
} 

MyArray::MyArray(const MyArray &A) //复制构造函数 
{     
    int n = A.size;  
    size = n;    
    arr = new int[n];   
    for(int i = 0; i < n; i++)
	{
		arr[0 + i] = A.arr[0 + i];
	}
}  
   
MyArray &MyArray::operator = (const MyArray &A)      
{  
    int n = A.size;//取A数组的大小   
    //如果本对象中的数组大小和A不同，则删除数组原有的内存，然后重新分配   
    if (size != n)  
    {  
        delete []arr;  
        arr = new int[n];  
        size = n;  
    }   
    for(int i = 0; i < n; i++)
	{
		arr[0 + i] = A.arr[0 + i];
	}  
    return *this;   
}  
  
   
int &MyArray::operator[](int n)  
{  
    if(n < 0 || n > size - 1)  
    {  
        cout << "index Out Of Range" << endl;  
        exit(1);  
    }  
    return arr[n];  
}  
  
bool MyArray::operator == (MyArray &A)  //重载==，使得Array对象能整体判断两个数组是否相等（size相等且对应元素相等）
{    
	int n = A.size;   //取A数组的大小   
	if (size != n)   //大小是否一致   
	{  
		return false;  
	}  
	else  
	{    
		while(n--)  
		{  
			if(arr != A.arr)  
			{  
				return false;  
			 }  
			arr++;  
			A.arr++;  
		}
	}
	return true;
}  
  
MyArray MyArray::operator + (MyArray &A)  
{  
    int n = A.size;   //取A数组的大小   
    if (size != n)   //大小不一致不能相加   
    {  
        cout << "两个数组的大小不同，无法进行相加" <<endl;  
        exit(1);  
    }  
    MyArray a(n);  //指定size的数组   
  
    for (int i = 0; i < size; i++)  
    {  
        a[i] = arr[i] + A[i];  
    }  
    return a; //返回当前对象的引用   
}  
  
ostream &operator << (ostream &out, MyArray &A)  
{  
    for (int i = 0; i < A.size; i++)  
    {  
        out << A[i] << "  ";  
    }  
    out << endl;  
    return out;  
}  
  
//取当前数组大小   
int MyArray::GetSize(void)const  
{  
    return size;  
}  

void MyArray::Resize(int sz)  
{  
    if(sz <= 0)  
    {  
        cout << "数组大小不能为负";  
        exit(1);  
    }  
    if(sz == size)
	{
        return; 
	}

    int *newlist = new int[sz];  
    for (int i = 0; i < sz; i++)  
    {  
        *(newlist + i) = 0;  
    }  
    int n = (sz <= size)?sz:size;  
    for(int i = 0; i < n; i++)
	{
		newlist[0 + i] = arr[0 + i];
	}  
    delete []arr;  
    arr = newlist;  
    size = sz;
}  
  
int main()  
{  
    int a[10]={1,2,3,4,5,6,7,8,9,10};  
    int b[10]={4,5,6,7,8,9,10,11,12,13};  
    MyArray arr1(a,10);  
    MyArray arr2(b,10); 
	cout << arr1;
	cout << arr2;

    MyArray arr3(10);  
    cout << arr3;

    arr3 = arr1 +arr2;  
    cout << arr3;

    arr3.Resize(20);  
    cout << arr3;  
    arr3.Resize(5);  
    cout << arr3; 

    system("pause");  
    return 0;  
}  

实验结果截图：

1  2  3  4  5  6  7  8  9  10
4  5  6  7  8  9  10  11  12  13
0  0  0  0  0  0  0  0  0  0
5  7  9  11  13  15  17  19  21  23
5  7  9  11  13  15  17  19  21  23  0  0  0  0  0  0  0  0  0  0
5  7  9  11  13
请按任意键继续. . .

实验心得：

这个实验，不得不说，挺难的，考察的东西也很多，笼统的说，不太容易，还是一点一点描述的好。

老师给出的代码，已经有了类，包括数据成员和成员函数，也给出了主函数，其实要做的，说简单也简单，就是根据功能，补充成员函数的函数体，可是看似简单的问题，解决起来却一点也不轻松。

要完成的函数有这么几个

   MyArray(int sz = 50);  
    MyArray(int a[], int sz);    //由一个内置类型的数组初始化   
    MyArray(const MyArray &A);  //复制构造函数   
    ~MyArray(void);             //析构函数，注意释放空间   
    MyArray &operator = (const MyArray &A); //重载“=”使得数组对象可以整体赋值   
    int &operator[](int i);     //重载[]，使得Array对象也可以如C++普通数组一样，用a[i]形式取出值【选做】   
    bool operator == (MyArray &A);  //重载==，使得Array对象能整体判断两个数组是否相等（size相等且对应元素相等）   
    MyArray operator + (MyArray &A);    //重载+，使两个Array对象可以整体相加（前提大小相等）【选做】   
    friend ostream &operator << (ostream &out,MyArray &A);    //重载<<，输出数组   
    int GetSize(void)const; //取数组大小；   
    void Resize(int sz);    //修改数组的大小，如果sz大于数组的原大小，增加的元素初始为；如果sz大于数组的原大小，舍弃后面的元素【选做】

从给数组置大小，到数组初始化，再到复制数组，等等，每一个函数都有其不容易解决的地方，像是运用指针指向数组实现相加或者赋值，总容易把人绕晕，因此代码实现时真的会有障碍存在，当然这只是我个人的感觉，也可能是自己能力尚且不足的原因。总体感觉，真的是没有什么好的办法，耐心在这里就显得尤为重要，真的，当时是被搞得焦头烂额，心情烦躁，以为很正确的代码，却总是出现问题，不是有错误，就是得不到想要的结果，当然，特别是在对付指针的时候。好就好在，我们还有很好的资源，现在觉得，阅读别人的代码有时候真的是可以让人茅塞顿开，特别是void Resize(int sz);函数的实现，老师的方法，真的是我心服口服。

总之，I found that I still have lots more to work on..