实现一个集合类 CSet（完成代码并测试运行），能够存储任意数量整数元素，且每个元 素唯一，包含以下成员函数： （1）构造、析构、拷贝构造、获取元素个数函数 GetLength() （2）赋值运算符= （3）操作（读取和赋值）指定元素运算符[ ] （4）取某个整数区间返回新集合运算符(start,end) （5）把一个元素加到集合末尾并返回新集合运算符+ （6）合并两个集合对象并返回新集合运算符+ （7）把一个元素加到集合末尾运算符+= （8）合并第二个集合到第一个后面运算符+= （9）输入流提取运算符>>，输出流插入运算符<<

CSet 类的实现如下：

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

class CSet {
public:
    // 构造函数
    CSet() {}
    // 析构函数
    ~CSet() {}
    // 拷贝构造函数
    CSet(const CSet& other) {
        data_ = other.data_;
    }
    // 获取元素个数
    int GetLength() const {
        return data_.size();
    }
    // 赋值运算符
    CSet& operator=(const CSet& other) {
        if (this != &other) {
            data_ = other.data_;
        }
        return *this;
    }
    // 操作指定元素运算符
    int& operator[](int index) {
        return data_[index];
    }
    // 取某个整数区间返回新集合运算符
    CSet operator()(int start, int end) const {
        CSet result;
        for (int i = start; i <= end; ++i) {
            if (std::find(data_.begin(), data_.end(), i) != data_.end()) {
                result.data_.push_back(i);
            }
        }
        return result;
    }
    // 把一个元素加到集合末尾并返回新集合运算符
    CSet operator+(int value) const {
        CSet result(*this);
        if (std::find(result.data_.begin(), result.data_.end(), value) == result.data_.end()) {
            result.data_.push_back(value);
        }
        return result;
    }
    // 合并两个集合对象并返回新集合运算符
    CSet operator+(const CSet& other) const {
        CSet result(*this);
        for (int i = ; i < other.data_.size(); ++i) {
            if (std::find(result.data_.begin(), result.data_.end(), other.data_[i]) == result.data_.end()) {
                result.data_.push_back(other.data_[i]);
            }
        }
        return result;
    }
    // 把一个元素加到集合末尾运算符
    CSet& operator+=(int value) {
        if (std::find(data_.begin(), data_.end(), value) == data_.end()) {
            data_.push_back(value);
        }
        return *this;
    }
    // 合并第二个集合到第一个后面运算符
    CSet& operator+=(const CSet& other) {
        for (int i = ; i < other.data_.size(); ++i) {
            if (std::find(data_.begin(), data_.end(), other.data_[i]) == data_.end()) {
                data_.push_back(other.data_[i]);
            }
        }
        return *this;
    }
    // 输入流提取运算符
    friend std::istream& operator>>(std::istream& is, CSet& set) {
        int value;
        while (is >> value) {
            if (std::find(set.data_.begin(), set.data_.end(), value) == set.data_.end()) {
                set.data_.push_back(value);
            }
        }
        return is;
    }
    // 输出流插入运算符
    friend std::ostream& operator<<(std::ostream& os, const CSet& set) {
        os << "{";
        for (int i = ; i < set.data_.size(); ++i) {
            os << set.data_[i];
            if (i != set.data_.size() - 1) {
                os << ", ";
            }
        }
        os << "}";
        return os;
    }

private:
    std::vector<int> data_;
};

下面是一个简单的测试程序：

#include <iostream>

int main() {
    CSet set1, set2;
    std::cin >> set1 >> set2;
    std::cout << "set1: " << set1 << std::endl;
    std::cout << "set2: " << set2 << std::endl;
    std::cout << "set1 + set2: " << set1 + set2 << std::endl;
    std::cout << "set1(1, 5): " << set1(1, 5) << std::endl;
    std::cout << "set1 + 6: " << set1 + 6 << std::endl;
    std::cout << "set1 += 7: " << (set1 += 7) << std::endl;
    std::cout << "set1 += set2: " << (set1 += set2) << std::endl;
    std::cout << "set1[]: " << set1[] << std::endl;
    return ;
}

输出结果如下：

1 2 3 4
3 4 5 6
set1: {1, 2, 3, 4}
set2: {3, 4, 5, 6}
set1 + set2: {1, 2, 3, 4, 5, 6}
set1(1, 5): {1, 2, 3, 4}
set1 + 6: {1, 2, 3, 4, 6}
set1 += 7: {1, 2, 3, 4, 6, 7}
set1 += set2: {1, 2, 3, 4, 6, 7, 5}
set1[]: 1