这个代码有很大的问题就是在继承这一方面做的不好，没有考虑继承的实际情况，实际上，如果写一个通归所有功能的大类，然后再让不同的对象去继承的话，存在一个问题，有的功能我实际生活中没法用也不应该用（比如普通用户没法删书删记录，但是管理员可以），那我继承过来不就违反了实际吗。所以继承不应该盲目，应该只把公有的公有的功能函数继承就可以了。自己独有的函数自己单独写。
代码里有不少心得体会和写这个代码时的思考点。
#include<bits/stdc++.h>
/*做这个系统的过程更让我体悟到了一句话：“没有调查，就没有发言权！”*/
using namespace std;
//可以只有基本数据参数，以后如果用到就初始化再压入容器中就可以了
//可以没有小时，因为图书馆看时间界限也是按天数
//不需要get set，因为时间数据不可修改，而且直接初始化即可
class Time
{
int year;
int month;
int day;
public:
Time()
{
year=0;
month=0;
day=0;
}
Time(int ye,int mo,int da):year(ye),month(mo),day(da) {}
friend bool operator-(Time &a,Time &b);
friend bool operator+(Time &a);
friend bool operator>(Time &a,Time &b);//友元函数直接访问
friend ostream&operator<<(ostream&os,const Time &date);
friend istream&operator>>(istream&is,Time &date);
};
/*不需要考虑年份小于的情况，道理很清楚，现在的年份总比你借书的年份晚吧*/
bool operator+(Time &a)//最简单的情况，年份没变
{
if(a.month+2<12)
return a.month+2;
}
bool operator-(Time &a,Time &b) //重载减号，可以判断闰年，用作以后的超期判断,
{
if(a.year>b.year)//情况太多了
{
if(a.year-(a.year/100)*100==0&&b.year-(b.year/100)*100==0)
{
if(a.year%400==0&&b.year%400==0)//这是个大特例，表示两年都是世纪闰年
{
if(a.month==2&&b.month!=2)
{
//这里就按别的月一个月30天
return 29-a.day+6*31+4*30+(b.month-2)*30+29+b.day+a.year-b.year-1;
}
}
if(a.year%400==0&&b.year%400!=0)
{
if(a.month==2&&b.month!=2)
{
//这里就按别的月一个月30天
return 29-a.day+6*31+4*30+(b.month-1)*30+b.day+(a.year-b.year-1)*365;
}
}
}
if(a.year%4==0&&a.year%100!=0||b.year%4==0&&b.year%100==0)
{
return (a.year-b.year-1)*364+(a.month-2)*30+29+a.day-(30-b.day+(12-b.month-2)*30+29);
}
else
{
return (a.year-b.year-1)*365+(a.month-1)*30+a.day-(30-b.day+(12-b.month-1)*30);
}
}
if(a.year==b.year)
{
return abs((a.month-1)*30+a.day-((b.month-1)*30+b.day));
}
}
bool operator>(Time &a,Time &b)
{
if(a.year>b.year)
{
return 1;
}
else if(a.year==b.year)
{
if(a.month>b.month)
return 1;
else if(a.month==b.month)
{
if(a.day>=b.day)
return 1;
}
}
}
ostream&operator<<(ostream&os,const Time &date)
{
os<<date.year<<" "<<date.month<<" "<<date.day;
return os;
}
istream&operator>>(istream&is,Time &date)
{
while(1)
{
is>>date.year>>date.month>>date.day;
if(date.year>1995||date.year<1945||date.month>12||date.month<1||date.day>31||date.day<0)
continue;
else
break;
}
return is;
}
/*
int main()
{
int a,b,c;
cin>>a>>b>>c;
Time d();
Time dd(a,b,c);
cout<<dd;
Time ddd;
cin>>ddd;
cout<<ddd;
}
*/
class BookInfo //书籍信息,
{
string title;//书名
string isbn;//书号
string publica;//出版社
string writer;//作者
int beijie;//该书借出了多少
int shengyu;//该书还剩多少
int chuyear;//出版年份,真的只有年份就够了，作用是核实所借书籍的有效性和丢失赔偿计算
public:
BookInfo()
{
title="0";
isbn="0";
publica="0";
writer="0";
beijie=0;
shengyu=10000;
chuyear=0;
}
BookInfo(string t,string i,string p,string w,int b,int s,int c):title(t),isbn(i),publica(p),writer(w),beijie(b),shengyu(s),chuyear(c) {}
string gettitle()
{
return title;
}
string getisbn()
{
return isbn;
}
string getpublica()
{
return publica;
}
string getwriter()
{
return writer;
}
int getbeijie()
{
return beijie;
}
int setbeijie(int beijie)
{
return this->beijie=beijie;
}
int getshengyu()
{
return shengyu;
}
int setshengyu(int shengyu)
{
return this->shengyu=shengyu;
}
int getchuyear()
{
return chuyear;
}
friend istream&operator>>(istream&is,BookInfo &book);
friend ostream&operator<<(ostream&os,BookInfo &book);
};
istream&operator>>(istream&is,BookInfo &book)
{
is>>book.title>>book.isbn>>book.publica>>book.writer>>book.beijie>>book.shengyu>>book.chuyear;
return is;
}
ostream&operator<<(ostream&os,BookInfo &book)
{
os<<book.title<<" "<<book.isbn<<" "<<book.publica<<" "<<book.writer<<" "<<book.beijie<<" "<<book.shengyu<<" "<<book.chuyear;
return os;
}
/*
int main()
{
string a,b,c,d;
int q,w,e;
cin>>a>>b>>c>>d>>q>>w>>e;
BookInfo g();
BookInfo bbb(a,b,c,d,q,w,e);
cout<<bbb;
}
*/
/*每次查询某个人的信息时，要显示这个人的借阅记录，弄一个文件，文件里存的是个人信息后面加上借阅信息，*/
class UserInfo //借阅人信息
{
//Record onere;//借阅人的信息里应当有记录
string name;
string id;
string major;
int nianji;
int yijie;//表示这个同学已经借了多少书
string mima;
int flag;//-1是冻结
public:
UserInfo()
{
name="0";
id="0";
major="0";
nianji=0;
yijie=0;
mima="000";
flag=1;
}
UserInfo(string na,string idd,string ma,int nj,int yj,string mma,int f):name(na),id(idd),major(ma),nianji(nj),yijie(yj),mima(mma),flag(f) {}
string getname()
{
return name;
}
string getid()
{
return id;
}
string getmajor()
{
return major;
}
string setmajor(string major)
{
return this->major=major;
}
int getnianji()
{
return nianji;
}
int getyijie()
{
return yijie;
}
int getflag()
{
return flag;
}
string getmima()
{
return mima;
}
string setmima(string mima)
{
this->mima=mima;
}
friend ostream&operator<<(ostream&os,UserInfo &user);
friend istream&operator>>(istream&is,UserInfo &user);
};
ostream&operator<<(ostream&os,UserInfo &user)
{
os<<user.name<<" "<<user.id<<" "<<user.major<<" "<<user.nianji<<" "<<user.yijie<<" "<<user.mima<<" "<<user.flag;
return os;
}
istream&operator>>(istream&is,UserInfo &user)
{
is>>user.name>>user.id>>user.major>>user.nianji>>user.yijie>>user.mima>>user.flag;
return is;
}
/*
int main()
{
string a,b,c,f;
int d,e,g;
cin>>a>>b>>c>>d>>e>>f>>g;
UserInfo ii();
UserInfo us(a,b,c,d,e,f,g);
cout<<us;
}
*/
/*判断超期，借了那么多书，每本个人的记录后面应当写着书的信
息、借阅时间、借还是还，通过判断借阅时间来判断是否超期，也就是要先
判断超期，若查到有本书超期了，那么就应当先还书，否则的话不可以借书。
续借的话借助时间类，续借自动加60天，通过函数计算出具体的年，月，日，再存入
*/
/*记录类我想只写书籍的信息和时间信息，因为当学生使用记录类时，查询的只是自己所借图书的信息以及它们对应的时间，
只是管理员能够看到所有同学信息罢了*/
/*有一个人就要开一个人的借阅记录，就要开文件，多个人要开多个*/
class Record //在查询某个用户的信息时输出记录类信息，也是通过下标哦,记录类里是用别的类的组合好呢，还是单个变量好？文件中的信息能够自动匹配类吗？
{
BookInfo boook;//用查询到的书籍信息初始化记录类（都存在与借书文件）
int year;//时间是自己输入（存在于借书文件），每本书对应的借阅时间，要想更好的判断超期，获取系统时间再与文件中的时间比对，若差值大于等与60天，超期
int month;
int day;
//int jieorhuan;//如果是借，标记为-1,如果是还，标记为1
public:
Record()
{
BookInfo boooke();
BookInfo boook("0","0","0","0",0,0,0);
year=0;
}
Record(BookInfo bf,int ye,int mo,int da):boook(bf),year(ye),month(mo),day(da) {}
BookInfo getboook()
{
return boook;
}
int getyear()
{
return year;
}
int getmonth()
{
return month;
}
int getday() //这个也可以实现续借功能
{
return day;
}
int setday(int day)
{
return this->day=day;
}
int setmonth(int month)
{
return this->month=month;
}
int setyear(int year)
{
return this->year=year;
}
friend istream&operator>>(istream&is,Record &rec);
friend ostream&operator<<(ostream&os,Record &rec);
};
istream&operator>>(istream&is,Record &rec)
{
is>>rec.boook>>rec.year>>rec.month>>rec.day;
return is;
}
ostream&operator<<(ostream&os,Record &rec)
{
os<<rec.boook<<" "<<rec.year<<" "<<rec.month<<" "<<rec.day;
return os;
}
/*
int main()
{
BookInfo bk();
Time te();
string a,b,c,d;
int q,w,e;
cin>>a>>b>>c>>d>>q>>w>>e;
BookInfo bo(a,b,c,d,q,w,e);
cout<<bo;
Time s();
int y,m,day;
cin>>y>>m>>day;
//Time tt(y,m,day);
Record re();
Record rec(bo,y,m,day);
cout<<rec;
}
*/
/*可以查询某个时间段的所有图书，方法：从文件中读取图书，因为图书信息有出版年份，
按照出版年份找出下标后再，下标不止一个，因为出版年份相同的图书可能不只一本，得先查multimap中数据个数*/
class GongnengIndex //作为被继承的基类对象
{
BookInfo bko;
Time te;
Record rec;/*很多人都出现了这个bug，那就是文件无法读取，明明有内容却显示没有内容*/
UserInfo ufoo;
bool flaggg;
//这些map存的都是图书馆里的全部图书，不是个人所借图书，个人所借图书在记录存着
multimap<string,int> shuming;
multimap<string,int>::iterator _shuming;
multimap<string,int> shuhao;
multimap<string,int>::iterator _shuhao;
multimap<string,int> chubanshe;
multimap<string,int>::iterator _chubanshe;
multimap<string,int> zuozhe;
multimap<string,int>::iterator _zuozhe;
multimap<string,int> xingming;
multimap<string,int>::iterator _xingming;
multimap<string,int> xuehao;
multimap<string,int>::iterator _xuehao;
multimap<string,int> zhuanye;
multimap<string,int>::iterator _zhuanye;
multimap<int,int> nianji;
multimap<int,int>::iterator _nianji;
vector<BookInfo> bookxx;
vector<BookInfo>::iterator _bookxx;
vector<UserInfo> userxx;
vector<UserInfo>::iterator _userxx;
/*multimap<Record,int> reco;
multimap<Record,int>::iterator _reco;*/
//以下为个人所借图书容器，上面那一坨是图书馆图书容器，查询书籍要通过上面的来
/*multi*/map<string,int> booktitle;
/*multi*/map<string,int>::iterator _booktitle;
/*multi*/map<string,int> bookisbn;
/*multi*/map<string,int>::iterator _bookisbn;
/*multi*/map<string,int> bookcbs;
/*multi*/map<string,int>::iterator _bookcbs;
/*multi*/map<string,int> bookzz;
/*multi*/map<string,int>::iterator _bookzz;
//个人vector
vector<BookInfo> onebookxx;
vector<BookInfo>::iterator _onebookxx;
vector<Record> jilu;
vector<Record>::iterator _jilu;
//后面查找可以用到的迭代器
multimap<string,int>::iterator it1;
multimap<string,int>::iterator it2;
multimap<int,int>::iterator itt1;
multimap<int,int>::iterator itt2;
public:
GongnengIndex() {}
~GongnengIndex()
{
flaggg=0;
/*savebook();
saveuser();
saverecord();
bookxx.clear();
userxx.clear();
jilu.clear();*/
}
//向各自的容器中压入新的信息，这是新的生机与活力
void addbook();
void adduser();
//通过书的不同信息来查
void inquirebyshuming();
void inquirebyshuhao();
void inquirebychubanshe();
void inquirebyzuozhe();
//通过人的不同信息来查
void inquirebyxingming(string xm);
void inquirebyxuehao(string xh);
void inquirebynianji(int nj);//多个人的信息+分别对应的借阅记录
void inquirebyzhuanye(string zy);//多个人的信息+分别对应的借阅记录
//续借：先把原有记录删除，再添加，用虚删，因为记录只读不写，只能这样，先删除
void inquirebydate();//通过一段时间查记录，查找一段时间内的记录
void borrow();//借，先判断超期
void returnn();//还完要删
void xujie();
void putallbookxx();//输出一个人的全部借阅记录
void putalluserxx();
void putallrecord();
void loadbook();//从书籍文件中导入
void loaduser();//从用户文件中导入
void loadrecord();//从记录文件中导入
void savebook();
void saveuser();
void saverecord();
};
//怎么虚删必须搞明白
void GongnengIndex::putallbookxx() //运行完之后就全没了，文件也没了
{
for(_bookxx=bookxx.begin(); _bookxx!=bookxx.end(); _bookxx++)
{
cout<<*_bookxx<<endl;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loadbook();
gd.putallbookxx();
}
*/
void GongnengIndex::putalluserxx() //管理员功能，输出一个人的全部信息同时，把这个人的所有借阅记录输出
{
for(_userxx=userxx.begin(); _userxx!=userxx.end(); _userxx++)
{
cout<<*_userxx<<endl;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loaduser();
gd.putalluserxx();
}
*/
void GongnengIndex::putallrecord() //这个功能是给用户看的，只是个人记录
{
for(_jilu=jilu.begin(); _jilu!=jilu.end(); _jilu++)
{
cout<<*_jilu<<endl;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loadrecord();
gd.putallrecord();
}
*/
void GongnengIndex::addbook() //向库中增加一本书，注意是库中，也许是图书馆又采购了
{
BookInfo bok;
cin>>bok;
bookxx.push_back(bok);
shuming.insert(make_pair(bok.gettitle(),bookxx.size()-1));
shuhao.insert(make_pair(bok.getisbn(),bookxx.size()-1));
chubanshe.insert(make_pair(bok.getpublica(),bookxx.size()-1));
zuozhe.insert(make_pair(bok.getwriter(),bookxx.size()-1));
ofstream outfile("book.txt",ios::app);
if(!outfile)
return ;
outfile<<endl<<bok;
outfile.close();
}
/*
int main()
{
GongnengIndex gd;
gd.addbook();
}
*/
void GongnengIndex::adduser() //最大的问题，将一个人的借阅记录和这个人连接起来
{
UserInfo people;
Record r1;
cin>>people;
userxx.push_back(people);
xingming.insert(make_pair(people.getname(),userxx.size()-1));
xuehao.insert(make_pair(people.getid(),userxx.size()-1));
zhuanye.insert(make_pair(people.getmajor(),userxx.size()-1));
nianji.insert(make_pair(people.getnianji(),userxx.size()-1));
ofstream outfile("user.txt",ios::app);
if(!outfile)
return ;
outfile<<endl<<people<<endl;
outfile.close();
}
/*
int main()
{
GongnengIndex gd;
gd.adduser();
}
*/
void GongnengIndex::inquirebyshuming()
{
string sm;
while(1)
{
cin>>sm;
it1=shuming.lower_bound(sm);//这个机制必须搞明白
it2=shuming.upper_bound(sm);
if(it1==it2)
continue;
_shuming=shuming.find(sm);
for(_shuming=it1; _shuming!=it2; _shuming++)
{
cout<<bookxx[_shuming->second]<<endl;
bko=bookxx[_shuming->second];
}
break;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loadbook();
gd.inquirebyshuming();
}
*/
void GongnengIndex::inquirebyshuhao()
{
string sh;
while(1)
{
cin>>sh;
it1=shuhao.lower_bound(sh);
it2=shuhao.upper_bound(sh);
_shuhao=shuhao.find(sh);
if(it1==it2)
continue;
for(_shuhao=it1; _shuhao!=it2; _shuhao++)
{
cout<<bookxx[_shuhao->second]<<endl;
bko=bookxx[_shuhao->second];//不能用到onebook里，因为编号问题，库中编号当然和个人记录下标编号不一致
}
break;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loadbook();
gd.inquirebyshuhao();
}
*/
void GongnengIndex::inquirebychubanshe()
{
string cbs;
while(1)
{
cin>>cbs;
it1=chubanshe.lower_bound(cbs);
it2=chubanshe.upper_bound(cbs);
if(it1==it2)
continue;
_chubanshe=chubanshe.find(cbs);
for(_chubanshe=it1; _chubanshe!=it2; _chubanshe++)
{
cout<<bookxx[_chubanshe->second]<<endl;
bko=bookxx[_chubanshe->second];
}
break;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loadbook();
gd.inquirebychubanshe();
}
*/
void GongnengIndex::inquirebyzuozhe()
{
string zz;
while(1)
{
cin>>zz;
it1=zuozhe.lower_bound(zz);
it2=zuozhe.upper_bound(zz);
if(it1==it2)
continue;
_zuozhe=zuozhe.find(zz);
for(_zuozhe=it1; _zuozhe!=it2; _zuozhe++)
{
cout<<bookxx[_zuozhe->second]<<endl;
bko=bookxx[_zuozhe->second];
}
break;
}
}
/*
int main()
{
GongnengIndex gd;
gd.loadbook();
gd.inquirebyzuozhe();
}
*/
void GongnengIndex::inquirebyxingming(string xm) //在查到人的信息的同时，输出他（她）的借阅记录,想到这里，有一个新思路，那就是用户文件里要包含记录
{
it1=xingming.lower_bound(xm);
it2=xingming.upper_bound(xm);
_xingming=xingming.find(xm);
for(_xingming=it1; _xingming!=it2; _xingming++)
{
cout<<userxx[_xingming->second]<<endl;
}
loadrecord();
putallrecord();
}
/*
int main()
{
GongnengIndex gd;
gd.loaduser();
gd.inquirebyxingming("王佳腾");
}
*/
void GongnengIndex::inquirebyxuehao(string xh)
{
it1=xuehao.lower_bound(xh);
it2=xuehao.upper_bound(xh);
_xuehao=xuehao.find(xh);
for(_xuehao=it1; _xuehao!=it2; _xuehao++)
{
cout<<userxx[_xuehao->second]<<endl;
}
loadrecord();
putallrecord();
}
/*
int main()
{
GongnengIndex gd;
gd.loaduser();
gd.inquirebyxuehao("2018212551");
}
*/
void GongnengIndex::inquirebyzhuanye(string zy)
{
it1=zhuanye.lower_bound(zy);
it2=zhuanye.upper_bound(zy);
_zhuanye=zhuanye.find(zy);
for(_zhuanye=it1; _zhuanye!=it2; _zhuanye++)
{
cout<<userxx[_zhuanye->second]<<endl;
}
loadrecord();
putallrecord();
}
/*
int main()
{
GongnengIndex gd;
gd.loaduser();
gd.inquirebyzhuanye("计算机");
}
*/
void GongnengIndex::inquirebynianji(int nj)
{
itt1=nianji.lower_bound(nj);
itt2=nianji.upper_bound(nj);
_nianji=nianji.find(nj);
for(_nianji=itt1; _nianji!=itt2; _nianji++)
{
cout<<userxx[_nianji->second]<<endl;
}
loadrecord();
putallrecord();
}
/*
int main()
{
GongnengIndex gd;
gd.loaduser();
gd.inquirebynianji(15);//文件老是会出现无法预料的bug，这方面还是要加强
}
*/
/*
void GongnengIndex::xujie(){//需要输入需要续借的书籍名
string bp;
cin>>bp;
Record rr;
jilu[shuming[bp]].setmonth()
}
*/
void GongnengIndex::borrow() //借之前要先判断
{
string chaxun;//借之前要先查询图书
string keeporstop;//还要存入相应的multimap里面
string thing;
int year;
int month;
int day;
cin>>year>>month>>day;
Time date(year,month,day);//当前时间
if(ufoo.getyijie()==10||jilu.size()==10)
{
cout<<"Please go to retrun book!"<<endl;
return ;
}
else
{
while(1)
{
//Time te(year,month,day);
cin>>chaxun;
if(chaxun=="shuming")
{
inquirebyshuming();
cin>>thing;
Record rec(bko,year,month,day/*,-1*/);
jilu.push_back(rec);
booktitle.insert(make_pair(bko.gettitle(),jilu.size()-1));
Time daat(jilu[booktitle[thing]].getyear(),jilu[booktitle[thing]].getmonth(),jilu[booktitle[thing]].getday());
if(date-daat>=30)
{
return ;
}
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
outfile<<rec<<endl;
outfile.close();
}
if(chaxun=="shuhao")
{
inquirebyshuhao();
Record rec(bko,year,month,day/*,-1*/);
jilu.push_back(rec);
bookisbn.insert(make_pair(bko.getisbn(),jilu.size()-1));
Time daat(jilu[bookisbn[thing]].getyear(),jilu[bookisbn[thing]].getmonth(),jilu[bookisbn[thing]].getday());
if(date-daat>=30)
{
return ;
}
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
outfile<<rec<<endl;
outfile.close();
}
if(chaxun=="chubanshe")
{
inquirebychubanshe();
Record rec(bko,year,month,day/*,-1*/);
jilu.push_back(rec);
bookcbs.insert(make_pair(bko.getpublica(),jilu.size()-1));
Time daat(jilu[bookcbs[thing]].getyear(),jilu[bookcbs[thing]].getmonth(),jilu[bookcbs[thing]].getday());
if(date-daat>=30)
{
return ;
}
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
outfile<<rec<<endl;
outfile.close();
}
if(chaxun=="zuozhe")
{
inquirebyzuozhe();
Record rec(bko,year,month,day/*,-1*/);
jilu.push_back(rec);
bookzz.insert(make_pair(bko.getwriter(),jilu.size()-1));
Time daat(jilu[bookzz[thing]].getyear(),jilu[bookzz[thing]].getmonth(),jilu[bookzz[thing]].getday());
if(date-daat>=30)
{
return ;
}
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
outfile<<rec<<endl;
outfile.close();
}
cin>>keeporstop;
if(keeporstop=="stop"||keeporstop=="STOP"||keeporstop=="Stop")
{
break;
}
else if(keeporstop=="keep"||keeporstop=="Keep"||keeporstop=="KEEP")
{
continue;
}
}
}
}
void GongnengIndex::returnn() /*记录直接vector删除，multmap虚删,别忘了加文件*/
{
/*在图书馆里，还书都是直接把书拿过去，管理员扫描书上粘的条形码，这里的条形码里包含的就是书的信息，扫描后，把用户记录里这本书的信息删除*/
/*没有书籍就没有还书这一说，所以根据书籍信息还书*/
/*没有调查，就没有发言权！*/
string xinxi,judge,keeporstop;
int num=0;
int year;
int month;
int day;
while(1)
{
cin>>year>>month>>day;
Time ti(year,month,day);
if(jilu.size()==num)
{
cout<<"Stop!You have returned enough books!"<<endl;
break;
}
cin>>judge;
if(judge=="shuming")
{
cin>>xinxi;
_booktitle=booktitle.find(xinxi);
jilu.erase(jilu.begin()+(_booktitle->second));
/*booktitle[]=-999;虚删标记,对于multimap，没法直接修改，只能先删除，再添加*/
/*map可以很轻松重置索引，但multimap很难*/
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
for(_jilu=jilu.begin(); _jilu!=jilu.end(); _jilu++)
{
outfile<<*_jilu<<endl;
}
num++;
}
if(judge=="shuhao")
{
cin>>xinxi;
_bookisbn=bookisbn.find(xinxi);
jilu.erase(jilu.begin()+(_bookisbn->second));
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
for(_jilu=jilu.begin(); _jilu!=jilu.end(); _jilu++)
{
outfile<<*_jilu<<endl;
}
num++;
}
if(judge=="chubanshe")
{
cin>>xinxi;
_bookcbs=bookcbs.find(xinxi);
jilu.erase(jilu.begin()+(_bookcbs->second));
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
for(_jilu=jilu.begin(); _jilu!=jilu.end(); _jilu++)
{
outfile<<*_jilu<<endl;
}
num++;
}
if(judge=="zuozhe")
{
cin>>xinxi;
_bookzz=bookzz.find(xinxi);
jilu.erase(jilu.begin()+(_bookzz->second));
ofstream outfile("record.txt",ios::app);
if(!outfile)
return ;
for(_jilu=jilu.begin(); _jilu!=jilu.end(); _jilu++)
{
outfile<<*_jilu<<endl;
}
num++;
}
cin>>keeporstop;
if(keeporstop=="stop"||keeporstop=="STOP"||keeporstop=="Stop")
{
break;
}
else if(keeporstop=="keep"||keeporstop=="Keep"||keeporstop=="KEEP")
{
continue;
}
}
}
void GongnengIndex::loadbook() //这样的函数就不测了吧
{
BookInfo babo;
ifstream infile("book.txt",ios::in);
if(!infile)
return ;
while(1)
{
if(infile.eof())
break;
infile>>babo;
bookxx.push_back(babo);
shuming.insert(make_pair(babo.gettitle(),bookxx.size()-1));
zuozhe.insert(make_pair(babo.getwriter(),bookxx.size()-1));
shuhao.insert(make_pair(babo.getisbn(),bookxx.size()-1));
chubanshe.insert(make_pair(babo.getpublica(),bookxx.size()-1));
}
infile.close();
}
void GongnengIndex::loaduser()
{
UserInfo usb;
ifstream infile("user.txt",ios::in);//数据文件在 d 盘根目录下
if(!infile)
return ;
while(1)
{
if(infile.eof())
break;
infile>>usb;
userxx.push_back(usb);
xingming.insert(make_pair(usb.getname(),userxx.size()-1));
xuehao.insert(make_pair(usb.getid(),userxx.size()-1));
zhuanye.insert(make_pair(usb.getmajor(),userxx.size()-1));
nianji.insert(make_pair(usb.getnianji(),userxx.size()-1));
}
infile.close();
}
void GongnengIndex::loadrecord()
{
Record recoo;
//BookInfo bk;
//Time te;
ifstream infile("record.txt",ios::in);
if(!infile)
return ;
while(1)
{
//cout<<5;
if(infile.eof())
break;
infile>>recoo;
jilu.push_back(recoo);
}
infile.close();
}
void GongnengIndex::savebook() //不需要对个人所借书籍再额外开一个文件，有记录就可以了
{
ofstream outfile("book.txt",ios::out);
if(!outfile)
return;
for(int i=0; i!=bookxx.size(); i++)
{
outfile<<bookxx[i]<<endl;
}
outfile.close();
}
void GongnengIndex::saverecord() //纯记录类，价值不大
{
ofstream outfile("record.txt",ios::out);
if(!outfile)
return;
for(int i=0; i!=jilu.size(); i++)
{
outfile<<jilu[i]<<endl;
}
outfile.close();
}
void GongnengIndex::saveuser() //这样一个用户文件就包含两个类，用户信息类和记录类,这个文件一般是管理员看
{
ofstream outfile("user.txt",ios::out);
if(!outfile)
return;
for(int i=0; i!=userxx.size(); i++)
{
outfile<<userxx[i]<<endl;
}
for(int i=0; i!=jilu.size(); i++)
{
outfile<<jilu[i]<<endl;
}
outfile.close();
}
class GuanliPort:public GongnengIndex //管理端写构造
{
public:
GuanliPort() {}
};
class UserPort:public GongnengIndex //用户端
{
UserInfo us;
public:
UserPort(UserInfo u):us(u)
{
}
};
/*登录说明:
1、请使用“我的图书馆”的用户名密码登录统一认证系统。
2、首次登录的读者：学生的账户为学号，初始密码为身份证号码后六位
（包含大写X），教工请务必到自助机刷卡获取证件号作为账户，初始密码为
身份证号码后六位（包含大写X），请务必尽快更改初始密码。
3、登录后可在“我的图书馆”中修改密码，本密码同时也是自助借书密码，*/
class Registerin:public GongnengIndex //登录端，多态
{
vector<UserInfo> uio;
vector<UserInfo>::iterator iter;
vector<BookInfo> bookxx;
map<string,int> use;
map<string,int>::iterator iter1;
map<string,int> shuming;
map<string,int> shuhao;
map<string,int> zuozhe;
map<string,int> chubanshe;
public:
Registerin()
{
loaduser();
loadbook();
}
~Registerin()
{
uio.clear();
use.clear();
}
void loaduser();
void loadbook();
void changemima();
void login();
};
void Registerin::loaduser()
{
UserInfo userr;
Record reccc;
int number;
ifstream infile("user.txt",ios::in);
if(!infile)
return ;
number=0;
uio.clear();
use.clear();
while(infile>>userr)
{
//iter1 = use.begin();
uio.push_back(userr);
use.insert(make_pair(userr.getid(),number));
//cout<<u1;
number++;
}
}
void Registerin::loadbook()
{
BookInfo babo;
ifstream infile("book.txt",ios::in);
if(!infile)
return ;
while(1)
{
if(infile.eof())
break;
infile>>babo;
bookxx.push_back(babo);
shuming.insert(make_pair(babo.gettitle(),bookxx.size()-1));
zuozhe.insert(make_pair(babo.getwriter(),bookxx.size()-1));
shuhao.insert(make_pair(babo.getisbn(),bookxx.size()-1));
chubanshe.insert(make_pair(babo.getpublica(),bookxx.size()-1));
}
infile.close();
}
void Registerin::login()
{
string zh,mim,changeornot;
for(int i=0; i<5; i++)
{
if(i==5)
break;
cin>>zh>>mim;
if(zh=="administrator"&&mim=="Bigbangtheworld")
{
GuanliPort gl;
//调用管理员菜单
gl.inquirebyshuming();
gl.inquirebyshuhao();
gl.inquirebychubanshe();
gl.inquirebyzuozhe();
gl.inquirebyxingming("王佳腾");
gl.inquirebyxuehao("2018212551");
gl.inquirebynianji(18);
gl.inquirebyzhuanye("计算机");
gl.putallrecord();
gl.putallbookxx();
gl.putalluserxx();
continue;
}
else
{
if((iter1=use.find(zh))!=use.end())
if(mim==uio[use[zh]].getmima()&&uio[use[zh]].getflag()!=-1)
{
cin>>changeornot;
if(changeornot=="YES"||changeornot=="Yes"||changeornot=="yes")
{
changemima();
continue;
}
UserPort uso(uio[use[zh]]);
//调用用户菜单
uso.inquirebyshuming();
uso.inquirebyshuhao();
uso.inquirebychubanshe();
uso.inquirebyzuozhe();
uso.putallrecord();
uso.putallbookxx();
uso.borrow();
uso.returnn();
break;
}
else if(uio[use[zh]].getflag())
continue;
}
}
}
void Registerin::changemima() //此函数实际情况下只能在登陆后使用
{
cout<<"please confirm it is your own operation!"<<endl;
string zhanghao,mimaa,houmi;
cin>>zhanghao>>mimaa;//旧密码
if(mimaa==uio[use[zhanghao]].getmima()&&uio[use[zhanghao]].getflag()!=-1)
{
cin>>houmi;
uio[use[zhanghao]].setmima(houmi);
ofstream outfile("user.txt",ios::out);
if(!outfile)
return ;
for(int i=0; i<uio.size(); i++)
{
outfile<<uio[i]<<endl;
}
//outfile<<uio[use[zhanghao]];
}
}
int main()
{
Registerin regis;
regis.login();
}