程序设计二（面向对象）_实训9_复杂类的实现_Array类的实现——头歌平台作业

这个作业有四个小块，主要是第三个使用到了c++11之后被弃用的功能，以及最后一题对Array比较大小的方法并没有明确的指出，让人摸不着头脑。

第1关：构造函数的实现

任务描述

Array 类是一个比较复杂的类，首先需要实现其构造函数。要求用户为 Array 类提供 4 种构造函数。

相关知识

Array 类 4 种构造函数分别是：

默认构造函数

使用该函数构造出的数组对象，逻辑上是空的；

拷贝构造函数

使用该函数构造出的输出对象，逻辑上的内容应与参数一模一样；

原生输出构造函数

给定一个 C++ 的原生数组，构造出指定内容的数组对象；

填充构造函数

给定参数 n 与 value，构造出一个数组对象，其内容是 n个 value。

编程要求

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

测试说明

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

第2关：成员函数的实现

---

任务描述

为 Array 类实现增、删、查、改4种功能函数，同时为了显示输出，再实现一个 disp 函数，将数组内容输出到显示器。
用户仍然要自行实现上一关中的构造函数。

相关知识

Array 类 4 种构造函数分别是：

默认构造函数

使用该函数构造出的数组对象，逻辑上是空的；

拷贝构造函数

使用该函数构造出的输出对象，逻辑上的内容应与参数一模一样；

原生输出构造函数

给定一个 C++ 的原生数组，构造出指定内容的数组对象；

填充构造函数

给定参数 n 与 value，构造出一个数组对象，其内容是 n个 value。

编程要求

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

测试说明

该项目一共有3个文件，main.cpp、Array.h 和 Array.cpp。其中 main.cpp 是测试文件，Array.h 包含 Array 类的定义和成员函数声明。用户仅能修改 Array.cpp 中的内容，在其中实现 Array 的成员函数。
提醒一下，所有序号均从 0 开始。

第3关：利用异常做参数有效性检查

任务描述

异常是一种错误处理的方式，面向对象程序设计更加倾向于异常处理。不然它们造出异常这种东西又是干嘛用的呢。

相关知识

请为 Array 类的 4 个构造函数和 5 个成员函数书写异常检测，当然实际上只有 6 个函数需要抛出异常。抛出的异常所附带的消息非常简单，只需包含抛出异常的函数名即可。提示：使用__func__ 宏，或者直接用字符串。

编程要求

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

测试说明

该项目一共有 3 个文件，main.cpp、Array.h 和 Array.cpp。其中 main.cpp 是测试文件，Array.h 包含 Array 类的定义和成员函数声明。用户仅能修改 Array.cpp 中的内容，在其中实现 Array 的成员函数。注意需要包含相应的头文件。
特别提示：仔细看 Array.h 中的文字注释

这个第三关实际上描述是有问题的，描述中使用的是老版本的功能，但是实际的答案需要使用c++11以后的版本的语法。

第4关：运算符重载

任务描述

为 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>
#include <stdexcept>
using namespace std;
class Array
{
private:
    enum
    {
        SIZE = 1000
    };              //该枚举的作用是规定原生数组的尺寸
    int data[SIZE]; //被包装的原生数组，可称之为数据的容器
    int size;       //当前数组的实际元素个数
public:
    int getSize() const { return size; }
    //默认构造函数
    Array();
    //拷贝构造函数
    Array(const Array &rhs);
    //原生数组构造函数，a表示原生数组，n表示用a中前n个元素生成对象
    Array(int const a[], int n);
    //填充构造函数，表示该数组由count个value构成
    Array(int count, int value);
    void print()
    {
        for (int i = 0; i < size; i++)
            cout << data[i] << " " << ends;
        cout << endl;
    }
    /**增删查改*/
    // pos位置上插入一个值为value的元素，pos及其后面的元素依次后移
    void insert(int pos, int value);
    //删除pos位置上的元素，其后的元素依次前移
    void remove(int pos);
    //返回第pos个位置上的元素值
    int at(int pos) const;
    //将pos位置上的元素值修改为newValue
    void modify(int pos, int newValue);
    //显示函数，将数组内容显示输出为一行，且每一个数后面均有一个空格
    void disp() const;
    //简单赋值运算符重载
    Array &operator=(const Array &rhs);
    //方括号运算符重载
    int &operator[](int pos);
    const int &operator[](int pos) const;
};
//小于号运算符重载
bool operator<(const Array &lhs, const Array &rhs);
//等于号运算符重载
bool operator==(const Array &lhs, const Array &rhs);
//加号运算符重载
const Array operator+(const Array &lhs, const Array &rhs);
//流输出运算符重载
ostream &operator<<(ostream &os, const Array &rhs);
Array::Array()
{
    size = 0;
};
Array::Array(const Array &rhs)
{
    int i;
    for (i = 0; i < SIZE; ++i)
    {
        data[i] = rhs.data[i];
    }
    size = rhs.getSize();
}
Array::Array(int const a[], int n)
{
    // int len=sizeof(a) / sizeof(a[0]);
    if (n < 0)
    {
        throw std::invalid_argument("Array");
    }
    int i;
    for (i = 0; i < n; ++i)
    {
        data[i] = a[i];
    }
    size = n;
}
Array::Array(int count, int value)
{
    if (count < 0)
    {
        throw std::invalid_argument("Array");
    }
    size = count;
    int i;
    for (i = 0; i < count; ++i)
    {
        data[i] = value;
    }
}
void Array::insert(int pos, int value)
{
    if (pos < 0 || pos > size || size == 1000)
    {
        throw std::invalid_argument("insert");
    }
    size++;
    for (int i = size - 1; i >= pos; i--)
    {
        data[i + 1] = data[i];
    }
    data[pos] = value;
}
void Array::remove(int pos)
{
    if (pos < 0 || pos > size)
    {
        throw std::invalid_argument("remove");
    }
    for (int i = pos; i < size; i++)
    {
        data[i] = data[i + 1];
    }
    size--;
}
int Array::at(int pos) const
{
    if (pos > size || pos < 0)
    {
        throw std::invalid_argument("at");
    }
    return data[pos];
}
void Array::modify(int pos, int newValue)
{
    if (pos > size || pos < 0)
    {
        throw std::invalid_argument("modify");
    }
    data[pos] = newValue;
}
void Array::disp() const
{
    if (size == 0)
    {
        return;
    }
    for (int i = 0; i < size; i++)
    {
        cout << data[i] << " ";
    }
    cout << endl;
}
Array &Array::operator=(const Array &rhs)
{
    int i;
    for (i = 0; i < rhs.size; ++i)
    {
        data[i] = rhs.data[i];
    }
    size = rhs.getSize();
    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() && lhs[0] <= rhs[0])
        return 1;
    else
        return 0;
}
bool operator==(const Array &lhs, const Array &rhs)
{
    bool res = 1;
    if (lhs.getSize() == rhs.getSize())
    {
        for (int i = 0; i < lhs.getSize(); i++)
            if (lhs[i] != rhs[i])
                res = 0;
        return res;
    }
    else
    {
        return 0;
    }
}
const Array operator+(const Array &lhs, const Array &rhs)
{
    Array tmp = lhs;
    for (int i = 0; i < rhs.getSize(); i++)
    {
        tmp.insert(tmp.getSize(), rhs[i]);
    }
    return tmp;
}
ostream &operator<<(ostream &os, const Array &rhs)
{
    for (int i = 0; i < rhs.getSize(); i++)
    {
        os << rhs[i] << " ";
    }
    return os;
}
int A[] = {1, 23, 4};
int main()
{
    try
    {
        // int u[7];
        // for (int i = 0; i < 7; ++i)
        //     cin >> u[i];
        // Array a(A, u[0]);
        // a.disp();
        // Array b(u[1], 9);
        // b.disp();
        // a.insert(u[2], 100);
        // a.disp();
        // a.remove(u[3]);
        // a.disp();
        // cout << a.at(u[4]) << endl;
        // a.modify(u[5], 100);
        // a.disp();
        // if (u[6] < 0)
        // {
        //     Array c(1000, 0);
        //     c.insert(0, 100);
        // }
        int n, m;
        cin >> n >> m;
        Array a(n, 0), b(m, 0);
        for (int i = 0; i < n; ++i)
            cin >> a[i];
        for (int i = 0; i < m; ++i)
            cin >> b[i];
        cout << a << endl;
        cout << b << endl;
        cout << (a == b) << endl;
        cout << (a < b) << endl;
        Array c;
        c = a = a + b;
        cout << c << endl;
    }
    catch (exception &e)
    {
        cout << e.what() << endl;
    }

    return 0;
}

这里直接全部给出了，为了方便调试，就把所有的代码放在一个文件里面，平台作业的提交需要更改一点点。

为了方便复制答案，如下：

//第一关
#include "Array.h"
Array::Array()
{
    size = 0;
}
Array::Array(const Array &rhs)
{
    size = rhs.size;
    for (int i = 0; i < size; i++)
        data[i] = rhs.data[i];
}
Array::Array(int const a[], int n)
{
    size = n;
    for (n--; n != -1; n--)
        data[n] = a[n];
}
Array::Array(int count, int value)
{
    size = count;
    for (count--; count != -1; count--)
        data[count] = value;
}

//第二关
#include "Array.h"
#include <iostream>
using std::cout;
using std::endl;
Array::Array()
{
    size = 0;
}
Array::Array(const Array &rhs)
{
    size = rhs.size;
    for (int i = 0; i < size; i++)
        data[i] = rhs.data[i];
}
Array::Array(int const a[], int n)
{
    size = n;
    for (n--; n != -1; n--)
        data[n] = a[n];
}
Array::Array(int count, int value)
{
    size = count;
    for (count--; count != -1; count--)
        data[count] = value;
}
void Array::insert(int pos, int value)
{
    size++;
    for (int i = size; i != pos; i--)
        data[i] = data[i - 1];
    data[pos] = value;
}
void Array::remove(int pos)
{
    size--;
    for (; pos != size + 1; pos++)
        data[pos] = data[pos + 1];
}
int Array::at(int pos) const
{
    return data[pos];
}
void Array::modify(int pos, int newValue)
{
    data[pos] = newValue;
}
void Array::disp() const
{
    for (int i = 0; i < size; i++)
        cout << data[i] << " ";
    cout << endl;
}

//第三关
/***begin***/
#include <iostream>
using namespace std;
#include "Array.h"
Array::Array()
{
    size = 0;
};
Array::Array(const Array &rhs)
{
    int i;
    for (i = 0; i < SIZE; ++i)
    {
        data[i] = rhs.data[i];
    }
    size = rhs.getSize();
}
Array::Array(int const a[], int n)
{
    // int len=sizeof(a) / sizeof(a[0]);
    if (n < 0)
    {
        throw std::invalid_argument("Array");
    }
    int i;
    for (i = 0; i < n; ++i)
    {
        data[i] = a[i];
    }
    size = n;
}
Array::Array(int count, int value)
{
    if (count < 0)
    {
        throw std::invalid_argument("Array");
    }
    size = count;
    int i;
    for (i = 0; i < count; ++i)
    {
        data[i] = value;
    }
}
void Array::insert(int pos, int value)
{
    if (pos < 0 || pos > size || size == 1000)
    {
        throw std::invalid_argument("insert");
    }
    size++;
    for (int i = size - 1; i >= pos; i--)
    {
        data[i + 1] = data[i];
    }
    data[pos] = value;
}
void Array::remove(int pos)
{
    if (pos < 0 || pos > size)
    {
        throw std::invalid_argument("remove");
    }
    for (int i = pos; i < size; i++)
    {
        data[i] = data[i + 1];
    }
    size--;
}
int Array::at(int pos) const
{
    if (pos > size || pos < 0)
    {
        throw std::invalid_argument("at");
    }
    return data[pos];
}
void Array::modify(int pos, int newValue)
{
    if (pos > size || pos < 0)
    {
        throw std::invalid_argument("modify");
    }
    data[pos] = newValue;
}
void Array::disp() const
{
    if (size == 0)
    {
        return;
    }
    for (int i = 0; i < size; i++)
    {
        cout << data[i] << " ";
    }
    cout << endl;
}

/***end***/ 

//第四关
#include "Array.h"
#include <iostream>
#include <stdexcept>
using namespace std;
Array::Array()
{
    size = 0;
};
Array::Array(const Array &rhs)
{
    int i;
    for (i = 0; i < SIZE; ++i)
    {
        data[i] = rhs.data[i];
    }
    size = rhs.getSize();
}
Array::Array(int const a[], int n)
{
    // int len=sizeof(a) / sizeof(a[0]);
    if (n < 0)
    {
        throw std::invalid_argument("Array");
    }
    int i;
    for (i = 0; i < n; ++i)
    {
        data[i] = a[i];
    }
    size = n;
}
Array::Array(int count, int value)
{
    if (count < 0)
    {
        throw std::invalid_argument("Array");
    }
    size = count;
    int i;
    for (i = 0; i < count; ++i)
    {
        data[i] = value;
    }
}
void Array::insert(int pos, int value)
{
    if (pos < 0 || pos > size || size == 1000)
    {
        throw std::invalid_argument("insert");
    }
    size++;
    for (int i = size - 1; i >= pos; i--)
    {
        data[i + 1] = data[i];
    }
    data[pos] = value;
}
void Array::remove(int pos)
{
    if (pos < 0 || pos > size)
    {
        throw std::invalid_argument("remove");
    }
    for (int i = pos; i < size; i++)
    {
        data[i] = data[i + 1];
    }
    size--;
}
int Array::at(int pos) const
{
    if (pos > size || pos < 0)
    {
        throw std::invalid_argument("at");
    }
    return data[pos];
}
void Array::modify(int pos, int newValue)
{
    if (pos > size || pos < 0)
    {
        throw std::invalid_argument("modify");
    }
    data[pos] = newValue;
}
void Array::disp() const
{
    if (size == 0)
    {
        return;
    }
    for (int i = 0; i < size; i++)
    {
        cout << data[i] << " ";
    }
    cout << endl;
}
Array &Array::operator=(const Array &rhs)
{
    int i;
    for (i = 0; i < rhs.size; ++i)
    {
        data[i] = rhs.data[i];
    }
    size = rhs.getSize();
    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() && lhs[0] <= rhs[0])
        return 1;
    else
        return 0;
}
bool operator==(const Array &lhs, const Array &rhs)
{
    bool res = 1;
    if (lhs.getSize() == rhs.getSize())
    {
        for (int i = 0; i < lhs.getSize(); i++)
            if (lhs[i] != rhs[i])
                res = 0;
        return res;
    }
    else
    {
        return 0;
    }
}
const Array operator+(const Array &lhs, const Array &rhs)
{
    Array tmp = lhs;
    for (int i = 0; i < rhs.getSize(); i++)
    {
        tmp.insert(tmp.getSize(), rhs[i]);
    }
    return tmp;
}
ostream &operator<<(ostream &os, const Array &rhs)
{
    for (int i = 0; i < rhs.getSize(); i++)
    {
        os << rhs[i] << " ";
    }
    return os;
}

重载小于号写的不尽完美，但是通过吗、平台的测试还是可以的。

                                                                                                 HBUT           duxingmengshou