Generikus Bináris Fa

#include <iostream>
#include<fstream>
using namespace std;

template<class R> class fa;
template<class T>
class elem{
    friend class fa<T>;
    T adat;
    int hany;
    elem *left;
    elem *right;
public:
    elem(){}
    void preord(){
    if(this!=NULL)
        {
        adat.kiir();
        //cout<<adat;
        this->left->preord();
        this->right->preord();
        }
    }
    void torol(){
    if(this!=NULL)
    {
        if(this->left!=NULL)
            this->left->torol();
        if(this->right!=NULL)
            this->right->torol();
        delete this;
    }

    }
};
template<class R>
class fa{
    elem<R> first;
    public:
    fa(){
    first.left=NULL;
    first.right=NULL;
    first.hany=0;
    }
    void beszur(R& x)
    {
        int bale=2;
        elem<R> *q=&first;
        elem<R> *p=&first;

        if(q->hany!=0)
        {
            if(q->adat.compare(x)==1)
            {
                p=q->right;
                bale=0;
            }
            else if(q->adat.compare(x)==2)
            {
                p=q->left;
                bale=1;
            }
            if(bale==2)
                ++(q->hany);
            else
            {
                while(p!=NULL)
                    if(p->adat.compare(x)==1)
                    {
                        q=p;
                        p=p->right;
                        bale=0;
                    }
                    else if(p->adat.compare(x)==2)
                    {
                        q=p;
                        p=p->left;
                        bale=1;
                    }
                    else
                        break;

                if(p==NULL)
                {
                    if(bale)
                    {
                        q->left=new elem<R>;
                        p=q->left;
                    }
                    else
                    {
                        q->right=new elem<R>;
                        p=q->right;
                    }
                    p->adat=x;
                    p->hany=1;
                    p->left=NULL;
                    p->right=NULL;
                }
                else
                    ++(p->hany);
            }
        }
        else
        {
            first.adat=x;
            first.hany=1;
        }
    }
    void preorder()
    {
        elem<R> *p=&first;
        p->preord();
    }
};

class Serialize{
public:
virtual void write(ostream &os) const=0;
virtual void read(istream &is)=0;
virtual ~Serialize(){}

};
template <class T>
class PFa: public Serialize, public fa<T>
{
    public:
    void write(ostream &os) const
    {

        //ide jön majd a fajlba iras
    }

    void read(istream &is)
    {
        //ide jön majd a vissza olvasas
    }

    ~PFa()
    {

    }
};

class student{
    string nev;
    string neptun;
    public:
    student(){}
    student(string nev, string neptun) :nev(nev), neptun(neptun){
    }
    int compare(student kivel)
    {
        if(neptun<kivel.neptun)
            return 1;
        else if(neptun>kivel.neptun)
            return 2;
        else return 0;
    }

    student operator=(student ki)
    {
        nev=ki.nev;
        neptun=ki.neptun;

        return ki;
    }

    void kiir()
    {
        cout<<"Nev: "<<nev<<" Neptun: "<<neptun<<endl;
    }
    ~student(){}
};

class szamok{
    int szam;

    public:
    szamok(){}
    szamok(int be) :szam(be){}
    int compare(szamok mivel){
    if(szam<mivel.szam)
        return 1;
    else if(szam>mivel.szam)
        return 2;
    else return 0;
    }
    szamok operator=(szamok mi)
    {
        szam=mi.szam;

        return mi;
    }
    void kiir()
    {
        cout<<"Szam: "<<szam<<endl;
    }
    ~szamok(){}

};


int main()
{
    //fa<student> y;
    PFa<szamok> x;
    ofstream f1;
    f1.open("mentes.txt");

  /* y.beszur(*(new student("dsfdsf","KSDFGH")));
   y.beszur(*(new student("dsfdsf","XFDFDF")));
   y.beszur(*(new student("dsfdsf","CVDFDF")));*/
   x.beszur(*(new szamok(32)));
   x.beszur(*(new szamok(25)));
   x.beszur(*(new szamok(45)));
   x.beszur(*(new szamok(12)));
  //y.beszur(*(new int(22)));
    //y.preorder();
    x.preorder();
    x.write(f1);
    f1.close();
    return 0;
}