（C/C++）Set类（集合）

Set类（集合）

题目：
#include
using namespace std;
class Set{
private:
int n;
int * pS; //集合元素
public:
Set(){n = 0;pS =NULL;}
Set(Set &s){
n = s.n;
if (n !=0)
{
pS= new int[n+1];
for (int i =1;i<=n;i++) //集合的下标从1开始，集合中不能有重复元素
pS[i] = s.pS[i];
}
}
~Set(){
if (pS)
{
delete []pS;
pS = NULL;
n =0;
}
}
void ShowElement()const{ //输出集合的元素
int temp = 0;
for(int i=1;i {
for(int j=i+1;j {
if(pS[i] > pS[j])
{
temp = pS[i];
pS[i] = pS[j];
pS[j] = temp;
}
}
}
cout<<"{";
for(int i =1;i cout < if (IsEmpty())
cout<<"}"< else cout< }
bool IsEmpty()const{return n?false:true;} //判断集合是否为空
int size(){return n;}
bool IsElement(int e)const {
for (int i =1;i<=n;i++)
if (pS[i] ==e)
return true;
return false;
}
bool operator <=(const Set &s)const;//this <= s判断当前集合是否包于集合s
bool operator ==(const Set &s)const; //判断集合是否相等
Set & operator +=(int e); // 向集合中增减元素e
Set & operator -=(int e); //删除集合中的元素e

Set operator |(const Set &s)const;  //集合并
Set operator &(const Set &s)const;//集合交
Set operator -(const Set &s)const; //集合差

};
完成Set类，实现运算符的重载。
重载操作符+=,向集合中增减元素e,例如:
Set s;
s +=1;
s.ShowElement();//{1}

重载操作符-=,删除集合中元素e,例如:
Set s;
s +=1,s+=2;
s.ShowElement();//{1,2}
s -=1;
s.showElement();//{2}

重载操作符<=,判断当前集合是否包于另一个集合，例如:
Set s1,s2,s3;
s1 +=1; s2+=1;s2+=3; s3+=2;
s1 <=s2;//true
s3 <=s2//false;

重载操作符==,判断集合是否相等,例如:
Set s1 s2;
s1 == s2;//true
s1+=1;s2+=2;
s1 ==s2 ;//false;

重载操作符|,集合并,例如:
Set s1 s2;
s1+=1;s2+=2;
s1|s2 ;//{1,2}

重载操作符&,集合交,例如:
Set s1 s2;
s1+=1;s2+=2;s2+=1;
s1&s2 ;//{1}

重载操作符-,集合差,例如:
Set s1 s2;
s1+=1;s1+=3;s2+=2;s2+=1;
s1-s2 ;//{3}

代码：

#include "cset.h"


bool Set::operator <=(const Set &s)const//this <= s判断当前集合是否包于集合s
{
    if ((this->IsEmpty() && s.IsEmpty()) || this->IsEmpty())
        return true;
    if (this->n > s.n)
        return false;
    for (int i = 1; i <= this->n; ++i)
    {
            if(!s.IsElement(this->pS[i]))
            {
                return false;
            }
    }
    return true;
}

bool Set::operator ==(const Set &s)const//判断集合是否相等
{
    if (this->n != s.n)
        return false;
    for (int i = 1; i <= this->n; ++i)
    {
            if (!s.IsElement(this->pS[i]))
            {
                return false;
            }

    }
    return true;
}

Set & Set::operator +=(int e)    // 向集合中增加元素e
{
    if (IsElement(e))//判断要加的值在集合里是否有相等的
        return *this;//有相等则直接返回本体，不用再加
    int *newP = new int[n+2];//创建一个新指针，指向空间大小为n+2，因为你加一个元素，内存就要多1，所以你新创一个指针，它的大小就总是比this->n多1，即n+1+1
    for (int i=1; i<=n; i++)
    {
        newP[i] = this->pS[i];
    }
    n++;
    newP[n]=e;
    delete []this->pS;//删除它所指向的内存的值
    this->pS = newP;
    return  *this;
}

Set & Set::operator -=(int e)   //删除集合中的元素e
{
    if (!IsElement(e))//判断删除元素是否在集合里，不在的话直接返回本体
        return *this;
    int s = 1;
    int *newp = new int[n];
    if (!IsEmpty())
    {
        for (int i = 1; i <= n; ++i)
        {
            if (this->pS[i] == e)
            {
                continue;
            }
            newp[s] = this->pS[i];
            s++;
        }
        n--;
        delete []this->pS;
        this->pS = newp;
        return *this;
    }
}

Set Set::operator |(const Set &s)const //集合并
{
    Set m;
    int i = 1;
    for (i = 1; i <= this->n; ++i)
    {
        m+=this->pS[i];//先加第一个集合的元素
    }
    for (int j = 1; j <= s.n; ++j)
    {
        if (!this->IsElement(s.pS[j]))//将第二个集合中的元素与第一个集合中的元素进行比较，如果有相等的，跳过，不相等则加进去
        {
            m+=s.pS[j];
        }
    }
    return m;
}
Set Set::operator &(const Set &s)const//集合交
{
    Set m;
    for (int j = 1; j <= s.n; ++j)
    {
        if (this->IsElement(s.pS[j]))//将第二个集合中的元素与第一个元素中的元素进行比较，如果有相等的，直接加
        {
            m+=s.pS[j];
        }
    }
    return m;
}
Set Set::operator -(const Set &s)const //集合差
{
    Set m;
    for (int i = 1; i <= this->n; ++i)
    {
        if (!s.IsElement(this->pS[i]))//同上面，如果两个集合中有不相等的元素，则加进去
        {
            m+=this->pS[i];
        }
    }
    return m;
}

建议：最好先做+=和-=的重载，再利用它们去完成集合并 交 差，要简便很多
这道题坑就坑在下标从1开始，导致你开辟空间时要判断n的值