template kolekcija

/*
template<class T1, class T2>
class Kolekcija{
T1 * _elementi1;
T2 * _elementi2;
int _trenutnoElemenata;
/*1. AddElement :: omogucava dodavanje novog elementa u kolekciju. Osigurati automatsko
prosiranje kolekcije prilikom dodavanja svakog novog elementa, te onemoguciti ponavljanje elemenata.
2. RemoveElement :: na osnovu parametra tipa T1 uklanja elemente iz kolekcije i smanjuje velicinu niza.
Ukoliko je potrebno, prilikom uklanjanja elementa izvrsiti dealokaciju. Prilikom uklanjanja elemenata ocuv
ati redoslijed njihovog dodavanja.
3. operator+ :: vraca objekat tipa Kolekcija koji u sebi sadrzi sve elemente objekta koji je
pozvao funkciju i objekta koji je proslijedjen kao parametar (takodjer tipa Kolekcija) , pri cemu se
elementi unutar kreirane kolekcije ne smiju ponavljati (ne smiju postojati dva ista elementa) .*/
};
*/

class Kolekcija{

    //potrebi su nam preklopljeni operatori
    //  =   ==   <<     []

    //////////////////////////////////////////////////////////////////////////////////////

    T1 * _elementi1;
    T2 * _elementi2;
    int _trenutnoElemenata;

    //////////////////////////////////////////////////////////////////////////////////////
public:
    Kolekcija(){
        _elementi1 = nullptr;
        _elementi2 = nullptr;
        _trenutnoElemenata = 0;
    }
    Kolekcija(const Kolekcija & obj){
        _trenutnoElemenata = obj._trenutnoElemenata;

        _elementi1 = new T1[_trenutnoElemenata];
        _elementi2 = new T2[_trenutnoElemenata];

        for (int i = 0; i < _trenutnoElemenata; i++){
            _elementi1[i] = obj._elementi1[i];
            _elementi2[i] = obj._elementi2[i];
        }
    }
    ~Kolekcija(){
            delete[]_elementi1;
            delete[]_elementi2;

            _elementi1 = nullptr;
            _elementi2 = nullptr;
            _trenutnoElemenata = 0;
    }

    //////////////////////////////////////////////////////////////////////////////////////
    void addElement(T1 element1, T2 element2){
        //1. AddElement :: omogucava dodavanje novog elementa u kolekciju. Osigurati automatsko
        //prosiranje kolekcije prilikom dodavanja svakog novog elementa, te onemoguciti ponavljanje elemenata.

        // provjera ima li elemenata u nizu
        for (int i = 0; i < _trenutnoElemenata; i++){
            // provjera nalaze li se elementi vec u nizu
            if (_elementi1[i] == element1 || _elementi2[i] == element2){
                //nalaze baciti exception
                throw exception("Element se vec nalazi u nizu!");
            }
        }

    // elementi se ne nalaze u nizu dodaj
        // kreiramo novi niz za 1 veci
        T1 * temp1 = new T1[_trenutnoElemenata + 1];
        T2 * temp2 = new T2[_trenutnoElemenata + 1];
        // prebaciti sve elemente
        for (int i = 0; i < _trenutnoElemenata; i++){
            temp1[i] = _elementi1[i];
            temp2[i] = _elementi2[i];
        }
        // osloboditi stare nizove
        delete[]_elementi1;
        delete[]_elementi2;

        // usmjeriti stare nizove na nove vece nizove
        _elementi1 = temp1;
        _elementi2 = temp2;

        // dodati elemente u kolekciju
        _elementi1[_trenutnoElemenata] =element1;
        _elementi2[_trenutnoElemenata] =element2;

        //uvecati brojac
        _trenutnoElemenata++;

    }
    void removeElement(T1 element){
        //2. RemoveElement::na osnovu parametra tipa T1 uklanja elemente iz kolekcije i smanjuje velicinu niza.
        //  Ukoliko je potrebno, prilikom uklanjanja elementa izvrsiti dealokaciju.Prilikom uklanjanja elemenata ocuvati redoslijed njihovog dodavanja.
        for (int i = 0; i < _trenutnoElemenata; i++){
            // pretrazuje nalazi li se element u kolekciji
            if (_elementi1[i] == element){
                // pronasao je element na poziciji i, ukloniti ga
                //delete _elementi1[i];
                //delete _elementi2[i];
                // uklonili smo element na toj poziciji, sada kopirati pok
                for (int j = i; j < _trenutnoElemenata-1; j++){
                    _elementi1[j] = _elementi1[j + 1];
                    _elementi2[j] = _elementi2[j + 1];
                }
                // uklonjen element i kopirani elementi da ne bude praznih mjesta u nizu
                // smanjiti trenutno
                _trenutnoElemenata--;
                // izaci iz funckije jer nema potrebe vise da pretrazujemo jer smo prilikom dodjele ogranicili da se elementi ne smije ponavljati
                return;

            }
        }
        // ukoliko se u for petlji nije pronasao elemnet baciti exception
        throw exception("Element nije moguce ukloniti iz kolekcije, jer se element ne nalazi u kolekciji!");
    }
    Kolekcija  operator +(const Kolekcija & k){
        //3. operator+ ::vraca objekat tipa Kolekcija koji u sebi sadrzi sve elemente objekta koji je
        //  pozvao funkciju i objekta koji je proslijedjen kao parametar(takodjer tipa Kolekcija), pri cemu se
        //  elementi unutar kreirane kolekcije ne smiju ponavljati(ne smiju postojati dva ista elementa)

        // pravimo kolekciju koja sadrzi elemente kolekcije koja je pozvala oeprator i kolekcije koja je u argumentu
        Kolekcija temp;
        // for petljom dodajemo elemente u temp kolekciju
        // isti elementi se nece dodavati jer je to rijeseno u funkciji addElement
        for (int i = 0; i < _trenutnoElemenata; i++){
            temp.addElement(_elementi1[i], _elementi2[i]);
        }
        // dodajemo elemente iz kolekcije koja se nalazi u argumentu
        for (int i = 0; i < k._trenutnoElemenata; i++){
            temp.addElement(k._elementi1[i], k._elementi2[i]);
        }
        // dodano sve vrati
        return temp;

        //// na 1 kolekciju dodati
        //T1 * temp1 = new T1[(_trenutnoElemenata + k._trenutnoElemenata)];
        //T2 * temp2 = new T2[(_trenutnoElemenata + k._trenutnoElemenata)];
        //// kopiramo iz prvog niza
        //for (int i = 0; i < _trenutnoElemenata; i++){
        //  temp1[i] = _elementi1[i];
        //  temp2[i] = _elementi2[i];
        //}
        //// kopiramo iz druog niza
        //for (int i = _trenutnoElemenata; i < (_trenutnoElemenata + k._trenutnoElemenata); i++){
        //  temp1[i] = k._elementi1[i];
        //  temp2[i] = k._elementi2[i];
        //}
        //// brisemo stari niz
        //delete[] _elementi1;
        //delete[] _elementi2;
        //
        //_elementi1 = temp1;
        //_elementi2 = temp2;

        //return *this;

    }
    void info(){
        cout << crt << "\tKOLEKCIJA\n" << crt;
        for (int i = 0; i < _trenutnoElemenata; i++){
            cout << _elementi1[i] << " - " << _elementi2[i] <<endl;
        }
        cout << crt;
    }

};