lista.h

#ifndef LISTA_H_INCLUDED
#define LISTA_H_INCLUDED

//#include "memtrace.h"

#define PR(x) std::cout << x << std::endl;
#define PR2(x, y) std::cout << x << y << std::endl;

//Generikus
template <typename Adattipus>
class Lista
{
    struct ListaElem
    {
        Adattipus adat;
        ListaElem* kov;
        ListaElem(Adattipus const &a) :adat(a), kov(NULL) {}
    };

    ListaElem* eleje;
    ListaElem* vege;
    size_t meret;

public:
    Lista() :eleje(NULL), vege(NULL), meret(0) {};
    Lista(Lista const &rhs) : eleje(NULL), vege(NULL), meret(rhs.meret)
    {

        if (rhs.eleje == NULL)
            return;
        else
        {
        PR("Lista copy");
            ListaElem *rhsmozgo = rhs.eleje;

            while(rhsmozgo != NULL)
            {
                this->Add(rhsmozgo->adat);
                rhsmozgo = rhsmozgo->kov;
            }
        }
    }

    Lista& operator=(const Lista& rhs)
    {
        if(this != &rhs)
        {
        PR2("===eleje:", eleje);
        PR2("rhshelyek: ", rhs.GetEleje());
            if (eleje != NULL)
                this->clear();
            ListaElem *rhsmozgo = rhs.eleje;

            while(rhsmozgo != NULL)
            {
                this->Add(rhsmozgo->adat);
                rhsmozgo = rhsmozgo->kov;
            }
            this->meret = rhs.meret;
            PR2("thiseleje:", this->GetEleje());
        }

            PR("ASD");
        return *this;
    }

    size_t const getSize() const {return meret;}
    bool const isNull() const {return eleje == NULL ? true : false;}
    ListaElem* GetEleje() const {return eleje;}

    void Add(Adattipus const &e)
    {
        ListaElem *uj = new ListaElem(e);

        if (eleje == NULL)
        {
            eleje = uj;
            vege = uj;
            meret++;
        }
        else
        {
            //PR2("\nEleje: ", eleje);
            /*PR2("Eleje-kov: ", eleje->kov);
            PR2("Vege: ", vege);
            PR2("Vege->kov: ", vege->kov);
            PR2("Uj: ", uj);*/
            vege->kov = uj;
            vege = vege->kov;
            /*PR2("Vege: ", vege);
            PR2("Vege->kov: ", vege->kov);
            PR("\n");*/
            meret++;
        }
    }

    void Remove(size_t idx)
    {
        if (idx >= meret)
            throw "Rossz index Remove!";
        ListaElem* mozgo = eleje;
        ListaElem* lemarado = eleje;

        if(idx == 0)
        {
            eleje = eleje->kov;
            delete mozgo;
            mozgo = eleje;
            lemarado = eleje;
            return;
        }

        for (size_t i = 0; i < idx; ++i)
        {
            lemarado = mozgo;
            mozgo = mozgo->kov;
        }
        lemarado->kov = mozgo->kov;
        delete mozgo;
    }

    Adattipus& operator[](size_t idx) const
    {
        if (idx >= meret)
            throw "Rossz index Lista[]!";
        //PR2("\nElejeELOTT: ", eleje);
        ListaElem* mozgo = eleje;
        //PR2("Eleje: ", eleje);
        for (size_t i = 0; i < idx; ++i)
            {
                /*PR2("\nEleje: ", eleje);
                PR2("Eleje->kov: ", eleje->kov);
                PR2("mozgo: ", mozgo);
                PR2("mozgo->kov: ", mozgo->kov);*/
                mozgo = mozgo->kov;
            }
        //PR2("ElejeKOV: ", eleje->kov);
        return mozgo->adat;
    }

    size_t Where(Adattipus const &e)
    {
        ListaElem* mozgo = eleje;

        for (size_t i = 0; mozgo != vege; mozgo = mozgo->kov)
        {
            if (mozgo->adat == e)
                return i;
        }
        return -1;
    }

    void clear()
    {
        PR2("this->getSize(): ", this->getSize());
        if(eleje == NULL || this->getSize() == 0)
            return;

        PR("\nLista dtor");
        ListaElem* mozgo = eleje;
        PR2("eleje:", eleje);
        //PR2("eleje kov:", eleje->kov);
        while(mozgo != NULL)
        {

            ListaElem* torlo = mozgo;
            PR2("vege:", vege);
            mozgo = mozgo->kov;

            PR2("Eppen itt:", mozgo);
            PR2("Eppen torlom:", torlo);
            PR2("torlo->kov:", torlo->kov);
            delete torlo;
        }
        eleje = NULL;
        vege = NULL;
        meret = 0;
    }

    virtual ~Lista() {clear();}
};


#endif // LISTA_H_INCLUDED