[C++]перегрузка

[Nadinka______]

Класс - множество set.

class set
{           
    public:
        set():power(0),rear(NULL){};
        set(const set & s);
        set(int p);
        set(int * a, int sz); 
        ~set();
        friend ostream & operator <<(ostream & out, const set & s);
        set & operator --(); //prefix
        set & operator --(int); //postfix
        operator int() { return power; }
        short operator == (const set & s) const;
        friend set operator +(int el, const set & s);   
        set operator & (const set & s2)const;          
        set & operator -= (const int el);                                   
 private:
        int power;        
        struct element * rear;
        void push(int val);
        struct element * contains(int v) const;
        void delEl(struct element * p);
};
void set::push(int val)                                                         
{ 
    struct element * newEl = new element;
    newEl->v = val;
	power++;
    if (rear)                       //если список не пустой
    {
        newEl->next = rear->next;
        rear->next = newEl;
        rear = newEl;             
    }
    else                            
    {
        newEl->next = newEl;
        rear = newEl;
    }
}

set::set(int * a, int sz):power(0),rear(NULL)            
{
    push(a[0]);
    for (int i=1; i<sz; i++)
    {
        if (!contains(a[i]))
            push(a[i]);
    }   
}

struct element * set::contains(int val) const        
{
    if (!rear) 
        return 0;
    struct element * p = rear;
    do
    {
        if (p->v == val)
            return p;
        p = p->next;
    } while (p != rear);
    return NULL;
}

void set::delEl(struct element * p)
{
    power--;
    delete p;
}

set::set(const set & s):power(0),rear(NULL)     
{
    if (s.rear)
    {
        struct element * p = s.rear->next;
        do             
        {                               
            push(p->v);
            p = p->next;
        } while (p != s.rear->next);
    }
}

set::~set()
{
    if (power)                  
    {
        struct element * p;
        do                             
        {                                   
            p = rear->next;
            rear->next = p->next;
            delEl(p);
        } while (power);
    }
}

ostream & operator <<(ostream & out, const set & s)
{
    if (s.power == 0)          
    {
        out<<"Empty set"<<endl;
        return out;
    }
    int i;                      
    struct element * p = s.rear->next;
    out<<"power["<<s.power<<"]"<<endl;
    do
    {
        out<<p->v<<"   ";         
        p = p->next;
    } while (p != s.rear->next);
    out<<endl;
    return out;
}

set & set::operator --()                
{                    
    struct element * p = rear->next;
    rear->next = p->next;
    delEl(p);
    return (*this);
}

set & set::operator --(int)            
{
    *this -= rear->v;
    return (*this);
}

short set::operator == (const set & s) const
{
    if (power != s.power)                   
        return 0;
    if (power == 0)                         
        return 1;
    struct element * p = s.rear;
    do                                      
    {
        if (!contains(p->v))                
            return 0;                       
        p = p->next;
    } while (p != s.rear);
    return 1;                               
}

set set::operator & (const set & s2)const				//пересечение множеств
{
    
	if ((power == s2.power)&&(*this == s2))             
		return *this;
	set spike; set spike2; set newS;
    if ((power == 0) || (s2.power == 0))                
        return newS;
	struct element *p = rear->next;
	
	if (power <= s2.power)                     
	{
		do       
		{
			if (s2.contains(p->v))      
				newS.push(p->v);
		    p = p->next;
        } while( p != rear->next);
	}
	else
	{
		newS = s2 & *this;
	}
	return newS;
}

set & set::operator -=(const int el)  
{
	struct element *p = contains(el);
	if (p==NULL || power == 0)
		return *this;        
	if ((power == 1) & (p != NULL))        
	{
        delEl(rear);
        rear = NULL;
        return *this;
    }
	if (p == rear)                     
	{
        do 
        {
            p = p->next;                
        } while (p->next != rear);
        p->next = rear->next;
        delEl(rear);
        rear = p;
    }
    else
    {
        struct element *tmp = p->next;
        p->v = p->next->v;
        p->next = p->next->next;        
        if (tmp == rear)
            rear = p;
        delEl(tmp);
        
    }
	return *this;
}

Как мне сделать проверку на подмножество???

[Nadinka______]

Вот само задание:
Класс - множество set. Дополнительно перегрузить следующие операции: -- удалить элемент из множества (типа set-item); * - пересечение множеств; < - сравнение множеств; > - проверка на подмножество; int()- мощность множества.

[_-Re@l-_]

А нафига было создавать класс set, если он и так уже реализован в STL? Возможно, конечно, там не совсем то, но...

[Nadinka______]

А нафига было создавать класс set, если он и так
уже реализован в STL? Возможно, конечно, там не совсем то, но...

Задание контрольной работы