Покритикуйте код

#ifndef CSTUDENT_H
#define CSTUDENT_H
 
#include <iostream>
using std::ostream;
using std::istream;
 
#include <iomanip>
using std::setw;
using std::left;
 
#include <string>
using std::string;
 
class CStudent
{
    friend ostream &operator<<(ostream& os,const CStudent& stud);
    friend istream &operator>>(istream& is,CStudent& stud);
    void swap(CStudent &_v);
 
    //сравнивание на основании фамилии (sname)
    int cmp(const CStudent&, const CStudent&) const;
 
 
    string fname;
    string sname;
    string tname;
    string group;
    int year;
    float average;
 
 
public:
    CStudent(string ="",string ="",string ="",string ="",int =0,float =0);
    CStudent& operator=(const CStudent &_v);
 
    void setFname(string s){fname=s;}
    string getFname() const{return fname;}
    void setSname(string s){sname=s;}
    string getSname() const {return sname;}
    void setTname(string s){tname=s;}
    string getTname() const{return tname;}
    void setGroup(string g){group=g;}
    string getGroup() const{return group;}
    void setYear(int y){year=(y>=1950 && y<=2012 ? y : -1);}
    int getYear() const{return year;}
    void setAverage(float aver){average=(aver>=0 && aver<=100 ? aver : -1);}
    float getAverage() const{return average;}
 
 
    bool operator==(const CStudent &right) const;
    bool operator!=(const CStudent &right) const;
    bool operator>(const CStudent &right) const;
    bool operator>=(const CStudent &right) const;
    bool operator<(const CStudent &right) const;
    bool operator<=(const CStudent &right) const;
};
 
#endif

#include "CStudent.h"
 
CStudent::CStudent(string f,string s,string t,string gr,int y,float aver)
{
    fname=f;
    sname=s;
    tname=t;
    group=gr;
    setAverage(aver);
    setYear(y);
}
 
void CStudent::swap(CStudent &_v)
{
    std::swap(fname,_v.fname);
    std::swap(sname,_v.sname);
    std::swap(tname,_v.tname);
    std::swap (group,_v.group);
    std::swap(year,_v.year);
    std::swap(average,_v.average);
}
 
int CStudent::cmp(const CStudent &s1, const CStudent &s2) const
{
    return (s1.fname.compare(s2.fname));
}
 
 
 
///////////////////////operator's/////////////////////////
 
CStudent& CStudent::operator=(const CStudent &_v)
{
    if(this != &_v)
     CStudent(_v).swap(*this);
    return *this;
}
 
bool CStudent::operator==(const CStudent &right) const
{
    return (cmp(*this,right)==0);
 
}
 
bool CStudent::operator!=(const CStudent &right) const
{
    return (cmp(*this,right)!=0);
 
}
 
bool CStudent::operator>(const CStudent &right) const
{
    return (cmp(*this,right)>0);
}
 
bool CStudent::operator>=(const CStudent &right) const
{
    return (cmp(*this,right)>=0);
}
 
bool CStudent::operator<(const CStudent &right) const
{
    return (cmp(*this,right)<0);
}
 
bool CStudent::operator<=(const CStudent &right) const
{
    return (cmp(*this,right)<=0);
}
 
ostream& operator<<(ostream& os,const CStudent& stud)
{
    os<<setw(8)<<left<<stud.fname
     <<setw(10)<<left<<stud.sname
     <<setw(12)<<left<<stud.tname
     <<setw(7)<<stud.group
     <<setw(5)<<stud.year
     <<setw(7)<<stud.average<<"\n";
 
     return os;
}
 
istream &operator>>(istream& is,CStudent& stud)
{
    int year, average;
    is>>stud.fname>>stud.sname>>stud.tname
     >>stud.group>>year>>average;
    if(is.fail())
     year=average=-1,is.clear();
 
    stud.setYear(year);
    stud.setAverage(average);
 
    return is;
}

#ifndef LIST_H
#define LIST_H
#include "CStudent.h"
#include "ListIterator.h"
 
class List
{
    struct ListItem
    {
        CStudent data;
        ListItem *Next;
        ListItem(const CStudent& first,ListItem *next=0){data=first;Next=next;};
    };
 
    ListItem *Head;
    ListItem *Tail;
 
public:
    friend class ListIterator<ListItem, CStudent>;
 
    typedef ListIterator<ListItem, CStudent> iterator;
 
    List(): Head(0), Tail(0){}
    List(const CStudent& stud);
    ~List(){this->deleteAll();}
 
 
    void addToTail(const CStudent&);
    void addToHead(const CStudent&);
 
 
    bool deleteFromHead();
    bool deleteFromTail();
    void deleteAll();
 
    void sort();
    ListIterator<ListItem,CStudent> findElement(CStudent &what); //поиск по всему списку
    ListIterator<ListItem,CStudent> findElement(CStudent &what, ListIterator<ListItem,CStudent> begin, ListIterator<ListItem,CStudent> end);//поиск с границами
    bool findAndDestroy(const CStudent& stud);
 
 
    ListIterator<ListItem,CStudent> begin()const {return ListIterator<ListItem,CStudent>(Head);}
    ListIterator<ListItem,CStudent> end() const {return ListIterator<ListItem,CStudent>(0);}
};
 
 
#endif

#include "List.h"
 
List::List(const CStudent& stud)
{
    Head=Tail=new ListItem(stud, 0);
}
 
void List::addToTail(const CStudent& right)
{
    if (Tail)
    {
        Tail->Next=new ListItem(right,0);
        Tail=Tail->Next;
    }
    else
     Head=Tail=new ListItem(right,0);
}
 
 
void List::addToHead(const CStudent& right)
{
    if (Head)
    {
        ListItem* temp=Head;
        Head=new ListItem(right,temp);
        Head->Next=temp;
    }
    else
        Head=Tail=new ListItem(right,0);
}
 
bool List::deleteFromHead()
{
    if(!Head) //удалять нечего
     return false;
 
    ListItem *temp=Head;
    Head=Head->Next;
    if(Head=NULL)
     Tail=NULL;
    delete temp;
    return true;
}
 
bool List::deleteFromTail()
{
    if(!Tail)//удалять нечего
     return false;
 
    else if(Tail==Head)//только один элемент
    {
        delete Tail;
        Head=Tail=NULL;
        return true;
    }
    ListItem *temp=Head;
    while(temp->Next!=Tail)//найти новый хвост
     temp=temp->Next;
 
    ListItem *toDelete=Tail;
    Tail=temp;
    temp->Next=0;
    delete toDelete;
    return true;
}
 
 
void List::deleteAll() // освободить память
{
    ListItem* temp;
    while(Head)
    {
        temp=Head;
        Head=Head->Next;
        delete temp;
    }
    Tail=Head=NULL;
}
 
void List:: sort()
{
    ListItem* new_begin=NULL;
    ListItem* new_end=NULL;
    ListItem* sprev=NULL;
 
    for(ListItem *scur=this->Head;scur!=NULL;scur=this->Head)
    {
        ListItem *smin=NULL;
        ListItem *sminprev=scur;
        CStudent min_elem=scur->data;
        for(ListItem *gp=scur->Next;gp!=NULL;gp=gp->Next)
        {
            if((gp->data)<=min_elem)
            {
                min_elem=gp->data;
                smin=gp;
                sprev=sminprev;
            }
            sminprev=gp;
        }
        if(smin==NULL)
        {
            smin=scur;
        }
        else if(smin==scur->Next)
        {
            scur->Next=scur->Next->Next;
        }
        else
        {
            sprev->Next=smin->Next;
        }
        if(new_begin!=NULL)
        {
            new_end->Next=smin;
            new_end=smin;
        }
        else
        {
            new_begin=smin;
            new_end=smin;
        }
        if(smin==this->Head)
         this->Head=smin->Next;
    }
    this->Head=new_begin;
    this->Tail=new_end;
 
}
 
bool List::findAndDestroy(const CStudent& stud)
{
    if(!Head)
     return false;
 
    ListItem *temp=Head;
    if(temp->data==stud) //если это первый элемент
    {
        this->deleteFromHead();
        return true;
    }
 
    ListItem* beforeTemp=temp;
    temp=temp->Next;
 
    while(temp)
    {
        if((temp->data==stud))
        {
             beforeTemp->Next=temp->Next;
             delete temp;
             return true;
        }
 
        beforeTemp=temp;
        temp=temp->Next;
    }
 
    return false;//такого элемента нет в списке
}
 
ListIterator<List::ListItem,CStudent> List::findElement(CStudent &what, ListIterator<ListItem,CStudent> begin, ListIterator<ListItem,CStudent> end)
{
    for(;begin!=end;++begin)
    {
        if ((*begin)==what)
         return begin;
    }
    //если ничего не найдено - вернуть итератор указывающий за конец списка (на NULL)
    return ListIterator<ListItem,CStudent>(NULL);
}
 
ListIterator<List::ListItem,CStudent> List::findElement(CStudent &what)
{
    return (this->findElement(what,this->begin(),this->end()));
}

#ifndef LISTITERATOR_H
#define LISTITERATOR_H
 
 
template<typename T, typename E>
class ListIterator
{
    T* current;
    public:
 
    ListIterator() {current=0;}
    ListIterator(T *elem){current=elem;}
    ListIterator(const ListIterator& right){current=right.current;}
 
    ListIterator& operator=(const ListIterator& ref);
    ListIterator& operator++();
    ListIterator operator++(int);
    bool operator==(const ListIterator& right) const;
    bool operator!=(const ListIterator& right) const;
    E& operator*();
    operator bool(){return current!=0;}
};
 
 
 
 
 
 
 
template<typename T, typename E>
ListIterator<T,E>& ListIterator<T,E>::operator++()
{
    if(*this)
     current=current->Next;
     return *this;
}
 
template<typename T, typename E>
ListIterator<T,E> ListIterator<T,E>::operator++(int)
{
    if(!(*this))
     return NULL;
     ListIterator<T,E> temp(*this);
    current=current->Next;
     return temp;
}
 
template<typename T, typename E>
bool ListIterator<T,E>::operator==(const ListIterator& right) const
{
    return (current==right.current);
}
 
template<typename T, typename E>
bool ListIterator<T,E>::operator!=(const ListIterator& right) const
{
    return !(*this==right);
}
 
template<typename T, typename E>
ListIterator<T,E>& ListIterator<T,E>::operator=(const ListIterator<T,E>& ref)
{
    current=ref.current;
    return *this;
}
 
template<typename T, typename E>
E& ListIterator<T,E>::operator*()
{
    if(*this)
     return current->data;
    else
     throw -1;
}
 
#endif

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
 
#include <windows.h>
#include "List.h"
 
 
int main()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    CStudent i("Иван","Иванов","Иванович","КС-09",1990,100);
    CStudent p("Петр","Петров","Петрович","КС-09",1991,99);
    CStudent s("Василий","Васильев","Васильевич","КС-09",1990,100);
    CStudent y("Ярослав","Ярый","Ярославович","КС-09",1990,100);
    List test;
 
    test.addToTail(p);
    test.addToHead(i);
    test.addToHead(s);
    test.addToHead(y);
    test.findAndDestroy(i);
    List::iterator it=test.findElement(i);
    if(it)
     cout<<*it;
 
    cout<<"Введите нового студента(имя, фамилия, отчество, группа, год, балл):\n";
    CStudent stud;
    cin>>stud;
    cout<<"Созданный студент:\n";
    cout<<stud;
    cout<<"добавлен в тестовый список.\n\n";
 
    test.addToHead(stud);
    test.sort();
    cout<<"Полный список студентов:\n";
    it=test.begin();
    while(it)
     cout<<*it++;
 
}