Ошибка в реализации множества

#include <iostream>
using namespace std;
 
 
class Set
{
private:
    int *int_set = nullptr;
    char *char_set = nullptr;
    int size; // размер множества
    bool is_sorted = 0;
 
    inline static int type_ = 0; // тип элементов;
 
    enum { INT = 1, CHAR = 2 };
 
    static void Set_type(int value) { type_ = value; }
 
    void Enter_int_set()
    {
        cout << "1.1 Ввести числа с клавиатуры" << endl;
        cout << "1.2 От n до m" << endl;
 
        int choice_numbers;
        cin >> choice_numbers;
 
        if (choice_numbers == 1) // Ввод с клавиатуры
        {
            int n;
            cout << "Введите количество чисел" << endl;
            cin >> n;
            size = n;
            int *temp_set = new int[size];
 
            cout << "Введите числа:" << endl;
 
            int quant_dublic = 0;
            bool dubl = 0;
            int for_size = size;
            int *temp_arr = new int[size];
            for (int i = 0; i < size; i++) 
                cin >> temp_arr[i];
            insert(temp_arr, size);
 
            Quick_sort(int_set, 0, size - 1);
            is_sorted = 1;
            return;
        }
        else if (choice_numbers == 2) // От element до m
        {
            is_sorted = 1;
            int m = 1;
            int n = 0;
            cout << "Введите n и m: " << endl;
            cin >> n;
            cin >> m;
 
            if (m - n <= 0)
            {
                int c; c = m; m = n; n = c;
            }
 
            size = m - n + 1;
            int_set = new int[size];
            for (int i = 0; i < size; i++) int_set[i] = n + i;
            return;
        }
    }
 
    void Enter_char_set()
    {
        cout << "Введите количество букв:" << endl;
        int n;
        cin >> n;
        size = n;
        char *temp_set = new char[size];
        cout << "Введите буквы:" << endl;
 
        int quant_dublic = 0;
        bool dubl = 0;
        char temp;
        int for_size = size;
        for (int i = 0; i < for_size; i++)
        {
            cin >> temp;
            for (int j = 0; j < i; j++)
            {
                if (temp == temp_set[j])
                {
                    quant_dublic++;
                    dubl = 1;
                    break;
                }
            }
            if (!dubl)
                temp_set[i] = temp; // добавляем во временный массив
            else
            {
                i--;
                for_size--;
            }
            dubl = 0;
        }
        size -= quant_dublic;
 
        char_set = new char[size];
        for (int k = 0; k < size; k++) char_set[k] = temp_set[k];
        delete[] temp_set;
 
        Quick_sort(char_set, 0, size - 1);
        is_sorted = 1;
        return;
    }
 
    template <class T>
    void Quick_sort(T *arr, int left, int right) // Быстрая сортировка для множества чисел
    {
        int i = left, j = right;
        T pivot = arr[(left + right) / 2];
 
        while (i <= j) {
            while (arr[i] < pivot) i++;
            while (arr[j] > pivot) j--;
            if (i <= j)
            {
                int t = arr[i]; // или std::swap(arr[i], arr[j]);
                arr[i] = arr[j];
                arr[j] = t;
                i++;
                j--;
            }
        }
        if (left < j) Quick_sort(arr, left, j);
        if (i < right) Quick_sort(arr, i, right);
    }
 
    void Object_type_selection() // выбор типа элементов
    {
        if (!type_)
        {
            cout << "Выберите тип элементов множества: " << endl;
            cout << "1. Целые числа" << endl;
            cout << "2. Буквы латинского алфавита" << endl;
 
            int choice_type;
            cin >> choice_type;
            switch (choice_type)
            {
            case 1: // Числа
                Set_type(INT);
                Enter_int_set();
                return;
 
            case 2:  // Буквы
                Set_type(CHAR);
                Enter_char_set();
                return;
            default:
                cout << "Ошибка. Введите цифру из диапазона для выбора действия." << endl;
            }
            return;
        }
 
        else if (type_ == 1)
        {
            Enter_int_set();
            return;
        }
 
 
        else if (type_ == 2)
        {
            Enter_char_set();
            return;
        }
    }
 
    template <class T>
    int find_numb_common(T *)
    {
    
    }
 
public:
    template <class T>
    void insert(T element)
    {
        if (type_ == INT)
        {
            for (int i = 0; i < size; i++) // пробег по int_set
            {
                if (element == int_set[i]) return;
            }
 
            T *temp_set = new T[size+1];
 
            for (int i = 0; i < size; i++) 
                temp_set[i] = int_set[i];
            temp_set[size] = element;
            size += 1;
 
            if(int_set != nullptr) delete[] int_set;
            int *int_set = new int[size];
            for (int i = 0; i < size; i++) 
                int_set[i] = temp_set[i];
            
            Quick_sort(int_set, 0, size - 1);
        }
 
        if (type_ == CHAR)
        {
            for (int i = 0; i < size; i++) // пробег по int_set
            {
                if (element == char_set[i]) return;
            }
 
            T *temp_set = new T[size + 1];
 
            for (int i = 0; i < size; i++) int_set[i] = temp_set[i];
 
            temp_set[size] = element;
            size += 1;
 
            delete[] char_set;
            for (int i = 0; i < size; i++) char_set[i] = temp_set[i];
 
            Quick_sort(char_set, 0, size - 1);
        }
        
        is_sorted = 1;
 
        return;
    }
 
    template <class T>
    void insert(T *array, int arr_size)
    {
        T *non_dubl_set = new T[arr_size];
 
        int quant_dublic = 0; // количество повторений
        bool dubl = 0;
        int cnt = 0;
 
        for (int i = 0; i < arr_size; i++) // пробег по array
        {
            for (int j = 0; j < size; j++) // пробег по int_set
            {
                if (type_ == INT)
                {
                    if (array[i] == int_set[j])
                    {
                        quant_dublic++;
                        dubl = 1;
                        break;
                    }
                }
 
                if (type_ == CHAR)
                {
                    if (array[i] == char_set[j])
                    {
                        quant_dublic++;
                        dubl = 1;
                        break;
                    }
                }
            }
            if (!dubl)
            {
                non_dubl_set[cnt] = array[i]; // добавляем во временный массив
                cnt++;
            }
            dubl = 0;
        }
 
        int arr_size_without = arr_size - quant_dublic; // размер array без повторений
 
        int final_size = size + arr_size_without;
 
        T *final_set = new T[final_size];
 
        if (type_ == 1) // первые size элементы из int_set
        {
            for (int i = 0; i < size; i++)
                final_set[i] = int_set[i];
        }
 
        for (int i = size; i < final_size; i++) // оставшиеся arr_size_without элементы из array
            final_set[i] = non_dubl_set[i - size];
 
        //size стал больше
        size = final_size;
 
        if (type_ == 1)
        {
            if (int_set != nullptr) delete[] int_set;
            int_set = new int[size];
 
            for (int i = 0; i < size; i++)
                int_set[i] = non_dubl_set[i];
            Quick_sort(int_set, 0, size - 1);
        }
 
        delete[] non_dubl_set;
        is_sorted = 1;
        return;
    }
 
    void print()
    {
        if (!size) cout << "{}" << endl;
 
        if (type_ == 1)
        {
            cout << "{";
            for (int i = 0; i < this->size; i++)
            {
                cout << int_set[i] << ", ";
            }
            cout << "\b\b}" << endl;
        }
        if (type_ == 2)
        {
            cout << "{";
            for (int i = 0; i < this->size; i++)
            {
                cout << char_set[i] << ", ";
            }
            cout << "\b\b}" << endl;
        }
    }
 
    // Метод для проверки принадлежности элемента множеству
    template <class T>
    bool contains(T element) const 
    {
        if(type_ == INT)
        {
            for (int i = 0; i < size; i++) 
                if (int_set[i] == element) 
                    return true;
            return false;
        }
        if (type_ == CHAR)
        {
            for (int i = 0; i < size; i++)
                if (char_set[i] == element)
                    return true;
            return false;
        }
    }
 
 
    int GetNumerous() // получение размера множества
    {
        return this->size;
    }
 
    Set(bool constr = 0) // конструктор пустого
    {
        if(!constr) Object_type_selection();
        else size = 0; // 1 для конструктора в операторе
    }
 
    //template <class T>
    //Set(T *elements, int size, bool is_sorted_value = 0) // конструктор с готовым массивом
    //{
    //  this->is_sorted = is_sorted_value;
    //
    //  if (type_ == INT)
    //  {
    //      Set_type(INT);
    //      this->size = size;
    //      int_set = elements;
    //      if (!is_sorted)
    //      {
    //          Quick_sort(elements, 0, size - 1);
    //          is_sorted = 1;
    //      }
    //  }
    //
    //  if (type_ == CHAR)
    //  {
    //      Set_type(CHAR);
    //      this->size = size;
    //      char_set = elements;
    //      if (!is_sorted)
    //      {
    //          Quick_sort(elements, 0, size - 1);
    //          is_sorted = 1;
    //      }
    //  }
    //}
 
    Set(const Set &other) // конструктор копирования
    {
        int *size = new int;
        *size = other.size; // копируем размер
        this->size = *size;
        if (type_ == 1) // если элементы целые
        {
            int_set = new int[this->size]; // выделяем память для массива
            for (int i = 0; i < this->size; i++) // копируем элементы
                int_set[i] = other.int_set[i];
        }
        else if (type_ == 2) // если элементы символьные
        {
            char_set = new char[this->size]; // выделяем память для массива
            for (int i = 0; i < this->size; i++) // копируем элементы
                char_set[i] = other.char_set[i];
        }
    }
 
    template <class T>
    Set &operator=(const Set &other) // Конструктор присваивания
    {
        if (this == &other) return *this;
 
        delete int_set;
        delete char_set;
 
        int *size = new int;
        bool *is_sorted = new bool;
        *size = other.size;
        *is_sorted = other.is_sorted;
 
        //this->size = *size;
        //this->is_sorted = *is_sorted;
 
        T *element_set = new int[other.size];
        if (type_ == 1)
        {
            for (int i = 0; i < other.size; i++) element_set[i] = other.int_set[i];
            this->int_set = element_set;
            this->char_set = nullptr;
 
            if (!is_sorted)
            {
                Quick_sort(int_set, 0, *size - 1);
                *is_sorted = 1;
            }
        }
        else if (type_ == 2)
        {
            for (int i = 0; i < other.size; i++) element_set[i] = other.char_set[i];
            this->char_set = element_set;
            this->int_set = nullptr;
 
            if (!is_sorted)
            {
                Quick_sort(char_set, 0, *size - 1);
                *is_sorted = 1;
            }
        }
        return *this;
    }
 
    ~Set() // Деструктор
    {
        delete[] int_set;
        delete[] char_set;
    }
 
    //Set operator +(Set &other)
    //{
    //  Set *new_set = new Set(1);
    //  new_set = this;
    //  *new_set = *this;
    //  if (type_ == 1) new_set->insert(other.int_set, other.size);
    //  return *new_set;
    //}
 
 
    
    Set friend operator +(Set l, Set r)
    {
        if (type_ == INT)
        {
            Set result(1);
            result = l;
 
            int counter = 0;
            for (int i = 0; i < r.size; i++)
            {
                if (l.contains(r.int_set[i])) counter++;
            }
            int new_size = l.size + r.size - counter;
            result.size = new_size;
            result.insert(r.int_set);
 
 
            return result;
        }
    }
 
    //for (int i = 0; i < l.size; i++) 
//  if (l.contains(r.int_set[i])) 
//      result.insert(r.int_set[i]);
 
    //Set friend operator +(Set l, Set r) // Операция объединения двух множеств
    //{
    //  Set Temp(1);
    //  if(type_ == INT)
    //  {
    //      Temp.int_set = new int[l.size];
    //      for (int i = 0; i < l.size; i++)
    //      {
    //          Temp.int_set[i] = l.int_set[i];
    //      }
    //      l.insert(r.int_set, r.size);
    //  }
 
        //Temp.size = l.size + r.size - find_numb_common();
 
    /*  return Temp;
    }*/
 
};
 
 
 
 
int main()
{
    setlocale(LC_CTYPE, "rus");
    //Set myset2{myset1}; // вызывается конструктор копирования
    //Set myset3 = myset1; // вызывается конструктор присваивания
 
    Set myset1;
    Set myset2;
    Set myset3 = myset1+myset2;
 
 
    myset1.print();
    myset2.print();
    myset3.print();
    return 0;
}

/* 489 */ result.insert(r.int_set);