Программа с шаблоном

#ifndef _BOOKS_
#define _BOOKS_
 
#include <string.h>
#include <iostream>
 
using namespace std;
 
#pragma warning (disable:4267)
#pragma warning (disable:4996)
 
#define LENGTH_DEFAULT      0x20
 
class CString;
class CBook;
template <class Item>
class CIterator;
template <class Item>
class CList;
 
class CString
{
protected:
    char * pStr;
    unsigned short uBufSize;
public:
    CString();
    CString(char *);
    CString(CString &);
    ~CString();
 
    void AllocBuffer(unsigned short);
    operator char * ();
    CString & operator + (char *);
    void operator += (char *);
    void operator = (char *);
    bool operator == (char *);  
    bool operator > (char *);
    bool operator < (char *);
    bool operator <= (char *);
    bool operator >= (char *);
};
 
class CBook
{
protected:
    CString sTitle;
    CString sAuthor;
    float fPrice;   
    unsigned short uYear;
public:
    CBook();
    CBook(CBook &);
    CBook(CString & title, CString & author, float price, unsigned short year); //куча конструкторов
    ~CBook();
 
    CString & Title();
    void Title(CString &);
    CString & Author();
    void Author(CString &);
    float Price();
    void Price(float);
    unsigned short Year();
    void Year(unsigned short);
    bool operator == (CBook &); 
};
 
template <class Item> class CList
{
public:
    CList * pPrev;
    CList * pNext;
    Item * pItem;
public:
    CList();
    ~CList();
    void Add(Item *, int (_cdecl *)(Item &, Item &));
    bool Remove(Item &);        
    CIterator<Item> & GetHead();    
    void Free();
};
 
template <class Item>
class CIterator
{
protected:
    CList<Item> * pHead;
    CList<Item> * pCurrent;
    unsigned short uID;
public:
    CIterator();
    CIterator(CList<Item> *);
    ~CIterator();
 
    Item & Data();
    bool GotoNext();
    bool GotoPrev();
    void Reset();
    unsigned short ID();
};
 
#endif

#include "books.h"
 
#define CMD_ADD             0x01
#define CMD_REMOVE          0x02
#define CMD_CHANGE          0x03
#define CMD_TITSORT         0x04
#define CMD_YEARSORT        0x05
#define CMD_PRICESORT       0x06
#define CMD_PRINT           0x07
 
void MenuProc();
void ShowMenu();
void Add(); 
void Remove();
void Change();
void TitSort();
void PriceSort();
void YearSort();
void Print();
void MenuProc();
int YearCmp(CBook &, CBook &);
int AuthorCmp(CBook &, CBook &);
int TitCmp(CBook &, CBook &);

#include "books.h"
#include "menu.h"
 
using namespace std;
 
CString::CString()
{
    this->pStr=new char [LENGTH_DEFAULT];
    this->uBufSize=LENGTH_DEFAULT;      //конструктор класса строк, размер буффера всегда кратен 32 байтам
    this->pStr[0]='\0';
    return;
}
 
CString::CString(char * str)
{
    unsigned short len=0;
 
    len=strlen(str);
    if((len % LENGTH_DEFAULT) == 0) this->uBufSize=len;
    else this->uBufSize=(unsigned short)(((len / LENGTH_DEFAULT)+1)*LENGTH_DEFAULT);    //ещё конструктор
    this->pStr=new char [this->uBufSize];
    strcpy(this->pStr, str);
    return;
}
 
CString::CString(CString & str)
{
    this->uBufSize=str.uBufSize;
    this->AllocBuffer(str.uBufSize);
    strcpy(this->pStr, str.pStr);
    return;
}
CString::~CString()
{
    delete [] this->pStr;
    this->pStr=0;
    this->uBufSize=0;           //и деструктор
    return;
}
 
void CString::AllocBuffer(unsigned short size) {    //распределить буффер
    unsigned short len=0;
    char * old=0;
 
    size++;
    len=strlen(this->pStr);
    if(len >= size) return;         //если новый размер меньше длины стрки, то возврат
    old=this->pStr;
    if((size % LENGTH_DEFAULT) == 0) this->uBufSize=size;
    else this->uBufSize=(unsigned short)(((size / LENGTH_DEFAULT)+1)*LENGTH_DEFAULT);
    this->pStr=new char [this->uBufSize];       //иначе перещитать размер буфера, перераспределить память, скопировать
    strcpy(this->pStr, old);
    delete [] old;
    return;
}
 
CString::operator char * ()
{   return this->pStr;  }       //оператор приведения в массив символьного тип
 
CString & CString::operator + (char * str)
{
    CString * res=0;
 
    res=new CString(* this);        //конкатенация с возвратом результата
    (* res) += str;
    return (* res);
}
 
void CString::operator += (char * str)
{
    unsigned short myLen=0, itLen=0;    //добавить к текущей строке ещё одну
    char * copy=0;
 
    itLen=strlen(str);
    myLen=strlen(this->pStr);
    if(this->uBufSize > (itLen+myLen)) strcat(this->pStr, str); //если буфер вмещает, копируем
    else {
        copy=new char [myLen+1];
        strcpy(copy, this->pStr);
        this->AllocBuffer(itLen+myLen);             //иначе перераспределяем и копируем
        strcpy(this->pStr, copy);
        strcat(this->pStr, str);
        delete [] copy;
    }
    return;
}
 
void CString::operator = (char * str)
{
    unsigned short len=0;
 
    len=strlen(str);
    if(this->uBufSize > len) strcpy(this->pStr, str);       //такие же манипуляции с буфером
    else {
        this->AllocBuffer(len);
        strcpy(this->pStr, str);
    }
    return;
}
bool CString::operator == (char * str)              //сравнения
{ return (strcmp(this->pStr, str) == 0); }
 
bool CString::operator > (char * str)
{   return (strcmp(this->pStr, str) == 1);  }
 
bool CString::operator < (char * str)
{   return (strcmp(this->pStr, str) == -1);  }
 
bool CString::operator >= (char * str)
{   return (strcmp(this->pStr, str) >= 0);  }
 
bool CString::operator <= (char * str)
{   return (strcmp(this->pStr, str) <= 0);  }
 
CBook::CBook()
{
    this->sAuthor="<unknown author>\0";     //конструктор заполняет поля значениями по умолчанию
    this->sTitle="<unknown title>\0";
    this->fPrice=0.0;
    this->uYear=1900;
    return;
}
 
CBook::CBook(CBook & book)
{
    this->sTitle=(char *)book.sTitle;
    this->sAuthor=(char *)book.sAuthor;         //конструктор-копировщик
    this->uYear=book.uYear;
    this->fPrice=book.fPrice;
    return;
}
CBook::CBook(CString & tit, CString & aut, float pr, unsigned short yr) //конструктор с параметрами
{
    this->sTitle=(char *)tit;
    this->sAuthor=(char *)aut;
    this->uYear=yr;
    this->fPrice=pr;
    return;
}
CBook::~CBook() //просто деструктор
{return;} 
 
CString & CBook::Title()        //последовательность гет-методов и сет-методов
{   return this->sTitle;    }
 
void CBook::Title(CString & tit)
{   this->sTitle=tit; return;   }
 
CString & CBook::Author()
{   return this->sAuthor;   }
 
void CBook::Author(CString & aut)
{   this->sAuthor=aut; return;  }
 
float CBook::Price()
{   return this->fPrice;    }
 
void CBook::Price(float pr)
{   this->fPrice=pr; return;    }
 
unsigned short CBook::Year()
{   return this->uYear;     }
 
void CBook::Year(unsigned short yr)
{   this->uYear=yr; return;     }
bool CBook::operator == (CBook & book)
{ return (this->fPrice == book.fPrice && this->uYear == book.uYear &&
            this->sAuthor == book.sAuthor && this->sTitle == book.sTitle);
}
 
 
void main()
{
    MenuProc();
}

#include "menu.h"
 
CList<CBook> * bookList=0;
unsigned short uBooks=0;
 
template <class Item>
CList<Item>::CList()
{
    this->pPrev=0;
    this->pNext=0;
    this->pItem=0;
    return;
}
 
template <class Item>
CList<Item>::~CList()   
{
    this->Free();
    return;
}
 
template <class Item>
void CList<Item>::Add(Item * it, int (_cdecl * cmp)(Item & it1, Item & it2))
{
    CList * cur=0, * prev=0, * addIt=0;
 
    if(this->pNext == 0){
        this->pNext=new CList;
        this->pNext->pItem=it;
        this->pNext->pNext=0;
        this->pNext->pPrev=0;
        return;
    }
    
    prev=0; cur=this->pNext;
    addIt=new CList();
    while((cur != 0) && (cmp(* it, * cur->pItem) > 0)){
        prev=cur;
        cur=cur->pNext;
    }
    addIt->pNext=cur;
    addIt->pPrev=prev;
    addIt->pItem=it;
    if(prev == 0) this->pNext=addIt;
        else prev->pNext=addIt;
    if(cur != 0) cur->pPrev=addIt;
    return;
}
 
template <class Item>
bool CList<Item>::Remove(Item & it)
{
    CList * cur=0, * prev=0;
 
    if(this->pNext == 0) return false;
    prev=0; cur=this->pNext;
    while((cur != 0) && !((* cur->pItem) == it)){
        prev=cur;
        cur=cur->pNext;
    }
    if(cur == 0) return false;
    if(cur->pPrev == 0){
        this->pNext=cur->pNext;
        if(this->pNext != 0)
            this->pNext->pPrev=0;
    }
    else {
        cur->pPrev->pNext=cur->pNext;
        if(cur->pNext != 0) cur->pNext->pPrev=cur->pPrev;
    }
    //delete cur->pItem;
    //delete cur;
    return true;
}
 
template <class Item>
CIterator<Item> & CList<Item>::GetHead()
{
    CIterator<Item> * res=0;
 
    res=new CIterator<Item>(this);
    return (* res);
}
 
template <class Item>
void CList<Item>::Free()
{
    CList<Item> * cur=0, * prev=0;
 
    if(this->pNext == 0) return;
    if(this->pNext->pNext == 0){
        delete this->pNext->pItem;
        this->pNext->pItem=0;
        delete this->pNext;
        return;
    }
    cur=this->pNext->pNext;
    prev=this->pNext;
    while(cur != 0)
    {
        delete prev->pItem;
        prev=cur;
        cur=cur->pNext;
    }
    return;
}
 
template <class Item>
CIterator<Item>::CIterator()
{
    this->pCurrent=0;
    this->pHead=0;
    this->uID=0;
    return;
}
 
template <class Item>
CIterator<Item>::CIterator(CList<Item> * lst)
{
    this->pHead=lst->pNext;
    this->pCurrent=lst->pNext;
    this->uID=1;
    return;
}
 
template <class Item>
CIterator<Item>::~CIterator()
{   return;     }
 
 
template <class Item>
Item & CIterator<Item>::Data()
{
    if(this->pCurrent != 0 && this->pCurrent->pItem != 0) return (* this->pCurrent->pItem);
    return (* new Item);
}
 
template <class Item>
bool CIterator<Item>::GotoNext()
{
    if(this->pCurrent == 0 || this->pCurrent->pNext == 0) return false;
    pCurrent=pCurrent->pNext;
    this->uID++;
    return true;
}
 
template <class Item>
bool CIterator<Item>::GotoPrev()
{
    if(this->pCurrent == 0 || this->pCurrent->pPrev == 0) return false;
    pCurrent=pCurrent->pPrev;
    this->uID--;
    return true;
}
 
template <class Item>
void CIterator<Item>::Reset()
{   
    this->pCurrent=this->pHead;
    this->uID=1;    
    return;
}
 
template <class Item>
unsigned short CIterator<Item>::ID()
{   return this->uID;   }
 
int YearCmp(CBook & b1, CBook & b2)
{   return b1.Year() - b2.Year();   }
 
int PriceCmp(CBook & b1, CBook & b2)
{   return (int)(b1.Price() - b2.Price());  }
 
int TitCmp(CBook & b1, CBook & b2)
{   return strcmp(b1.Title(), b2.Title());  }
 
void PrintMenu()
{
    cout<<"\t********** MENU **********\0"<<endl;
    cout<<CMD_ADD<<" - add a new book\0"<<endl;
    cout<<CMD_REMOVE<<" - remove existing book\0"<<endl;
    cout<<CMD_CHANGE<<" - change existing book data\0"<<endl;
    cout<<CMD_TITSORT<<" - sort list by title\0"<<endl;
    cout<<CMD_YEARSORT<<" - sort list by year\0"<<endl;
    cout<<CMD_PRICESORT<<" - sort list by price\0"<<endl;
    cout<<CMD_PRINT<<" - print the list\0"<<endl;
    cout<<"  any another to exit\0"<<endl;
    cout<<endl;
}
 
void Add()
{
    CString tit, aut;
    unsigned short year=0;
    float price=0;
 
    cout<<"   ***** Adding a book *****\0"<<endl;
    cout<<"Book's title: \0"; cin>>(char *)tit;
    cout<<"Book's author: \0"; cin>>(char *)aut;
    cout<<"Book's price: \0"; cin>>price;
    cout<<"Book's production year: \0"; cin>>year;
 
    bookList->Add(new CBook(tit, aut, price, year), YearCmp);
    uBooks++;
    return;
}
 
void Remove()
{
    CString tit;
    CIterator<CBook> iter=bookList->GetHead();
    
    if(uBooks == 0){
        cout<<"The list is empty!\0"<<endl;
        return;
    }
    cout<<"   ***** Removing a book *****\0"<<endl;
    cout<<"Enter book's title: \0"; cin>>(char *)tit;
    if(iter.Data().Title() == tit){
            bookList->Remove(iter.Data());
            return;
    }
    while(iter.GotoNext() == true)
        if(iter.Data().Title() == tit){
            bookList->Remove(iter.Data());
            uBooks--;
            return;
        }
    cout<<"Such book was not found!\0"<<endl;
}
void Change()
{
    CString tit, aut;
    unsigned short year=0;
    float price=0;
    CIterator<CBook> iter=bookList->GetHead();
    
    if(uBooks == 0){
        cout<<"The list is empty!\0"<<endl;
        return;
    }
    cout<<"   ***** Changing book's data *****\0"<<endl;
    cout<<"Current book's title: \0"; cin>>(char *)tit;
    if(iter.Data().Title() == tit){
            bookList->Remove(iter.Data());
            cout<<"New book's title: \0"; cin>>(char *)tit;
            cout<<"New book's author: \0"; cin>>(char *)aut;
            cout<<"New book's price: \0"; cin>>price;
            cout<<"New book's production year: \0"; cin>>year;
            bookList->Add(new CBook(tit, aut, price, year), YearCmp);
            return;
        }
    while(iter.GotoNext() == true)
        if(iter.Data().Title() == tit){
            bookList->Remove(iter.Data());
            cout<<"New book's title: \0"; cin>>(char *)tit;
            cout<<"New book's author: \0"; cin>>(char *)aut;
            cout<<"New book's price: \0"; cin>>price;
            cout<<"New book's production year: \0"; cin>>year;
            bookList->Add(new CBook(tit, aut, price, year), YearCmp);
            return;
        }
    cout<<"Such book was not found!\0"<<endl;
}
 
 
void TitSort()
{
    CIterator<CBook> iter=bookList->GetHead();
    CList<CBook> * newList=0;
 
    if(uBooks == 0){
        cout<<"The list is empty!\0"<<endl;
        return;
    }
    newList=new CList<CBook>;
    newList->Add(new CBook(iter.Data()), TitCmp);
    while(iter.GotoNext() == true)
        newList->Add(new CBook(iter.Data()), TitCmp);
    bookList->Free();
    bookList=newList;
    cout<<"   ***** List was sorted by title *****\0"<<endl;
    return;
}
 
void PriceSort()
{
    CIterator<CBook> iter=bookList->GetHead();
    CList<CBook> * newList=0;
 
    if(uBooks == 0){
        cout<<"The list is empty!\0"<<endl;
        return;
    }
    newList=new CList<CBook>;
    newList->Add(new CBook(iter.Data()), PriceCmp);
    while(iter.GotoNext() == true)
        newList->Add(new CBook(iter.Data()), PriceCmp);
    bookList->Free();
    bookList=newList;
    cout<<"   ***** List was sorted by price *****\0"<<endl;
    return;
}
 
void YearSort()
{
    CIterator<CBook> iter=bookList->GetHead();
    CList<CBook> * newList=0;
 
    if(uBooks == 0){
        cout<<"The list is empty!\0"<<endl;
        return;
    }
    newList=new CList<CBook>;
    newList->Add(new CBook(iter.Data()), YearCmp);
    while(iter.GotoNext() == true)
        newList->Add(new CBook(iter.Data()), YearCmp);
    bookList->Free();
    bookList=newList;
    cout<<"   ***** List was sorted by year *****\0"<<endl;
    return;
}
void Print()
{
    CIterator<CBook> iter=bookList->GetHead();
    
    if(uBooks == 0){
        cout<<"The list is empty!\0"<<endl;
        return;
    }
    cout<<"   ***** Books' list *****\0"<<endl;
    cerr<<iter.ID()<<". "<<iter.Data().Author()<<": \""<<iter.Data().Title()<<"\", "
        <<iter.Data().Year()<<"y., $"<<iter.Data().Price()<<endl;
    while(iter.GotoNext() == true){
        cerr<<iter.ID()<<". "<<iter.Data().Author()<<": \""<<iter.Data().Title()<<"\", "
            <<iter.Data().Year()<<"y., $"<<iter.Data().Price()<<endl;
    }
}
 
void MenuProc()
{
    unsigned short cmd=0, loop=0;
 
    bookList=new CList<CBook>;
    while(cmd <= CMD_PRINT)
    {
        if((loop % 0x08) == 0)
            PrintMenu();
        cout<<"Your choice: \0"; cin>>cmd;
        if(cmd == CMD_ADD) Add();
        else if(cmd == CMD_REMOVE) Remove();
        else if(cmd == CMD_CHANGE) Change();
        else if(cmd == CMD_TITSORT) TitSort();
        else if(cmd == CMD_PRICESORT) PriceSort();
        else if(cmd == CMD_YEARSORT) YearSort();
        else if(cmd == CMD_PRINT) Print();
        else cmd=CMD_PRINT+1;
        loop++;
        cout<<endl;
    }
}