设计和实现整型集合类（Set），并在主函数里对该类进行测试。整型集合类的成员函数要求如下： （1）添加构造函数完成初始化（可用一个集合或数组初始化另一个集合） （2）输出所有元素 （3）添加析构函数释放内存 （4）重载+，-和*运算符实现集合的并､差、交； （5）重载赋值运算符=，用一个集合给另一个集合赋值。

好的，我会为您解答这个问题。

首先，我们需要设计一个整型集合类（Set），可以使用动态数组来存储元素。以下是该类的基本框架：

class Set {
public:
    // 添加构造函数完成初始化
    Set();
    Set(const Set& other);
    Set(int arr[], int size);

    // 添加析构函数释放内存
    ~Set();

    // 输出所有元素
    void print() const;

    // 重载+，-和*运算符实现集合的并、差、交
    Set operator+(const Set& other) const;
    Set operator-(const Set& other) const;
    Set operator*(const Set& other) const;

    // 重载赋值运算符=，用一个集合给另一个集合赋值
    Set& operator=(const Set& other);

private:
    int* mElements;  // 动态数组，存储元素
    int mSize;       // 集合大小
};

接下来，我们需要实现这些成员函数。以下是完整的代码：

#include <iostream>
#include <algorithm>

class Set {
public:
    // 添加构造函数完成初始化
    Set() : mElements(nullptr), mSize(0) {}
    Set(const Set& other) : mElements(nullptr), mSize(0) {
        mElements = new int[other.mSize];
        mSize = other.mSize;
        std::copy(other.mElements, other.mElements + mSize, mElements);
    }
    Set(int arr[], int size) : mElements(nullptr), mSize(0) {
        mElements = new int[size];
        mSize = size;
        std::copy(arr, arr + mSize, mElements);
        std::sort(mElements, mElements + mSize);
        auto it = std::unique(mElements, mElements + mSize);
        mSize = std::distance(mElements, it);
    }

    // 添加析构函数释放内存
    ~Set() {
        delete[] mElements;
        mElements = nullptr;
        mSize = 0;
    }

    // 输出所有元素
    void print() const {
        std::cout << "{ ";
        for (int i = 0; i < mSize; ++i) {
            std::cout << mElements[i] << " ";
        }
        std::cout << "}\n";
    }

    // 重载+，-和*运算符实现集合的并、差、交
    Set operator+(const Set& other) const {
        Set result;
        int i = 0, j = 0;
        while (i < mSize || j < other.mSize) {
            if (i < mSize && (j >= other.mSize || mElements[i] < other.mElements[j])) {
                result.addElement(mElements[i]);
                ++i;
            }
            else if (j < other.mSize && (i >= mSize || mElements[i] > other.mElements[j])) {
                result.addElement(other.mElements[j]);
                ++j;
            }
            else {
                result.addElement(mElements[i]);
                ++i;
                ++j;
            }
        }
        return result;
    }

    Set operator-(const Set& other) const {
        Set result;
        int i = 0, j = 0;
        while (i < mSize) {
            if (j >= other.mSize || mElements[i] < other.mElements[j]) {
                result.addElement(mElements[i]);
                ++i;
            }
            else if (mElements[i] > other.mElements[j]) {
                ++j;
            }
            else {
                ++i;
                ++j;
            }
        }
        return result;
    }

    Set operator*(const Set& other) const {
        Set result;
        int i = 0, j = 0;
        while (i < mSize && j < other.mSize) {
            if (mElements[i] < other.mElements[j]) {
                ++i;
            }
            else if (mElements[i] > other.mElements[j]) {
                ++j;
            }
            else {
                result.addElement(mElements[i]);
                ++i;
                ++j;
            }
        }
        return result;
    }

    // 重载赋值运算符=，用一个集合给另一个集合赋值
    Set& operator=(const Set& other) {
        if (this != &other) {
            delete[] mElements;
            mElements = new int[other.mSize];
            mSize = other.mSize;
            std::copy(other.mElements, other.mElements + mSize, mElements);
        }
        return *this;
    }

private:
    int* mElements;  // 动态数组，存储元素
    int mSize;       // 集合大小

    // 添加元素
    void addElement(int element) {
        if (std::find(mElements, mElements + mSize, element) == mElements + mSize) {
            int* newElements = new int[mSize + 1];
            std::copy(mElements, mElements + mSize, newElements);
            newElements[mSize] = element;
            delete[] mElements;
            mElements = newElements;
            ++mSize;
            std::sort(mElements, mElements + mSize);
        }
    }
};

int main() {
    int arr1[] = { 1, 2, 3, 4 };
    int arr2[] = { 3, 4, 5, 6 };
    Set set1(arr1, 4);
    Set set2(arr2, 4);
    Set set3 = set1 + set2;
    Set set4 = set1 - set2;
    Set set5 = set1 * set2;

    std::cout << "set1: ";
    set1.print();
    std::cout << "set2: ";
    set2.print();
    std::cout << "set1 + set2: ";
    set3.print();
    std::cout << "set1 - set2: ";
    set4.print();
    std::cout << "set1 * set2: ";
    set5.print();

    Set set6;
    set6 = set5;
    std::cout << "set6: ";
    set6.print();

    return 0;
}

在主函数中，我们创建了两个集合 set1 和 set2，并用数组初始化它们。然后，我们分别对它们进行了并、差、交运算，并输出结果。接着，我们使用赋值运算符将 set5 赋值给 set6，并输出 set6 的内容。

这样，我们就实现了一个整型集合类，并在主函数里对该类进行了测试。