在第二次集合类作业的基础上，请扩展相关功能：（1）通过构造函数实现对集合对象的初始化（2）增加集合的交、并、差等功能实现。集合是通常数学意义下的集合，即元素无序且无重复

//
// Created by wp on 2020/3/28.
//

//定义一个集合类Set（集合的概念大家都知道，一组无重复无序数据的集合），包含元素的输入、输出、插入、删除、查找等方法。
//在第二次集合类作业的基础上，请扩展相关功能：（1）通过构造函数实现对集合对象的初始化（2）增加集合的交、并、差等功能实现。集合是通常数学意义下的集合，即元素无序且无重复
#include <iostream>

using namespace std;

template<typename SaveType=int>
class Set {
public:
    //构造函数初始化
    explicit Set (int m_max = 20) {
        this->max = m_max;
        this->index = 0;
        this->a = new SaveType[max];
    }


    //重载赋值运算符
    Set<SaveType> &operator=(Set m_set) {
        //new一个集合的对象,往里面存元素
        Set temp_set = new Set<SaveType>(this->index + m_set.index + 2);
        for (int i = 0; i < this->index + m_set.index; ++i) {
            temp_set.append(this->a[i]);
        }
        //返回自身
        return *this;
    }

    //重载减法运算符
    Set<SaveType> &operator-(Set m_set) {
        //new一个集合的对象,往里面存元素
        //Set temp_set = *new Set<SaveType>(this->index + m_set.index + 2);
        for (int i = 0; i < m_set.index+1; ++i) {
            this->setDeleteNum(m_set.a[i]);
        }
        //返回自身
        return *this;
    }

    //并集  返回一个集合Union
    Set<SaveType> Union(Set m_set) {
        if (this->isEmpyt()) {
            return m_set;
        } else {
            //new一个集合的对象,往里面存元素
            Set temp_set = *new Set<SaveType>((int) (this->index + m_set.index + 2));
            for (int i = 0; i < this->index; ++i) {
                temp_set.append(this->a[i]);
            }
            for (int i = 0; i < m_set.index; ++i) {
                temp_set.append(m_set.a[i]);
            }
            return temp_set;
        }
    }


    //交集  返回一个集合 intersection
    Set<SaveType> intersection(Set m_set) {
        if (this->isEmpyt()) {
            return m_set;
        } else {
            //new一个集合的对象,往里面存元素
            Set temp_set = *new Set<SaveType>((int) (this->index + m_set.index + 2));

            for (int i = 0; i < m_set.index; ++i) {
                if(find(m_set.a[i])){
                    temp_set.append(m_set.a[i]);
                }
            }
            return temp_set;
        }
    }

    //差集 返回一个集合 Difference
    Set<SaveType> Difference(Set m_set) {
        if (this->isEmpyt()) {
            return m_set;
        } else {
            //交集
            Set<SaveType> temp_intersection_set = this->intersection(m_set);
            //并集
            Set<SaveType> temp_Union_set = this->Union(m_set);

            //差集
            Set<SaveType> temp_Difference_set = *this - m_set;

            return temp_Difference_set;
        }
    }


    //集合内部元素的初始化
    void setinit() {
        for (int i = 0; i < this->max; i++) {
            this->append(100 - i);
        }
    }

    //查找元素,返回从0开始的下标
    //没有元素返回-1
    int setFindNum(SaveType num) {
        int m_index = find(num);
        //cout<<m_index<<endl;
        if (m_index != 0) {
            return m_index - 1;
        } else {
            //cout << "没有 " << num << " 这个元素" << endl;
            return -1;
        }
    }

    //输入,加入元素
    void append(SaveType num) {
        if (this->isFull()) {
            cout << "超出范围" << endl;
            return;
        }
        if (find(num)) {
            //cout << "已经有元素 " << num << " 添加失败" << endl;
            return;
        }

        this->a[index] = num;
        index++;
    }

    //输出,从集合的尾部将元素移除,并返回相应的元素
    SaveType pop() {
        if (this->isEmpyt()) {
            cout << "元素已空" << endl;
            return 0;
        }
        index--;
        SaveType temp = this->a[index];
        SaveType temp_null = 0;
        this->a[index] = temp_null;
        return temp;
    }

    //删除集合元素num
    void setDeleteNum(SaveType num) {
        int index_temp = find(num);
        if (index_temp != 0) {
            for (int i = index_temp - 1; i < index - 1; i++) {
                this->a[i] = this->a[i + 1];
            }
            SaveType temp_null = 0;
            this->a[--index] = temp_null;
            //index--;
        } else {
            //cout << "删除失败" << endl;
            return;
        }
    }

    //打印集合元素
    void printf() {
        //cout << index << endl;
        for (int i = 0; i < index; i++) {
            cout << this->a[i] << " , ";
        }
        cout << endl;
    }

    //返回集合长度
    int length() {
        return index;
    }

    //在集合的n处插入元素e
    void setInsert(int n, SaveType e) {
        if (this->isFull()) {
            cout << "插入,集合元素已经满了" << endl;
            return;
        }
        if (find(e)) {
            //cout << "已经有该元素,添加失败" << endl;
            return;
        }
        for (int i = index - 1; i > n - 1; i--) {
            this->a[i + 1] = a[i];
        }
        a[n] = e;
        index++;
    }


private:
    //变量需要初始化,没有的话后面加上{}
    int max;
    int index;
    SaveType *a;

    //判断集合是否为空
    int isEmpyt() {
        return index == 0 ? 1 : 0;
    }

    int isFull() {
        return index == max ? 1 : 0;
    }

    //返回找到这个元素的下标
    int find(SaveType num) {
        for (int i = 0; i < index; i++) {
            if (this->a[i] == num) {
                return i + 1;
            }
        }
        return 0;
    }
};


int main() {
    //模板定义存储的数据类型
    Set<char> x(30);//有参构造函数,默认集合元素是20个,填入参数以后就是这个元素空间的大小

    x.append('z');
    x.append('c');
    x.append('q');
    x.append('a');
    x.append('t');
    x.append('q');
    x.append('a');


    Set<char> y(20);
    y.append('a');
    y.append('f');
    y.append('p');
    y.append('A');
    y.append('W');
    y.append('D');
    y.append('C');
    y.append('q');
    y.append('a');

    //集合
    cout << "集合x:";
    x.printf();
    cout << "集合y:";
    y.printf();
    cout << endl;

    //交集 intersection
    cout << "交集z0:";
    Set<char> z0 = x.intersection(y);
    z0.printf();//打印集合元素
    cout<<endl;

    //并集 Union
    Set<char> z1 = x.Union(y);
    cout << "并集z1:";
    z1.printf();//打印集合元素
    cout<<endl;

    //差集 Difference
    Set<char> z2 = x.Difference(y);
    cout << "差集z2:";
    z2.printf();//打印集合元素
    cout<<endl;


    return 0;
}