程序设计二（面向对象）_实训9_复杂类的实现_Array类的实现

任务描述
为 Array 类重载以下运算符：简单赋值运算符，方括号运算符，小于号运算符，等于号运算符，加号运算符，流输出运算符。

简单赋值运算符和方括号运算符必须以成员函数形式重载，其余运算符以非成员函数形式重载。所有非成员函数都是非友元函数。

相关知识
加号运算符完成连接操作。流输出运算符进行输出，将数组输出为一行，每个数后面接一个空格。

等于号操作符返回 true 或者 false ，两个 Array 类的实例相等，当且仅当两个实例的长度相等且每一个对应的元素分别相等。

小于号操作符返回 true 或者 false，我们使用类似于字典序来比较两个 Array 实例的大小。对于Array a 与 Array b 而言，如果 a 的第一个数小于 b 的第一个数，我们就称 a 小于 b；如果 a 的第一个数大于 b 的第一个数，我们称 a 大于 b；如果 a 的第一个数等于b的第一个数，则比较第二个数……特别的，假设 a 是较短的数组、b 是较长的数组，且 a 的所有元素与 b 前部分的对应元素分别相等，我们称 a 是小于 b 的。反过来，如果 b 是较短的数组，a 是较长的数组，且 b 的元素与 a 前部分的对应元素分别相等，我们称 a 大于 b。

用户还需实现构造函数和成员函数。

编程要求
根据提示，在右侧编辑器的Begin-End区域内补充代码。

测试说明
该项目一共有 3 个文件，main.cpp、Array.h 和 Array.cpp。其中 main.cpp 是测试文件，Array.h 包含 Array 类的定义和成员函数声明。用户仅能修改 Array.cpp 中的内容，在其中实现 Array 的成员函数。

具体实现代码如下

#include<iostream>
using namespace std;
#include"Array.h"

 // 默认构造函数
Array::Array() : size(0) {
    // 初始化为空数组
}

// 复制构造函数
Array::Array(const Array& rhs) {
    size = rhs.getSize();
    for (int i = 0; i < size; i++) {
        data[i] = rhs.data[i];  // 深拷贝数据
    }
}

// 数组初始化，带数组和大小参数，可能抛出invalid_argument异常
Array::Array(int const a[], int n) {
    if (n < 0 || n > 1000) {  // 确保数组大小有效且不超出最大大小
        throw std::invalid_argument("Array");
    }
    size = n;
    for (int i = 0; i < n; i++) {
        data[i] = a[i];
    }
}

// 数组初始化，带大小和默认值，可能抛出invalid_argument异常
Array::Array(int count, int value) {
    if (count < 0 || count > 1000) {
        throw std::invalid_argument("Array");
    }
    size = count;
    for (int i = 0; i < count; i++) {
        data[i] = value;
    }
}

/*** 增删查改 ***/

// 在pos位置上插入一个值为value的元素，pos及其后面的元素依次后移
void Array::insert(int pos, int value) {
    if (pos < 0 || pos > size || size >= 1000) {  // 数组越界检查
        throw std::invalid_argument("insert");
    }
    // 将后续元素后移
    for (int i = size; i > pos; i--) {
        data[i] = data[i - 1];
    }
    data[pos] = value;
    size++;  // 增加数组大小
}

// 删除pos位置上的元素，其后的元素依次前移
void Array::remove(int pos) {
    if (pos < 0 || pos >= size) {  // 确保删除的位置在有效范围内
        throw std::invalid_argument("remove");
    }
    // 将后续元素前移
    for (int i = pos; i < size - 1; i++) {
        data[i] = data[i + 1];
    }
    size--;  // 减少数组大小
}

// 返回第pos个位置上的元素值
int Array::at(int pos) const {
    if (pos < 0 || pos >= size) {  // 确保位置有效
        throw std::invalid_argument("at");
    }
    return data[pos];
}

// 将pos位置上的元素值修改为newValue
void Array::modify(int pos, int newValue) {
    if (pos < 0 || pos >= size) {  // 确保位置有效
        throw std::invalid_argument("modify");
    }
    data[pos] = newValue;
}

// 显示函数，将数组内容显示输出为一行，且每一个数后面均有一个空格
void Array::disp() const {
    for (int i = 0; i < size; i++) {
        cout << data[i] << " ";
    }
    cout << endl;
}
    //简单赋值运算符重载
    Array& Array::operator = (const Array&rhs)
    {
        size=rhs.getSize();
        for(int i=0;i<size;i++)
        {
            data[i]=rhs.data[i];
        }
        return (*this);
    }
    //方括号运算符重载
    int& Array::operator [] (int pos)
    {
        return data[pos];
    }
    const int& Array::operator [] (int pos)const
    {
        return data[pos];
    }

//小于号运算符重载
bool operator<(const Array&lhs,const Array&rhs)
{
    if(lhs.getSize()==rhs.getSize())
    {
        for(int i=0;i<lhs.getSize();i++)
        {
            if(lhs[i]!=rhs[i])
            {
                if(lhs[i]<rhs[i])
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
    }
    else if(lhs.getSize()>rhs.getSize())
    {
        for(int i=0;i<rhs.getSize();i++)
        {
            if(lhs[i]!=rhs[i])
            {
                if(lhs[i]<rhs[i])
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        return false;
    }
    else
    {
        for(int i=0;i<lhs.getSize();i++)
        {
            if(lhs[i]!=rhs[i])
            {
                if(lhs[i]<rhs[i])
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        return true;
    }

}
//等于号运算符重载
bool operator==(const Array&lhs,const Array&rhs)
{
    if(lhs.getSize()==rhs.getSize())
    {
        for(int i=0;i<lhs.getSize();i++)
        {
            if(rhs[i]!=lhs[i])
            {
                return false;
            }
        }
        return true;
    }
    return false;
}
//加号运算符重载
const Array operator + (const Array&lhs,const Array&rhs)
{

    Array a(lhs.getSize()+rhs.getSize(),0);
    for(int i=0;i<lhs.getSize();i++)
    {
        a.modify(i,lhs[i]);
    }
    for(int i=lhs.getSize();i<a.getSize();i++)
    {
        a.modify(i,rhs[i-lhs.getSize()]);
    }
    return a;
}
//流输出运算符重载
using std::ostream;
ostream& operator << (ostream&os,const Array&rhs)
{
    for(int i=0;i<rhs.getSize();i++)
    {
        os<<rhs[i]<<" ";
    }
    return os;
}