Разработать класс Set "множество целых чисел" в соответствии со следующим заданием

Реализовать класс конечное множество целых чисел, который имеет следующий интерфейс:

    class Set
{
    int size; // размер множества !!power
    int count; // количество элементов в множестве !!max
    int* p; // указатель на массив элементов
public:
    // конструкторы
    Set(const int& _size = 0); // по умолчанию
    Set(const Set& s); // копирования
    // деструктор
    ~Set() { };
    // функции члены класса
    int getSize() const; // размерность множества
    int getCount() const; // количество элементов в множестве
    void include(const int& n); // включить элемент
    bool exclude(const int& n); // исключить элемент
    void empty(); // очистка множества
    bool isInSet(const int& n) const; // есть такой элемент? 
    // операторы члены класса
    Set& operator =(const Set& s); // присваивание множеств
    Set& operator +=(const Set& s); // объединение множеств
    Set& operator -=(const Set& s); // разность множеств
    Set& operator *=(const Set& s); // пересечение множеств
    // операторы друзья класса
    // объединение множеств
    friend Set operator +(const Set& s1, const Set& s2);
    // разность множеств
    friend Set operator -(const Set& s1, const Set& s2);
    // пересечение множеств
    friend Set operator *(const Set& s1, const Set& s2);
    // операторы ввода-вывода
    // ввод элемента в множество из потока
    friend istream& operator >>(istream& in, Set& s);
    // вывод множества в поток
    friend ostream& operator <<(ostream& out, const Set& s);
};

У меня есть заготовка, но немного запутался в добавлении и удалении элемента, помогите разобраться:

#include "Set.h"
 

    Set::Set(const Set& s) // копирования
    {
        size = s.size; //копируем размерность множества
        p = new int[count];
        memcpy(p, s.p, sizeof(int) * size); //копируем данные
    }
     
    // функции члены класса
     
    int Set::getSize() const // размерность множества
    {
        return size;
    }
    int Set::getCount() const // количество элементов в множестве
    {
        return count;
    }
    void Set::include(const int& n) // включить элемент
    {
     
    }
    bool Set::exclude(const int& n) // исключить элемент
    {
     
    }
    void Set::empty() // очистка множества
    {
        delete[]p;
    }
     
    bool Set::isInSet(const int& n) const // есть такой элемент?
    {
        for (int i = 0; i < size; i++) //ищем символ в массиве
            if (p[i] == n) return true; //нашли - возвращаем 1
        return false; //не нашли - 0
    }
     
    // операторы члены класса
     
    Set& Set::operator = (const Set& s) // присваивание множеств
    { //аналогично конструктору копирования
     
        size = s.size;
        p = new int[count];
        memcpy(p, s.p, sizeof(int) * size);
        return *this;
    }
     
    Set& Set::operator += (const Set& s) // объединение множеств
    {
        if (size + 1 > count || isInSet(s)) return *this; //если max достигнут или такой элемент уже есть - выходим
        p[size] = s; //Добавляем в конец
        size++; //увеличиваем size //не думаю, что правильно + выдает ошибку из-за разных типов
    }
     
    Set& Set::operator -= (const Set& s) // разность множеств
    { //аналогично конструктору копирования
     
        if (size - 1 < count || isInSet(s)) return *this; //если min достигнут или такой элемент уже есть - выходим
        p[size] = s; //Добавляем в конец
        size++; //увеличиваем size //не думаю, что правильно + выдает ошибку из-за разных типов
    }
     
    Set& Set::operator *= (const Set& s) // пересечение множеств
    {
        if (isInSet(s)) return *this;
        p[size] = s; //Добавляем в конец
        size++; //увеличиваем мощность //не думаю, что правильно + выдает ошибку из-за разных типов
    }
     
    // операторы друзья класса
     
     
    // объединение множеств
     
    Set operator + (const Set& s1, const Set& s2)
    {
        Set tmp;
        for (int i = 0; i < s1.size; i++) //просто добавляем к результату все символы первого и второго множеств
            tmp += s1.p[i]; //повторные не добавятся из-за реализации оператора +=
        for (int i = 0; i < s2.size; i++)
            tmp += s2.p[i];
        return tmp;
    }
     
    // разность множеств
    Set operator - (const Set& s1, const Set& s2) 
    {
        Set tmp; //буфер
        for (int i = 0; i < s1.size; i++) //идём по символам первого множества
            if (!s2.isInSet(s1.p[i])) tmp += s1.p[i]; //если символ первого не содержится во втором, добавляем  к результату
        return tmp; //возвращаем буфер
    }
     
    // пересечение множеств
    Set operator * (const Set& s1, const Set& s2)
    {
        Set tmp;
        for (int i = 0; i < s1.size; i++) //если символ первого содержится во втором, добавляем к результату
            if (s2.isInSet(s1.p[i])) tmp += s1.p[i];
        return tmp;
    }
     
    // ввод элемента в множество из потока
    istream& operator >> (istream& in, Set& s)
    {
        cout << "Enter power: ";
        in >> s.size;
        cout << "Enter chars: ";
        for (int i = 0; i < s.size; i++)
            in >> s.p[i];
        return in;
    }
     
    // вывод множества в поток
    ostream& operator << (ostream& out, const Set& s)
    {
        out << "{ ";
        for (int i = 0; i < s.size - 1; i++)
            out << s.p[i] << ", ";
        out << s.p[s.size - 1] << " }";
        return out;
    }