library management system simulation(first)

//************************************************************** // customer_exception.h // ************************************************************ #ifndef CUSTOMER_EXCEPTION_H_ #define CUSTOMER_EXCEPTION_H_ #include<stdexcept> #include<string> class customerException :public std::logic_error { public: customerException(const std::string &message=""): logic_error(message.c_str()) {} }; #endif

//*********************************************************** // book_exception.h //*********************************************************** #ifndef BOOK_EXCEPTION_H_ #define BOOK_EXCEPTION_H_ #include<stdexcept> #include<string> class bookException:public std::logic_error { public: bookException(const std::string &message=""): logic_error(message.c_str()) {} }; #endif

//******************************************************** // book_item.h implemention file---book_item.cpp //******************************************************** #ifndef BOOK_ITEM_H_ #define BOOK_ITEM_H_ #include<string> #include<iostream> #include<fstream> using namespace std; class bookItem { private: string title; string author; string ISBN; string publisher; string category; string custID; float price; int pages; //construtor function public: bookItem(const bookItem&_item); bookItem(); void createBookItem(); string getTitle()const; string getAuthor()const; string getISBN()const; string getPublisher()const; string getCategory()const; string getCustID()const; bool getStatus()const; void setCustID(const string &_custID); bookItem & getPtr(); void display()const; friend ifstream & operator>>(ifstream &fin,bookItem &_item); friend ofstream & operator<<(ofstream &fout,const bookItem &_item); }; #endif

//***************************************************************** // book_item.cpp book's information //***************************************************************** #include"book_item.h" #include<cstddef> using namespace std; bookItem::bookItem(const bookItem &_item) { title=_item.title; author=_item.author; ISBN=_item.ISBN; publisher=_item.publisher; category=_item.category; custID=_item.custID; price=_item.price; pages=_item.pages; } bookItem::bookItem() { title=""; author=""; ISBN=""; publisher=""; category=""; custID=""; price=0.0; pages=0; } void bookItem::createBookItem() { bool isok=false; char ch; while(!isok) { cout<<"\t\t\t create book item !"<<endl<<endl<<endl; cout<<" \t\t\tenter the book's title :"; getline(cin,title); cout<<"\n \t\t\tenter the book's author :"; getline(cin,author); cout<<"\n \t\t\tenter the book's ISBN :"; getline(cin,ISBN); cout<<"\n \t\t\tenter the book's publisher :"; getline(cin,publisher); cout<<"\n \t\t\tenter the book's category :"; getline(cin,category); cout<<"\n \t\t\tenter the book's price :"; cin>>price; while(cin.get()!='\n') ; cout<<"\n \t\t\tenter the book's pages :"; cin>>pages; while(cin.get()!='\n') ; cout<<endl<<endl<<endl; cout<<" \t\t\tbook information is ok !"<<endl; cout<<" \t\t\tS for Save And R for Reset :"; cin>>ch; while(cin.get()!='\n') ; if(ch=='S'||ch=='s') isok=true; } } string bookItem::getTitle()const { return title; } string bookItem::getAuthor()const { return author; } string bookItem::getISBN()const { return ISBN; } string bookItem::getPublisher()const { return publisher; } string bookItem::getCategory()const { return category; } string bookItem::getCustID()const { return custID; } bool bookItem::getStatus()const { if(custID.empty()) return false; else return true; } void bookItem::setCustID(const string &_custID) { custID=_custID; } bookItem & bookItem::getPtr() { return *this; } void bookItem::display()const { cout<<"********************************************************************************"<<endl<<endl; cout<<"**\t\tbook's title : "<<title<<endl; cout<<"**\t\tbook's author : "<<author<<endl; cout<<"**\t\tbook's ISBN : "<<ISBN<<endl; cout<<"**\t\tbook's publisher : "<<publisher<<endl; cout<<"**\t\tbook's category : "<<category<<endl; cout<<"**\t\tbook's price : $ "<<price<<endl; cout<<"**\t\tbook's pages : "<<pages<<endl; if(getStatus()) cout<<"\t\t\t\tthis book has been borrowed !"<<endl; else cout<<"\t\t\t\tthis book is still in lirary !"<<endl; cout<<"\n********************************************************************************"<<endl<<endl; } ifstream &operator>>(ifstream &fin,bookItem &_item) { if(fin.peek()=='\n') fin.ignore(1); getline(fin,_item.title,'~'); getline(fin,_item.author,'~'); getline(fin,_item.ISBN,'~'); getline(fin,_item.publisher,'~'); getline(fin,_item.category,'~'); if(fin.peek()=='~') { fin.ignore(1); _item.custID=""; } else getline(fin,_item.custID,'~'); fin>>_item.price>>_item.pages; return fin; } ofstream &operator<<(ofstream &fout,const bookItem &_item) { fout<<_item.title<<'~'<<_item.author<<'~'<<_item.ISBN<<'~'<<_item.publisher<<'~'<<_item.category <<'~'<<_item.custID<<'~'<<_item.price<<' '<<_item.pages<<endl; return fout; }

//************************************************************ // customer_item.h implemention file--customer_item.cpp //************************************************************ #ifndef CUSTOMER_ITEM_H_ #define CUSTOMER_ITEM_H_ #include<string> #include<iostream> #include<fstream> #include"book_tree.h" #include"book_item.h" using namespace std; class customerItem { private: static const int MAX=5; string name; string ID; string unit; string password; int numb; bookItem *books[MAX]; public: customerItem(); customerItem(const customerItem &_item); ~customerItem(); void createCustomerItem(); customerItem &operator=(const customerItem &_item); bookItem*& operator[](int index); void setPassword(const string &_str); string getPassword()const; string getID()const; void display()const;//attention void borrow(bookItem &_item); void revert(const string &_ISBN); ifstream& readCitem(ifstream &fin,bookTree &btree); friend ofstream &operator<<(ofstream &fout, customerItem &_item); }; #endif

//*************************************************************** // customer_item.cpp customer information //************************************************************** #include"customer_item.h" #include"book_item.h" customerItem::customerItem() { name=""; ID=""; unit=""; password=""; numb=0; for(int i=0;i<MAX;i++) { books[i]=NULL; } } customerItem::customerItem(const customerItem &_item) { name=_item.name; ID=_item.ID; unit=_item.unit; password=_item.password; numb=_item.numb; for(int i=0;i<numb;i++) books[i]=_item.books[i]; } customerItem::~customerItem() { } void customerItem::createCustomerItem() { bool isok=false; char ch; while(!isok) { cout<<"\t\t\tcreate new customer information !"<<endl<<endl<<endl; cout<<"\t\t\tenter the customer's name :"; getline(cin,name); cout<<"\n\t\t\tenter the customer's ID :"; getline(cin,ID); cout<<"\n\t\t\tenter the customer's unit :"; getline(cin,unit); cout<<"\a\n\n\t\t\t customer information is ok "<<endl<<endl; cout<<"\t\t S for Save or R for Reset :"; cin>>ch; while(cin.get()!='\n') ; if(ch=='s'||ch=='S') isok=true; } } customerItem &customerItem::operator=(const customerItem &_item) { if(this == &_item) return *this; else { name=_item.name; ID=_item.ID; unit=_item.unit; password=_item.password; numb=_item.numb; for(int i=0;i<numb;i++) books[i]=_item.books[i]; } return *this; } void customerItem::setPassword(const string &_str) { password=_str; } string customerItem::getPassword()const { return password; } string customerItem::getID()const { return ID; } void customerItem::display()const { cout<<"********************************************************************************"<<endl<<endl; cout<<"**\t\tthe customer's name :"<<name<<endl; cout<<"**\t\tthe customer's ID :"<<ID<<endl; cout<<"**\t\tthe customer's unit :"<<unit<<endl<<endl; if(numb==0) cout<<"\t\t\t you has borrowed 0 book !"<<endl; else { cout<<"\t\t\t you has borrow "<<numb<<" books ."<<endl; cout<<"\t\t\t\t AS follows :"<<endl; for(int i=0;i<numb;i++) books[i]->display(); } } void customerItem::borrow(bookItem &_item) { if(numb>=MAX) { cout<<"\a\a\a\t\t more than "<<MAX<<" books you have borrowed !\n"; cout<<"\t\t\t borrowing is canceled "<<endl<<endl; } else { _item.setCustID(ID); books[numb]=&(_item.getPtr()); numb++; cout<<"\t\t\t borrowing success !"<<endl<<endl; } } void customerItem::revert(const string &_ISBN) { int index=0; while(books[index]->getISBN()!=_ISBN && index<numb) { index++; } if(books[index]->getISBN()!=_ISBN) cout<<"\t\t\t you didnot borrow this book !"<<endl<<endl; else { int i; string tem=""; books[index]->setCustID(tem); for(i=index;i<numb-1;i++) { books[i]=books[i+1]; } books[i]=NULL; numb--; cout<<"\t\t\t revert book success !"<<endl<<endl; } } ofstream &operator<<(ofstream &fout, customerItem &_item) { fout<<_item.name<<'~'<<_item.ID<<'~'<<_item.unit<<'~'<<_item.password<<'~'<<_item.numb<<'~'; for(int i=0;i<_item.numb;i++) { fout<<_item[i]->getISBN()<<'~'; } fout<<endl; return fout; } ifstream& customerItem::readCitem(ifstream &fin, bookTree &_tree) { getline(fin,name,'~'); getline(fin,ID,'~'); getline(fin,unit,'~'); getline(fin,password,'~'); fin>>numb; if(fin.peek()=='~') fin.ignore(1); for(int i=0;i<numb;i++) { string temp; getline(fin,temp,'~'); books[i]=&(_tree.search(temp).getPtr()); } while(fin.get()!='\n') ; return fin; } bookItem *&customerItem::operator[](int index) { return books[index]; }

//************************************************************ // custoemr_node.h implemention file---customer_node.cpp //************************************************************ #ifndef CUSTOMER_NODE_H_ #define CUSTOEMR_NODE_H_ #include"customer_item.h" class customerNode { private: customerItem item; customerNode *leftchild; customerNode *rightchild; customerNode(); customerNode(const customerItem &_item,customerNode *leftPtr=NULL, customerNode *rightPtr=NULL); ~customerNode(); friend class customerTree; }; #endif

//***************************************************************** // customer_node.cpp binary's customer node //***************************************************************** #include"customer_node.h" customerNode::customerNode() { item=customerItem(); leftchild=rightchild=NULL; } customerNode::customerNode(const customerItem &_item,customerNode *leftPtr, customerNode *rightPtr):item(_item),leftchild(leftPtr),rightchild(rightPtr) {} customerNode::~customerNode() {}

//***************************************************************** // book_node.h implemention file---book_node.cpp //***************************************************************** #ifndef BOOK_NODE_H_ #define BOOK_NODE_H_ #include"book_item.h" class bookNode { private: bookItem item; bookNode *leftchild; bookNode *rightchild; explicit bookNode(); bookNode(const bookItem &_item,bookNode *leftPtr=NULL, bookNode *rightPtr=NULL); ~bookNode(); friend class bookTree; }; #endif

//**************************************************************** // book_node.cpp binary's book node //**************************************************************** #include"book_node.h" bookNode::bookNode() { item=bookItem(); leftchild=NULL; rightchild=NULL; } bookNode::bookNode(const bookItem &_item,bookNode *leftPtr,bookNode *rightPtr): item(_item),leftchild(leftPtr),rightchild(rightPtr) {} bookNode::~bookNode() {}

//**********************************************************
//             book_tree.h implemention file---book_tree.cpp
//**********************************************************
#ifndef BOOK_TREE_H_
#define BOOK_TREE_H_
#include<fstream>
#include<iostream>
#include<cstddef>
#include<string>
#include"book_node.h"
#include"book_exception.h"
using namespace std;
typedef void (*Function)(const bookItem &_item);
class bookTree
{
	private:
		bookNode *root;
		int amount;
	public:
		bookTree();
		bookTree(const bookItem &_item);
		~bookTree();
	

		bool isEmpty()const;
		int getAmount()const{return amount;}
		void insert(const bookItem &newitem)throw(bookException);
                void remove(const string &_ISBN)throw(bookException);
		void search(const string &_key,char & _type)const;
		bookItem & search(const string &_ISBN)throw(bookException);
		void traverse(Function  visit);
		void write(ofstream &fout);
		void read(ifstream &fin,int n);
	protected:
		void insertItem(bookNode*& treePtr,const bookItem &newItem)throw(bookException);
		void removeItem(bookNode *& treePtr,const string &_ISBN)throw(bookException);
		void removeNode(bookNode*& treePtr);
		void processLeft(bookNode*& treePtr,bookItem &_item);
		void destory(bookNode *  &_treePtr);
		void retrieveInorde(bookNode *const & treePtr,const string &_key,char &_type)const;
		bookItem & retrieveTree(bookNode * & treePtr,const string &_ISBN)throw(bookException);
	        void traverseItem(bookNode * & treePtr,Function  visit);
		void  writeItem(bookNode * & treePtr,ofstream &fout);
		void readItem(bookNode *& treePtr,ifstream &fin,int n);
};
#endif

//************************************************************** // book_tree.cpp search binary tree storing book items //************************************************************** #include<cassert> #include<cstdlib> #include<cstddef> #include"book_tree.h" bookTree::bookTree() { root=NULL; amount=0; } bookTree::bookTree(const bookItem &_item) { root=new bookNode(_item,NULL,NULL); assert(root!=NULL); amount=1; } bookTree::~bookTree() { destory(root); } bool bookTree::isEmpty()const { return (root==NULL); } void bookTree::insert(const bookItem &newitem)throw(bookException) { try{ insertItem(root,newitem); }catch(bookException &bexvept) { throw; } } void bookTree::remove(const string &_ISBN)throw(bookException) { try { removeItem(root,_ISBN); } catch(bookException &bexcept) { throw; } } void bookTree::search(const string &_key,char & _type)const { retrieveInorde(root,_key,_type); } bookItem & bookTree::search(const string &_ISBN)throw(bookException) { try{ return(retrieveTree(root,_ISBN)); } catch(bookException &cexcept) { throw; } } void bookTree::traverse(Function visit) { traverseItem(root,visit); } void bookTree::write(ofstream &fout) { writeItem(root,fout); } void bookTree::read(ifstream &fin,int n) { readItem(root,fin,n); } void bookTree::insertItem(bookNode *&treePtr,const bookItem &newitem) throw(bookException) { if(treePtr==NULL) { treePtr=new bookNode(newitem,NULL,NULL); if(treePtr==NULL) throw bookException("bookException :can't allocate memory in insert function !\a\a\a\a\a"); amount++; } else if((treePtr->item.getISBN())>newitem.getISBN()) insertItem(treePtr->leftchild,newitem); else insertItem(treePtr->rightchild,newitem); } void bookTree::removeItem(bookNode *& treePtr,const string &_ISBN)throw(bookException) { if(treePtr==NULL) throw bookException("bookException :delete the key book failed in remove function !\a\a\a\a\a"); else if(treePtr->item.getISBN()>_ISBN) removeItem(treePtr->leftchild,_ISBN); else if(treePtr->item.getISBN()==_ISBN) { removeNode(treePtr); amount--; } else removeItem(treePtr->rightchild,_ISBN); } void bookTree::removeNode(bookNode *& treePtr) { bookNode *delPtr; bookItem tempItem; if(treePtr->leftchild==NULL&&treePtr->rightchild==NULL) { delete treePtr; treePtr=NULL; } else if(treePtr->leftchild==NULL) { delPtr=treePtr; treePtr=treePtr->rightchild; delPtr->rightchild=NULL; delete delPtr; } else if(treePtr->rightchild==NULL) { delPtr=treePtr; treePtr=treePtr->leftchild; delPtr->leftchild=NULL; delete delPtr; } else { processLeft(treePtr->rightchild,tempItem); treePtr->item=tempItem; } } void bookTree::processLeft(bookNode *&treePtr,bookItem &_item) { if(treePtr->leftchild==NULL) { _item=treePtr->item; bookNode *tempPtr=treePtr; treePtr=treePtr->rightchild; tempPtr->rightchild=NULL; delete tempPtr; } else processLeft(treePtr->leftchild,_item); } void bookTree::destory(bookNode *&_treePtr) { if(_treePtr!=NULL) { destory(_treePtr->leftchild); destory(_treePtr->rightchild); delete _treePtr; _treePtr=NULL; amount--; } } void bookTree::retrieveInorde(bookNode *const & treePtr,const string &_key,char & _type)const { if(treePtr!=NULL) { if(_type=='T'||_type=='t') { retrieveInorde(treePtr->leftchild,_key,_type); if(treePtr->item.getTitle()==_key) { treePtr->item.display(); } retrieveInorde(treePtr->rightchild,_key,_type); } else if(_type=='A'||_type=='a') { retrieveInorde(treePtr->leftchild,_key,_type); if(treePtr->item.getAuthor()==_key) { treePtr->item.display(); } retrieveInorde(treePtr->rightchild,_key,_type); } else if(_type=='I'||_type=='i') { retrieveInorde(treePtr->leftchild,_key,_type); if(treePtr->item.getISBN()==_key) { treePtr->item.display(); } retrieveInorde(treePtr->rightchild,_key,_type); } else if(_type=='P'||_type=='p') { retrieveInorde(treePtr->leftchild,_key,_type); if(treePtr->item.getPublisher()==_key) { treePtr->item.display(); } retrieveInorde(treePtr->rightchild,_key,_type); } else if(_type=='C'||_type=='c') { retrieveInorde(treePtr->leftchild,_key,_type); if(treePtr->item.getCategory()==_key) { treePtr->item.display(); } retrieveInorde(treePtr->rightchild,_key,_type); } } } bookItem &bookTree::retrieveTree(bookNode *&treePtr,const string &_ISBN) throw(bookException) { if(treePtr==NULL) throw bookException("bookException :seek the key book failed in search function !\a\a\a\a\a"); else if(treePtr->item.getISBN()==_ISBN) return treePtr->item; else if(treePtr->item.getISBN()>_ISBN) retrieveTree(treePtr->leftchild,_ISBN); else retrieveTree(treePtr->rightchild,_ISBN); } void bookTree::traverseItem(bookNode *&treePtr,Function visit) { if(treePtr!=NULL) { traverseItem(treePtr->leftchild,visit); visit(treePtr->item); traverseItem(treePtr->rightchild,visit); } } void bookTree::writeItem(bookNode *&treePtr,ofstream &fout) { if(treePtr!=NULL) { writeItem(treePtr->leftchild,fout); fout<<treePtr->item; writeItem(treePtr->rightchild,fout); } } void bookTree::readItem(bookNode *&treePtr ,ifstream &fin,int n) { if(n>0) { treePtr=new bookNode(); readItem(treePtr->leftchild,fin,n/2); fin>>treePtr->item; amount++; readItem(treePtr->rightchild,fin,(n-1)/2); } }

//**************************************************************** // customer_tree.h implemention file---customer_tree.cpp //******************************************************************* #ifndef CUSTOMER_TREE_H_ #define CUSTOMER_TREE_H_ #include<string> #include<fstream> #include<iostream> #include<cstddef> #include"customer_node.h" #include"customer_exception.h" using namespace std; typedef void (*FunctionType)(const customerItem &_item); class customerTree { private: customerNode *root; int amount; public: customerTree(); customerTree(const customerItem &_item); ~customerTree(); int getAmount()const{return amount;} bool isEmpty()const; void insert(const customerItem &newitem)throw(customerException); void remove(const string &_ID)throw(customerException); customerItem & search(const string &_ID)throw(customerException); void traverse(FunctionType visit); void write(ofstream &fout); void read(ifstream &fin,int n, bookTree &_tree); protected: void insertItem(customerNode *&treePtr,const customerItem &newitem)throw(customerException); void removeItem(customerNode *&treePtr,const string &_ID)throw(customerException); void removeNode(customerNode *&treePtr); void processLeft(customerNode *&treePtr,customerItem &_item); void destory(customerNode *&treePtr); customerItem & retrieveTree(customerNode *&treePtr,const string &_ID)throw(customerException); void traverseItem(customerNode *&treePtr,FunctionType visit); void writeItem(customerNode *&treePtr,ofstream &fout); void readItem(customerNode *&treePtr,ifstream &fin,int n,bookTree &_tree); }; #endif
//************************************************************************ // customer_tree.cpp search binary tree storing customer items //************************************************************************ #include<cassert> #include<cstddef> #include"customer_tree.h" #include"book_tree.h" customerTree::customerTree() { root=NULL; amount=0; } customerTree::customerTree(const customerItem &_item) { root=new customerNode(_item,NULL,NULL); assert(root!=NULL); amount=1; } customerTree::~customerTree() { destory(root); } bool customerTree::isEmpty()const { return (root==NULL); } void customerTree::insert(const customerItem &newitem)throw(customerException) { try { insertItem(root,newitem); } catch(customerException &cExcept) { throw; } } void customerTree::remove(const string &_ID)throw(customerException) { try { removeItem(root,_ID); } catch(customerException &cexcept) { throw; } } customerItem &customerTree::search(const string &_ID)throw(customerException) { try{ return retrieveTree(root,_ID); } catch(customerException &cexcept) { throw; } } void customerTree::traverse(FunctionType visit) { traverseItem(root,visit); } void customerTree::read(ifstream &fin,int n,bookTree &_tree) { readItem(root,fin,n,_tree); } void customerTree::write(ofstream &fout) { writeItem(root,fout); } void customerTree::writeItem(customerNode *&treePtr,ofstream &fout) { if(treePtr!=NULL) { writeItem(treePtr->leftchild,fout); fout<<treePtr->item; writeItem(treePtr->rightchild,fout); } } void customerTree::readItem(customerNode *& treePtr,ifstream &fin,int n,bookTree &_tree) { if(n>0) { treePtr=new customerNode(); readItem(treePtr->leftchild,fin,n/2,_tree); treePtr->item.readCitem(fin,_tree); amount++; readItem(treePtr->rightchild,fin,(n-1)/2,_tree); } } void customerTree::insertItem(customerNode *&treePtr,const customerItem &newitem)throw(customerException) { if(treePtr==NULL) { treePtr= new customerNode(newitem,NULL,NULL); if(treePtr==NULL) throw customerException("customerException :allocate memory failed in insert function !\a\a\a\a\a"); amount++; } else if(treePtr->item.getID()>newitem.getID()) insertItem(treePtr->leftchild,newitem); else insertItem(treePtr->rightchild,newitem); } void customerTree::removeItem(customerNode *&treePtr,const string &_ID)throw(customerException) { if(treePtr==NULL) throw customerException("customerException :delete failed in remove function !\a\a\a\a\a"); else if(treePtr->item.getID()>_ID) removeItem(treePtr->leftchild,_ID); else if(treePtr->item.getID()==_ID) { removeNode(treePtr); amount--; } else removeItem(treePtr->rightchild,_ID); } void customerTree::removeNode(customerNode *&treePtr) { customerNode *delPtr; customerItem tempItem; if(treePtr->leftchild==NULL &&treePtr->rightchild==NULL) { delete treePtr; treePtr=NULL; } else if(treePtr->leftchild==NULL) { delPtr=treePtr; treePtr=treePtr->rightchild; delPtr->rightchild=NULL; delete delPtr; } else if(treePtr->rightchild==NULL) { delPtr=treePtr; treePtr=treePtr->leftchild; delPtr->leftchild=NULL; delete delPtr; } else { processLeft(treePtr->rightchild,tempItem); treePtr->item=tempItem; } } void customerTree::processLeft(customerNode *&treePtr,customerItem &_item) { if(treePtr->leftchild==NULL) { _item=treePtr->item; customerNode *delPtr=treePtr; treePtr=treePtr->rightchild; delPtr->rightchild=NULL; delete delPtr; } else processLeft(treePtr->leftchild,_item); } void customerTree::destory(customerNode *&treePtr) { if(treePtr!=NULL) { destory(treePtr->leftchild); destory(treePtr->rightchild); delete treePtr; treePtr=NULL; } } customerItem &customerTree::retrieveTree(customerNode *&treePtr,const string &_ID) throw(customerException) { if(treePtr==NULL) throw customerException("customerException :seek the key customer failed in search function !\a\a\a\a\a"); else if(treePtr->item.getID()>_ID) retrieveTree(treePtr->leftchild,_ID); else if(treePtr->item.getID()==_ID) return treePtr->item; else retrieveTree(treePtr->rightchild,_ID); } void customerTree::traverseItem(customerNode *&treePtr,FunctionType visit) { if(treePtr!=NULL) { traverseItem(treePtr->leftchild,visit); visit(treePtr->item); traverseItem(treePtr->rightchild,visit); } }