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

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

（2）赋值运算符=

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

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

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

以下是一个基础示例，演示了如何使用deque实现自定义类的运算符重载：（答题不易，希望采纳💕）

from collections import deque

class MyDeque:
    def __init__(self):
        self.items = deque()

    def __len__(self):
        return len(self.items)

    def __getitem__(self, index):
        return self.items[index]

    def __setitem__(self, index, value):
        self.items[index] = value

    def __str__(self):
        return str(self.items)

    def __add__(self, other):
        new_deque = MyDeque()
        new_deque.items = self.items + other.items
        return new_deque

    def __sub__(self, other):
        new_deque = MyDeque()
        for item in self.items:
            if item not in other.items:
                new_deque.items.append(item)
        return new_deque

    def __mul__(self, n):
        new_deque = MyDeque()
        new_deque.items = self.items * n
        return new_deque

    def __rmul__(self, n):
        return self.__mul__(n)

    def __eq__(self, other):
        return self.items == other.items

    def __ne__(self, other):
        return self.items != other.items
    
    def GetLength(self):
        return len(self.items)
    
    def __del__(self):
        del self.items
        
    def __copy__(self):
        new_deque = MyDeque()
        new_deque.items = self.items.copy()
        return new_deque
    
    def __deepcopy__(self, memo):
        new_deque = MyDeque()
        new_deque.items = copy.deepcopy(self.items, memo)
        return new_deque
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, item):
        self.items[index] = item
        
    def get_range(self, start_index, end_index):
        new_deque = MyDeque()
        for i in range(start_index, end_index+1):
            new_deque.items.append(self.items[i])
        return new_deque

在这个示例中，我们创建了一个名为 MyDeque 的类，它继承自Python内置的 deque 类，并实现了一些常见的运算符重载。其中包括赋值运算符、读取和赋值指定元素运算符、返回新集合的运算符等。

另外，该类还实现了 GetLength() 函数，用于返回当前deque中的元素个数。同时还实现了构造函数、析构函数、拷贝构造函数，以便我们更好地使用deque对象。

最后，我们添加了一个名为 get_range() 的方法，它接受两个参数 start_index 和 end_index，并返回由指定整数区间内的元素组成的新deque。

您好，我是有问必答小助手，您的问题已经有小伙伴帮您解答，感谢您对有问必答的支持与关注！
PS：问答VIP年卡 【限时加赠：IT技术图书免费领】，了解详情>>> https://vip.csdn.net/askvip?utm_source=1146287632不知道你这个问题是否已经解决, 如果还没有解决的话:

• 你可以参考下这篇文章：编写一个猜数字游戏程序。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^