Объявите класс Tintset

#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>
#include <random>
 
using namespace std;
 
class Tintset
{
private:
    int *  intset    = nullptr;
    size_t max_size = 10;
    void FillRandom(void);
    void Fill(void);
public:
    Tintset();
    Tintset(const size_t size);
    Tintset(const Tintset & cpyset);
    bool operator==(const Tintset & src) const;
    bool operator!=(const Tintset & src) const;
    Tintset & Union(const Tintset & src);
    void Print(void) const;
    void Input(void);
    ~Tintset();
};
 
int main  ()
{
    cout<<boolalpha;
    cout<<"ti1. Cоздание Tintset с конструктором по умолчанию"<<endl;
    Tintset ti1;
    ti1.Print();
 
    cout<<endl;
    cout<<"ti2. Cоздание Tintset конструктором с параметром размера и заполнением случайными числами"<<endl;
    Tintset ti2(10);
    ti2.Print();
 
    cout<<endl;
    cout<<"ti3. Cоздание Tintset конструктором копирования (из ti2)"<<endl;
    Tintset ti3(ti2);
    ti3.Print();
 
    cout<<endl;
    cout<<"сравнение на равенство множеств : "<<endl;
    cout<<"Множества ti2 и ti3 равны ? : "<< (ti2 == ti3) <<endl;
    cout<<"Множества ti1 и ti3 равны ? : "<< (ti1 == ti3) <<endl;
    cout<<endl;
    cout<<"Объединение ti1 и ti2"<<endl;
    ti1.Union(ti2);
    ti1.Print();
 
    // ручной ввод множества
    cout<<endl;
    Tintset ti4(3);
    ti4.Input();
 
    cout<<endl;
    ti4.Print();
 
    cout<<endl;
 
    system("pause");
}
 
void Tintset::FillRandom(void){
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<int> dist(0, 5);
    generate(&intset[0], &intset[max_size], [&dist, &gen]() -> int
            { return dist(gen); });
};
void Tintset::Tintset::Fill(void){
    for (size_t i=0; i<max_size; ++i)
        intset[i] = 0;
};
Tintset::Tintset(){
    intset = new int[max_size];
    this->Fill();
};
Tintset::Tintset(const size_t size) {
    if (size == 0)
        throw range_error("Out of range");
    max_size    = size;
    intset = new int[max_size];
    this->FillRandom();
};
 
Tintset::Tintset(const Tintset & cpyset){
    if (&cpyset != this && cpyset.intset != nullptr)
    {
        max_size = cpyset.max_size;
        intset = new int[max_size];
        memcpy(intset, cpyset.intset,sizeof(int)*max_size);
    }
};
// старое объединение
//Объединением множеств и называется множество , каждый элемент которого принадлежит множеству А или множеству Б :
/*Tintset & Tintset::Union(const Tintset & src){
    int * newset = new int[this->max_size + src.max_size];
    memcpy(newset, this->intset, sizeof(int)*max_size);
    memcpy(newset+this->max_size, src.intset, sizeof(int)*src.max_size);
    max_size = this->max_size + src.max_size;
    index = max_size - 1;
    delete [] intset;
    intset = newset;
    return *this;
};*/
Tintset & Tintset::Union(const Tintset & src){
    int * tmpset = new int[this->max_size + src.max_size];
    //cout<<"tmpsetsize - "<<this->max_size + src.max_size<<endl;
    int tmp_size = 0;
    int * ptr_tmp;
    int * ptr_this = this->intset;
    int * ptr_src = src.intset;
    bool is_in_set;
    while(ptr_this<&this->intset[this->max_size]) // для первого множества (this)
    {
        ptr_tmp = tmpset;
        is_in_set=false;
        while( ptr_tmp < (tmpset+tmp_size) )
        {
            if (*ptr_this==*ptr_tmp)
            {
                is_in_set = true;
                break;
            }
            ++ptr_tmp;
        }
        if (!is_in_set)
            tmpset[tmp_size++] = *ptr_this;
        ++ptr_this;
    }
 
    while(ptr_src<&src.intset[src.max_size]) // для второго множества (src)
    {
        ptr_tmp = tmpset;
        is_in_set=false;
        while( ptr_tmp < (tmpset+tmp_size) )
        {
            if (*ptr_src==*ptr_tmp)
            {
                is_in_set = true;
                break;
            }
            ++ptr_tmp;
        }
        if (!is_in_set)
            tmpset[tmp_size++] = *ptr_src;
        ++ptr_src;
    }
    //cout<<"tmpsetelements - "<<tmp_size<<endl;
    if (tmp_size<1)
    {
        intset = nullptr;
        max_size = 0;
        return *this;
    }
    int * fit_set = new int[tmp_size];
    memcpy(fit_set, tmpset, tmp_size*sizeof(int));
    delete [] intset;
    delete [] tmpset;
    intset = fit_set;
    max_size = tmp_size;
    return *this;
}
//Определение. Неупорядоченные множества равны, если они содержат одинаковый набор элементов.
bool Tintset::operator==(const Tintset & src) const
{
    if (this->max_size != src.max_size)
        return false;
    for(size_t i=0; i<max_size; ++i)
        if (intset[i]!=src.intset[i])
            return false;
    return true;
 
}
bool Tintset::operator!=(const Tintset & src) const
{
        return !this->operator==(src);
}
 
void Tintset::Print(void) const{
    if (!intset)
        return;
    int * ptr = intset;
    while(ptr != &intset[max_size])
    {
        cout<<*ptr<<'\t';
        ptr++;
    }
    cout<<endl;
};
 
 
void Tintset::Input(void)
{
    size_t i_count = 0;
    cout<<"Вы можете ввести "<< max_size<< " целых значений."<<endl;
 
    while (i_count<max_size)
    {
        cout<<"Введите " << i_count + 1 << " значение : ";
        cin>>intset[i_count];
        ++i_count;
    }
 
}
 
Tintset::~Tintset(){
    if (intset)
        delete [] intset;
};