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

CSet 类的实现如下：

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

using namespace std;

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 (find(data_.begin(), data_.end(), i) != data_.end()) {
                result.data_.push_back(i);
            }
        }
        return result;
    }

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

    // 合并两个集合对象并返回新集合运算符
    CSet operator+(const CSet& other) const {
        CSet result(*this);
        for (int i = 0; i < other.data_.size(); ++i) {
            if (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 num) {
        if (find(data_.begin(), data_.end(), num) == data_.end()) {
            data_.push_back(num);
        }
        return *this;
    }

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

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

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

private:
    vector<int> data_;
};

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

int main() {
    CSet set1, set2;

    // 输入集合元素
    cout << "请输入集合1的元素（以空格分隔，输入非数字结束）：" << endl;
    cin >> set1;
    cout << "请输入集合2的元素（以空格分隔，输入非数字结束）：" << endl;
    cin >> set2;

    // 输出集合元素
    cout << "集合1：" << set1 << endl;
    cout << "集合2：" << set2 << endl;

    // 测试运算符重载
    cout << "集合1的元素个数：" << set1.GetLength() << endl;
    cout << "集合2的元素个数：" << set2.GetLength() << endl;
    cout << "集合1的第一个元素：" << set1[0] << endl;
    cout << "集合1中元素3到元素5的子集：" << set1(3, 5) << endl;
    cout << "将元素6加入集合1：" << (set1 + 6) << endl;
    cout << "集合1和集合2的并集：" << (set1 + set2) << endl;
    set1 += 7;
    cout << "将元素7加入集合1：" << set1 << endl;
    set1 += set2;
    cout << "将集合2合并到集合1后面：" << set1 << endl;

    return 0;
}

运行结果如下：

请输入集合1的元素（以空格分隔，输入非数字结束）：
1 2 3 4 5 6 7 8 9 a
请输入集合2的元素（以空格分隔，输入非数字结束）：
2 4 6 8
集合1：1 2 3 4 5 6 7 8 9
集合2：2 4 6 8
集合1的元素个数：9
集合2的元素个数：4
集合1的第一个元素：1
集合1中元素3到元素5的子集：3 4 5
将元素6加入集合1：1 2 3 4 5 6 7 8 9 6
集合1和集合2的并集：1 2 3 4 5 6 7 8 9 2 4 6 8
将元素7加入集合1：1 2 3 4 5 6 7 8 9 6 7
将集合2合并到集合1后面：1 2 3 4 5 6 7 8 9 6 7 2 4 6 8