suma zbiorów, usuwanie elementu tablicy

Mam problem z zadaniem, które wydaje się być banalne. Mianowicie chodzi o stworzenie klasy Zbiór, a w niej umieścić metodę usuwającą element ze zbioru oraz metodę sumującą dwa zbiory. Dodatkowo metoda sumująca ma brać pod uwagę to, że jeśli dany element np. o wartości 3 znajduje się w zbiorze pierwszym i drugim, to w sumie pojawia się tylko raz.
Mam publiczne zmienne:
int *tab;
int miejsce;//zajmowane miejsce
int l_elementow;
int wartosc;

Napisałam następujące metody, ale nie działają.

void Zbior::usun(int wartosc){
     Zbior z = *this;
     for (int i=wartosc; i<l_elementow-1; i++){
              z[i]=z[i+1];      
              cout<<z.tab[i];
     }
                
} 

 Zbior & Zbior::operator+(const Zbior & z){
    Zbior nowy;
    Zbior zb;
    int wartosc;
    for(int i=0; i<20;i++){
            for(int j=0; j<20; j++){
                    while(z.tab[i]=zb.tab[j]){
                                            nowy.dolaczW(z.tab[i]);
                    }
                    while(z.tab[i] != zb.tab[j]){
                                         nowy.dolaczW(z.tab[i]);
                                         nowy.dolaczW(zb.tab[j]);
                    }
            }
    }
}

a także metodę dołączającą element do zbioru dolaczW():

 void Zbior::dolaczW(int wart){
     if(l_elementow==miejsce){
        int*temp=new int[2*miejsce];
        for(int i=0;i<miejsce;i++){
                temp[i]=tab[i];
        }
        miejsce*=2;
        delete[]tab;
        tab=temp;
     }  
     tab[l_elementow]=wart;
     l_elementow++;

}

Ktoś mi pomoże z tym, zapewne, drobiazgiem?

czy musisz korzystac z int *tab? Czy mozesz korzystac z gotowych klas?

1. Przydadzą Ci się metody wyszukujące wartość w zbiorze.

int Zbior::indeks(int wartosc) const
{
    for (int i = 0; i < l_elementow; ++i)
    {
        if (tab[i] == wartosc)
        {
            return i;
        }
    }
    return -1;
}

bool Zbior::jest(int wartosc) const
{
    return indeks(wartosc) != -1;
}

2. Taką instrukcją

Zbior z = *this;

tworzysz lokalną kopię zamiast operować na właściwym obiekcie klasy.

void Zbior::usun(int wartosc)
{
    int i = indeks(wartosc);
    if (i != -1)
    {
        for (int j = i; j + 1 < l_elementow; ++j)
        {
            tab[j] = tab[j + 1]; // przesuwanie elementow tablicy
        }
        --l_elementow;
    }
} 

3a. Nie możesz zwracać referencji do obiektu lokalnego.
3b. operator+ powinien zwracać obiekt, a nie referencję.
3c. Skąd wzięłaś magiczną liczbę 20?

Zbior Zbior::operator+(const Zbior &z) const
{
    Zbior nowy;
    for (int i = 0; i < l_elementow; ++i)
    {
        nowy.dolaczW(tab[i]);
    }
    for (int i = 0; i < z.l_elementow; ++i)
    {
        int w = z.tab[i];
        if (!nowy.jest(w))
        {
            nowy.dolaczW(w);
        }
    }
    return nowy;
}

4. Jeśli klasa ma przechowywać unikatowe wartości, to powinnaś to uwzględnić w metodzie dolaczW.

Dziękuję serdecznie za pomoc! :)
Niestety nie mogłam użyć std::set, ponieważ sama musiałam zaprojektować klasę Zbiór, ale dzięki Wam udało się ;)

A moglibyście mi jeszcze powiedzieć jak ewentualnie wyglądałby tutaj konstruktor kopiujący?

1. Konstruktor kopiujący.

Zbior::Zbior(const Zbior &z):
    tab(new int[z.miejsce]), miejsce(z.miejsce), l_elementow(z.l_elementow)
{
    for (int i = 0; i < z.l_elementow; ++i)
    {
        tab[i] = z.tab[i];
    }
}

2. Powinnaś też mieć operator=.

Zbior& Zbior::operator=(const Zbior &z)
{
    if (this != &z)
    {
        if (miejsce != z.miejsce)
        {
            delete[] tab;
            tab = new int[z.miejsce];
            miejsce = z.miejsce;
        }
        l_elementow = z.l_elementow;
        for (int i = 0; i < z.l_elementow; ++i)
        {
            tab[i] = z.tab[i];
        }
    }
    return *this;
}

3. Czy na pewno potrzebny Ci składnik klasy wartosc?

Dzięki wielkie :) operator= zaimplementowałam już wcześniej, a zmienna wartosc rzeczywiście jest zupełnie zbędna :) Dzięki jeszcze raz :)