Разность двух множеств через массивы

#include <iostream>
using namespace std;
 
class Set {
    friend ostream& operator<< (ostream&, const Set&); //перегрузка вывода  
    friend istream& operator>> (istream&, Set&); //перегрузка ввода
 
private:
    int* members; //ссылка на начало массива
    int len; // размер массива
public:
    Set(); // по умолчанию
    Set(int); // с параметрами
    Set(const Set&); // копирования
 
    ~Set();// деструктор
    int getLenght() const; // вернуть размер массива
    const Set& operator= (const Set&); // оператор присваивания
    bool operator== (const Set&) const; // перегрузка сравнения
    int& operator[] (int);//перегрузка взятия индекса(для удаления элемента)
 
    Set& operator-(int n);// перегрузка удаления элемента
    Set operator- (const Set& ob2); // перегрузка разности
    Set operator+ (const Set& ob2);// перегрузка сложения
    Set& operator+ (const int&);//перегрузка добавления элемента
 
 
 
};
 
 
Set::Set() // конструктор по умолчанию, без параметров
{
    len = 3; // по умолчанию размер массива = 3 элементов
    members = new int[len]; // выделение места для массива
    for (int i = 0; i < len; i++) // обнуление массива
        members[i] = 0;
}
 
Set::Set(int size) // конструктор с параметрами
{
 
    len = (size > 0 ? size : 3);// если значение параметра больше 0, присвоить members значение size, иначе - 3
    members = new int[len]; // выделить место в памяти для массива
 
    for (int i = 0; i < len; i++) // обнуление 
        members[i] = 0;
}
 
Set::Set(const Set & copy) // конструктор копии
    :len(copy.len)              // инициализатор размера массива
{
    members = new int[len]; // выделение места для массива
 
    for (int i = 0; i < len; i++)
        members[i] = copy.members[i]; // заполняем массив значениями массива copy
}
 
Set::~Set() // десструктор класса Set
{
    delete[] members; // удаляет элементы массива
}
 
int Set::getLenght() const // вернуть размер массива
{
    return len;
}
const Set& Set::operator= (const Set & ob2) // оператор присваивания
{
    if (&ob2 != this) // чтобы не выполнялось самоприсваивание
    {
        if (len != ob2.len)
        {
            delete[] members; // освободить пространство
            len = ob2.len; // установить нужный размер массива
            members = new int[len]; // выделить память под копируемый массив
        }
 
        for (int i = 0; i < len; i++)
            members[i] = ob2.members[i]; // скопировать массив
    }
 
    return *this; //для множественного присваивания
}
int& Set::operator[] (int subscript) // взятие индекса
{
 
    return members[subscript]; // возврат ссылки на элемент массива
}
Set& Set::operator-(int n)//удаление элемента массива // перегрузка удаления последнего элемента
{
    Set temp(*this); // временно сохраняем текущее множество
    delete[] members; // удаляем старое множество
    len = temp.getLenght() - 1; // изменяем текущий размер
    members = new int[len]; // выделить место в памяти для множества
 
    for (int i = 0, j = 0; i < getLenght(); j++)
        if (j != n)
        {
            members[i] = temp.members[j];
            i++;
        }
    return *this;
}
 
    Set& Set::operator+ (const int& number) // оператор добавления элемента 
    {
        Set result(len);
        result = *this; // временно сохраним текущий массив
        delete[] members; // освобождаем память
        len = len +1; 
        members = new int[len]; // выделяем память
        for (int i = 0; i < (len - 1); i++)
            members[i] = result.members[i]; // скопировать массив
        members[len - 1] = number; // добавляем число в конец массива
        return *this;
    }
    Set Set::operator+ (const Set & ob2) // объединение двух множеств
    {
        int num = len + ob2.getLenght(); // количество элементов нового множества
        Set result(num); //создания временного массива с размером num
        int i = 0, j = 0, n = 0;
        while ((i < len) && (j < ob2.getLenght())) {
            if (members[i] < ob2.members[j])
                result.members[n++] = members[i++];
            else if (ob2.members[j] < members[i])
                result.members[n++] = ob2.members[j++];
            else {
                result.members[n++] = members[i++];
                ++j;
            }
 
        }
        while (i < len)
            result.members[n++] = members[i++];
        while (j < ob2.getLenght())
            result.members[n++] = ob2.members[j++];
        return result;
    }
 
 
    Set Set::operator- (const Set & ob2) // разница двух множеств
    {
        Set temp(*this); // временно сохраняем текущее множество
        delete[] members; // удаляем старое множество
        len = temp.getLenght() - 1; // изменяем текущий размер
        members = new int[len]; // выделить место в памяти для множества
 
        for (int i = 0, j = 0; i < getLenght(); i++)
        {
            while (j < ob2.getLenght() && ob2.members[j] != members[i]) j++;
            if (j == ob2.getLenght())
                members[i] = temp.members[j];
            return *this;
        }
    }
    
    istream& operator>> (istream & input, Set & newset) // перегрузка вывода
    {
        for (int i = 0; i < newset.len; i++)
            input >> newset.members[i];
        return input;
    }
    ostream& operator<< (ostream & output, const Set & ob2) // перегрузка ввода
    {
        for (int i = 0; i < ob2.len; i++)
        {
            output << ob2.members[i];
 
        }
 
        output << std::endl;
 
        return output;
    }
 
    bool Set::operator== (const Set & ob2) const// оператор сравнения
    {
        if (len != ob2.len)
            return false;
        for (int i = 0; i < len; i++)
            if (members[i] != ob2.members[i])
                return false;
 
        return true;
    }
 
 
    int main()
    {
 
        setlocale(LC_ALL, "Russian");
 
 
        Set s1;
        Set s2(3);
        Set s3, s4;
        cout << "Введите элементы множества s1 (по умолчанию len =3): \n";
        cin >> s1;
        cout << "Введите элементы множества s2 (с параметром len = 4): \n";
        cin >> s2;
        cout << "множество s1 = " << s1;
        cout << "множество s2 = " << s2;
 
        cout << "s1 после удаления первого элемента: " << s1 - 0 << s1;
 
        cout << "s1 после прибавлении 4: " << s1 + 4 << s1;
 
        s3 = s1 + s2;
        cout << "Сумма s3 = s1 + s2: \n";
        cout << "s3 = " << s3;
 
        cout << "s1 = " << s1;
        cout << "s2 = " << s2;
        s4 = (s1 - s1);
        cout << "Разность s4 =  s1 - s2 \n";
        cout << "s1 = " << s1;
        cout << "s2 = " << s2;
        cout << "s4 = " << s4;
        cout << "s1 = " << s1;
        cout << "Проверка операции присваивания(s1 = s2): \n";
        s1 = s2;
        cout << "s1 = " << s1 << "s2 = " << s2;
        cout << "Проверка операции сравнения: \n";
        if (s1 == s2)
            cout << "s1 равно s2";
        else
            cout << "s1 не равно s2";
 
        cout << "\n";
 
        system("pause");
        return 0;
    }

Set Set::operator- (const Set & ob2) // разница двух множеств
    {
        Set temp(*this); // временно сохраняем текущее множество
        delete[] members; // удаляем старое множество
        len = temp.getLenght() - 1; // изменяем текущий размер
        members = new int[len]; // выделить место в памяти для множества
 
        for (int i = 0, j = 0; i < getLenght(); i++)
        {
            while (j < ob2.getLenght() && ob2.members[j] != members[i]) j++;
            if (j == ob2.getLenght())
                members[i] = temp.members[j];
            return *this;
        }
    }

Set Set::operator- (const Set & ob2)  const 
 {
        Set temp;
................................
         return temp;
    }