编写一个类，实现运算符重载

Question

利用deque实现动态存储
1）构造、析构、拷贝构造、获取元素个数函数 GetLength()

（2）赋值运算符=

（3）操作（读取和赋值）指定元素运算符[ ]

（4）取某个整数区间返回新集合运算

Answer 1

#include <iostream>
#include <algorithm>
#include <vector>

class CSet
{
private:
    std::vector<int> m_data;

public:
    // 构造函数
    CSet() {}

    // 拷贝构造函数
    CSet(const CSet& other)
    {
        m_data = other.m_data;
    }

    // 析构函数
    ~CSet() {}

    // 获取元素个数函数
    int GetLength() const
    {
        return m_data.size();
    }

    // 赋值运算符
    CSet& operator=(const CSet& other)
    {
        if (this != &other)
        {
            m_data = other.m_data;
        }
        return *this;
    }

    // 操作(读取和赋值)指定元素运算符[]
    int& operator[](int index)
    {
        return m_data[index];
    }

    const int& operator[](int index) const
    {
        return m_data[index];
    }

    // 取某个整数区间返回新集合运算符(start,end)
    CSet operator()(int start, int end) const
    {
        CSet result;
        for (int i = start; i <= end && i < GetLength(); ++i)
        {
            result.m_data.push_back(m_data[i]);
        }
        return result;
    }

    // 把一个元素加到集合末尾并返回新集合运算符+
    CSet operator+(int element) const
    {
        CSet result(*this);
        if (std::find(result.m_data.begin(), result.m_data.end(), element) == result.m_data.end())
        {
            result.m_data.push_back(element);
        }
        return result;
    }

    // 合并两个集合对象并返回新集合运算符+
    CSet operator+(const CSet& other) const
    {
        CSet result(*this);
        for (int i = 0; i < other.GetLength(); ++i)
        {
            int element = other[i];
            if (std::find(result.m_data.begin(), result.m_data.end(), element) == result.m_data.end())
            {
                result.m_data.push_back(element);
            }
        }
        return result;
    }

    // 把一个元素加到集合末尾运算符+=
    CSet& operator+=(int element)
    {
        if (std::find(m_data.begin(), m_data.end(), element) == m_data.end())
        {
            m_data.push_back(element);
        }
        return *this;
    }

    // 合并第二个集合到第一个后面运算符+=
    CSet& operator+=(const CSet& other)
    {
        for (int i = 0; i < other.GetLength(); ++i)
        {
            int element = other[i];
            if (std::find(m_data.begin(), m_data.end(), element) == m_data.end())
            {
                m_data.push_back(element);
            }
        }
        return *this;
    }

    // 输入流提取运算符>>
    friend std::istream& operator>>(std::istream& in, CSet& set)
    {
        int element;
        while (in >> element)
        {
            if (std::find(set.m_data.begin(), set.m_data.end(), element) == set.m_data.end())
            {
                set.m_data.push_back(element);
            }
        }
        return in;
    }

    // 输出流插入运算符<<
    friend std::ostream& operator<<(std::ostream& out, const CSet& set)
    {
        for (int i = 0; i < set.GetLength(); ++i)
        {
            if (i > 0)
            {
                out << " ";
            }
            out << set[i];
        }
        return out;
    }
};

int main() 
{     
    CSet set1;     
    cin >> set1;     
    cout << set1 << endl; 

    CSet set2 = set1;     
    cout << set2 << endl;

    CSet set3;     
    set3 = set1;     
    cout << set3 << endl;

    int len = set1.GetLength();     
    for (int i = 0; i < len; ++i)     
    {         
        cout << set1[i] << " ";     
    }     
    cout << endl; 

    CSet set4 = set1(1, 3);     
    cout << set4 << endl; 

    CSet set5 = set1 + 5;     
    cout << set5 << endl; 

    CSet set6 = set1 + set5;     
    cout << set6 << endl; 

    set1 += 6;     
    cout << set1 << endl;

    set1 += set5;     
    cout << set1 << endl;

    return 0; 
}