程序设计——图书管理系统（附源代码）

图书管理系统（客户端）
数据类：

基础类：读者最大借书量、最长借书时间（按天计算）。这两个都是类成员    

日期类：包括年月日，重载输入运算符时，要进行数据的合法性检验；重载输出运算符时，按照“年/月/日”形式输出；重载+运算符；

借阅记录类：包括日期、书号、读者学号、类型（借出/还回/续借）、图书类型（基础/文学休闲/专业）；

读者类：学号、姓名、专业、班级、已借图书数量；    

图书类：书号、书名、作者、出版社、出版日期、图书类型（基础/文学休闲/专业）、馆藏总量、在馆数量；

操作类：

数据成员：图书向量、学生对象，当前日期

成员函数：带学生对象和当前日期的构造函数；
                  按书名、书号、出版社、出版日期查询图书；
                  按书名模糊查询图书；
                  按书名+作者、出版社+作者查询图书；
                  输入起止出版日期，查询指定时间段出版的图书；
                  按书号查询图书借阅情况；
                  按时间段/图书类型查询本人的借阅情况；                        
                  借书（输入书号，如果书库有这本书且本人借阅量不超限，办理借书手续（本人借书量加一、图书在库数量减一），对本人和书生成借阅记录）；
                  续借（内容基本同上）；
                  还书（内容类似）；
                  显示本人的图书借阅信

图书借阅操作类：
数据成员：借阅记录向量
成员函数：
构造函数、读写文件函数、析构函数；
各种查询；
追加记录

#include<iostream>
#include<string>
#include<cstring>
#include<vector>
#include<fstream>
#include<map>
#include<algorithm>
//#include <bits/stdc++.h>

using namespace std;

//基础类：读者最大借书量、最长借书时间（按天计算）。这两个都是类成员
class Base
{
private:
    static int book_max;
    static int day_max;
public:
    Base()
    {

    };
    ~Base();
    static int get_book_max()
    {
        return book_max;
    }
    static int get_day_max()
    {
        return day_max;
    }
};

int Base::book_max = 20;
int Base::day_max = 60;

//日前类：包括年月日，重载输入运算符时，要进行数据的合法性检验；重载输出运算符时，按照“年/月/日”形式输出；重载+运算符
class Date
{
private:
    int year;
    int month;
    int day;
public:
    friend ostream& operator<<(ostream& out, Date& d);
    friend istream& operator>>(istream& in, Date& d);
    Date operator+(int n);
    bool operator<(const Date& d) const;
    bool operator==(const Date& d) const;
    Date(int year, int month, int day = 1);
    Date();
    int get_year();
    int get_month();
    int get_day();
};

int Date::get_year()
{
    return year;
}

int Date::get_month()
{
    return month;
}
int Date::get_day()
{
    return day;
}
Date::Date()
{
    year = 2022;
    day = 1;
    month = 1;
}
Date::Date(int year, int month, int day)
{
    this->year = year;
    this->month = month;
    this->day = day;
}
Date Date::operator+(int n)
{
    int cal[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    while (n)
    {
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
            cal[2] = 29;
        day++;
        if (day > cal[month])
        {
            day = 1;
            month++;
        }
        if (month > 12)
        {
            month = 1;
            year++;
        }
        n--;
    }
    return *this;
}

bool Date::operator<(const Date& d) const
{
    if (year != d.year) return year <= d.year;
    else if (month != d.month) return month <= d.month;
    else return day <= d.day;
}

bool Date::operator==(const Date& d) const
{
    if (year == d.year && month == d.month && day == d.day)
        return true;
    return false;
}

ostream& operator<<(ostream& out, Date& d)
{
    out << d.year << "/" << d.month << "/" << d.day;
    return out;
}

istream& operator>>(istream& in, Date& d)
{
    int cal[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    int year, month, day;
    char op;
    in >> year >> op >> month >> op >> day;
    if ((year % 4 == 0 && year % 100 != 0 )|| year % 400 == 0)
        cal[2] = 29;
    if (month < 1 || month > 12)
    {
        return in;
    }
    else if (day < 1 || day > cal[month])
    {
        return in;
    }
    else {
        d.year = year;
        d.month = month;
        d.day = day;
    }
    return in;
}



//借阅记录类：包括日期、书号、读者学号、类型（借出/还回/续借）、图书类型（基础/文学休闲/专业）

class Record
{
private:
    Date Record_date;
    string Book_id;
    string Reader_id;
    string Record_type;
    string Book_type;
public:
    Record(Date Record_date, string Book_id, string Reader_id, string Record_type, string Book_type);
    Record() {
    }
    void set_Record_date(Date Record_date);
    void set_Book_id(string Book_id);
    void set_Reader_id(string Reader_id);
    void set_Record_type(string Record_type);
    void set_Book_type(string Book_type);
    Date get_Record_date() { return Record_date; }
    string get_Book_id();
    string get_Reader_id();
    string get_Record_type();
    string get_Book_type();
    friend ostream& operator<<(ostream& out, Record& d);
    friend istream& operator>>(istream& in, Record& d);
};

void Record::set_Record_date(Date Record_date)
{
    this->Record_date = Record_date;
}

void Record::set_Book_id(string Book_id)
{
    this->Book_id = Book_id;
}

void Record::set_Reader_id(string Reader_id)
{
    this->Reader_id = Reader_id;
}

void Record::set_Record_type(string Record_type)
{
    this->Record_type = Record_type;
}

void Record::set_Book_type(string Book_type)
{
    this->Book_type = Book_type;
}

string Record::get_Book_id()
{
    return Book_id;
}

string Record::get_Reader_id()
{
    return Reader_id;
}

string Record::get_Record_type()
{
    return Record_type;
}

string Record::get_Book_type()
{
    return Book_type;
}

Record::Record(Date Record_date, string Book_id, string Reader_id, string Record_type, string Book_type)
{
    this->Record_date = Record_date;
    this->Book_id = Book_id;
    this->Reader_id = Reader_id;
    this->Record_type = Record_type;
    this->Book_type = Book_type;
}
ostream& operator<<(ostream& out, Record& d)
{
    out << d.Record_date << " " << d.Book_id << " " << d.Reader_id << " " << d.Record_type << " " << d.Book_type << endl;
    return out;
}
istream& operator>>(istream& in, Record& d)
{
    in >> d.Record_date >> d.Book_id >> d.Reader_id >> d.Record_type >> d.Book_type;
    return in;
}


//读者类：学号、姓名、专业、班级、已借图书数量、借阅记录向量
class Reader
{
private:
    string Reader_id;
    string Reader_name;
    string Reader_major;
    string Reader_class;
    int Reader_book_num;
public:
    Reader(string Reader_id, string Reader_name, string Reader_major, string Reader_class, int Reader_book_num);
    Reader() {
    }
    void set_Reader_id(string Reader_id);
    void set_Reader_name(string Reader_name);
    void set_Reader_major(string Reader_major);
    void set_Reader_class(string Reader_class);
    void set_Reader_book_num(int Reader_book_num);
    string get_Reader_id();
    string get_Reader_name();
    string get_Reader_major();
    string get_Reader_class();
    int get_Reader_book_num();
    friend ostream& operator<<(ostream& out, Reader& r);
    friend istream& operator>>(istream& in, Reader& r);

};

Reader::Reader(string Reader_id, string Reader_name, string Reader_major, string Reader_class, int Reader_book_num)
{
    this->Reader_id = Reader_id;
    this->Reader_name = Reader_name;
    this->Reader_major = Reader_major;
    this->Reader_class = Reader_class;
    this->Reader_book_num = Reader_book_num;
}

void Reader::set_Reader_id(string Reader_id)
{
    this->Reader_id = Reader_id;
}

void Reader::set_Reader_name(string Reader_name)
{
    this->Reader_name = Reader_name;
}

void Reader::set_Reader_major(string Reader_major)
{
    this->Reader_major = Reader_major;
}

void Reader::set_Reader_class(string Reader_class)
{
    this->Reader_class = Reader_class;
}

void Reader::set_Reader_book_num(int Reader_book_num)
{
    this->Reader_book_num = Reader_book_num;
}

string Reader::get_Reader_id()
{
    return Reader_id;
}

string Reader::get_Reader_name()
{
    return Reader_name;
}

string Reader::get_Reader_major()
{
    return Reader_major;
}

string Reader::get_Reader_class()
{
    return Reader_class;
}

int Reader::get_Reader_book_num()
{
    return Reader_book_num;
}

ostream& operator<<(ostream& out, Reader& r)
{
    out << r.Reader_id << " " << r.Reader_name << " " << r.Reader_major << " " << r.Reader_class << " " << r.Reader_book_num << endl;
    return out;
}

istream& operator>>(istream& in, Reader& r)
{
    in >> r.Reader_id >> r.Reader_name >> r.Reader_major >> r.Reader_class >> r.Reader_book_num;
    return in;
}



//图书类：书号、书名、作者、出版社、出版日期、图书类型（基础/文学休闲/专业）、馆藏总量、在馆数量
class Book
{
private:
    string Book_id;
    string Book_name;
    string Book_author;
    string Book_press;
    Date Book_date;
    string Book_type;
    int Book_Lib_sum;
    int Book_Lib_now;
public:
    Book() {}
    Book(string Book_id, string Book_name, string Book_author, string Book_press,
        Date Book_date, string Book_type, int Book_Lib_sum, int Book_Lib_now);
    string get_Book_id();
    string get_Book_name();
    string get_Book_author();
    string get_Book_press();
    Date get_Book_date();
    string get_Book_type();
    int get_Book_Lib_sum();
    int get_Book_Lib_now();
    void set_Book_id(string Book_id);
    void set_Book_name(string Book_name);
    void set_Book_author(string Book_author);
    void set_Book_press(string Book_press);
    void set_Book_date(Date Book_date);
    void set_Book_type(string Book_type);
    void set_Book_Lib_sum(int Book_Lib_sum);
    void set_Book_Lib_now(int Book_Lib_now);
    friend istream& operator >>(istream& in, Book& b);
    friend ostream& operator <<(ostream& out, Book& b);
};

string Book::get_Book_id()
{
    return Book_id;
}

string Book::get_Book_name()
{
    return Book_name;
}

string Book::get_Book_author()
{
    return Book_author;
}

string Book::get_Book_press()
{
    return Book_press;
}

Date Book::get_Book_date()
{
    return Book_date;
}

string Book::get_Book_type()
{
    return Book_type;
}

int Book::get_Book_Lib_sum()
{
    return Book_Lib_sum;
}

int Book::get_Book_Lib_now()
{
    return Book_Lib_now;
}

void Book::set_Book_id(string Book_id)
{
    this->Book_id = Book_id;
}

void Book::set_Book_name(string Book_name)
{
    this->Book_name = Book_name;
}

void Book::set_Book_author(string Book_author)
{
    this->Book_author = Book_author;
}

void Book::set_Book_press(string Book_press)
{
    this->Book_press = Book_press;
}

void Book::set_Book_date(Date Book_date)
{
    this->Book_date = Book_date;
}

void Book::set_Book_type(string Book_type)
{
    this->Book_type = Book_type;
}

void Book::set_Book_Lib_sum(int Book_Lib_sum)
{
    this->Book_Lib_sum = Book_Lib_sum;
}

void Book::set_Book_Lib_now(int Book_Lib_now)
{
    this->Book_Lib_now = Book_Lib_now;
}

Book::Book(string Book_id, string Book_name, string Book_author, string Book_press, Date Book_date,
    string Book_type, int Book_Lib_sum, int Book_Lib_now)
{
    this->Book_id = Book_id;
    this->Book_name = Book_name;
    this->Book_author = Book_author;
    this->Book_press = Book_press;
    this->Book_date = Book_date;
    this->Book_type = Book_type;
    this->Book_Lib_sum = Book_Lib_sum;
    this->Book_Lib_now = Book_Lib_now;
}

istream& operator>>(istream& in, Book& b)
{
    in >> b.Book_id >> b.Book_name >> b.Book_author >> b.Book_press >> b.Book_date >> b.Book_type >> b.Book_Lib_sum
        >> b.Book_Lib_now;
    return in;
}
ostream& operator<<(ostream& out, Book& b)
{
    out << b.Book_id << " " << b.Book_name << " " << b.Book_author << " " << b.Book_press << " " << b.Book_date
        << " " << b.Book_type << " " << b.Book_Lib_sum << " " << b.Book_Lib_now << endl;
    return out;
}


//借阅记录操作类
//借阅记录类：包括日期、书号、读者学号、类型（借出/还回/续借）、图书类型（基础/文学休闲/专业）
class Operate_record
{
private:
    vector<Record> record;
    multimap<string, int> record_book_id;
    multimap<string, int> record_reader_id;
    multimap<Date, int> record_date;
public:
    ~Operate_record()
    {
        record_write();
    }
    Operate_record()
    {
        record_read();
    }
    Operate_record(Record r)
    {
        record.push_back(r);
        record_read();
    }
    void record_read();
    void record_write();
    void record_add(Record& r);
    void selete_record_book_id(string n);
    void selete_record_reader_id(string n);
    void selete_record_date(Date& d);
    void selete_record_date_range(Date& d1, Date& d2);

    void record_show(Reader reader);

};

void Operate_record::record_read()
{
    Record record1;
    ifstream ifs("2020214380record.txt");
    if (!ifs)
        return;
    while (ifs >> record1)
    {
        record.push_back(record1);
        record_book_id.insert(make_pair(record1.get_Book_id(), record.size() - 1));
        record_reader_id.insert(make_pair(record1.get_Reader_id(), record.size() - 1));
        record_date.insert(make_pair(record1.get_Record_date(), record.size() - 1));
    }
    ifs.close();
}

void Operate_record::record_write()
{
    fstream ofs("2020214380record.txt", ios::out);
    vector<Record>::iterator it;
    for (it = record.begin(); it != record.end(); it++)
    {
        ofs << *it;
    }
    ofs.close();
}

void Operate_record::record_add(Record& r)
{
    record.push_back(r);
    record_book_id.insert(make_pair(r.get_Book_id(), record.size() - 1));
    record_reader_id.insert(make_pair(r.get_Reader_id(), record.size() - 1));
    record_date.insert(make_pair(r.get_Record_date(), record.size() - 1));
}

void Operate_record::selete_record_book_id(string n)
{

    multimap<string, int>::iterator i;
    pair<multimap<string, int>::iterator, multimap<string, int>::iterator> range;
    range = record_book_id.equal_range(n);
    for (i = range.first; i != range.second; i++)
    {
        cout << record[i->second] << endl;
    }
}

void Operate_record::selete_record_reader_id(string n)
{
    multimap<string, int>::iterator i;
    pair<multimap<string, int>::iterator, multimap<string, int>::iterator> range;
    range = record_reader_id.equal_range(n);
    for (i = range.first; i != range.second; i++)
    {
        cout << record[i->second] << endl;
    }
}


void Operate_record::selete_record_date_range(Date& d1, Date& d2)
{
    multimap<Date, int>::iterator it1, it2, it;
    it1 = record_date.lower_bound(d1);
    it2 = record_date.upper_bound(d2);
    for (it = it1; it != it2; it++)
    {
        cout << record[it->second];
    }
}


void Operate_record::selete_record_date(Date& d)
{


    multimap<Date, int>::iterator it;
    pair<multimap<Date, int>::iterator, multimap<Date, int>::iterator> range;
    range = record_date.equal_range(d);
    if (range.first == record_date.end()) return;
    it = range.first;
    do {
        cout << record[it->second];
    } while (it++ != range.second);

}

void Operate_record::record_show(Reader reader)
{
    multimap<string, int>::iterator i;
    for (i = record_reader_id.begin(); i != record_reader_id.end(); i++)
    {
        if(i->first == reader.get_Reader_id())
        {
            cout << record[i->second] << endl;
        }
    }
}

class Operate_book
{
private:
    vector<Book> book;
    multimap<string, int> map_book_id;
    multimap<string, int> map_book_name;
    multimap<string, int> map_book_press;
    multimap<Date, int> map_book_date;
    multimap<string, int> map_book_author;
public:
    Operate_book()
    {
        book_read();
    }
    ~Operate_book()
    {
        book_write();
    }
    Operate_book(Book b)
    {
        book.push_back(b);
        book_read();
    }
    void book_read();
    void book_write();
    int selete_book_id(string n);//书号
    void selete_book_name(string n);//书名
    void selete_book_press(string n);//出版社
    void selete_book_date(Date d);//日期
    void selete_book_date_range(Date d1, Date d2);
    void selete_book_name_vague(string n);//按书名模糊查询
    void selete_book_name_author(string book_name, string author_name);
    void selete_book_press_author(string book_press, string author_name);
    void borrow_book(string n, Reader reader, Date date_now);
    void book_renew(string n, Reader reader, Date date_now);
    void book_return(string n, Reader reader, Date date_now);

};

void Operate_book::book_read()
{
    Book book1;
    ifstream ifs("2020214380book.txt");
    if (!ifs)
        return;
    while (ifs >> book1)
    {
        book.push_back(book1);
        map_book_id.insert(make_pair(book1.get_Book_id(), book.size() - 1));
        map_book_name.insert(make_pair(book1.get_Book_name(), book.size() - 1));
        map_book_press.insert(make_pair(book1.get_Book_press(), book.size() - 1));
        map_book_author.insert(make_pair(book1.get_Book_author(), book.size() - 1));
        map_book_date.insert(make_pair(book1.get_Book_date(), book.size() - 1));
    }
    ifs.close();
}

void Operate_book::book_write()
{
    fstream ofs("2020214380book.txt");
    vector<Book>::iterator it;
    for (it = book.begin(); it != book.end(); it++)
    {
        ofs << *it;
    }
    ofs.close();
}


int Operate_book::selete_book_id(string n)
{
    multimap<string, int>::iterator it;
    it = map_book_id.find(n);
    if (it == map_book_id.end())
    {
        return -1;
    }
    else
    {
        cout << book[it->second] << endl;
        return it->second;
    }
}

void Operate_book::selete_book_name(string n)
{
    multimap<string, int>::iterator i;
    for (i = map_book_name.begin(); i != map_book_name.end(); i++)
    {
        if(i->first == n)
        {
            cout << book[i->second] << endl;
        }
    }
}


void Operate_book::selete_book_press(string n)
{
    multimap<string, int>::iterator i;
    for (i = map_book_press.begin(); i != map_book_press.end(); i++)
    {
        if(i->first == n)
        {
            cout << book[i->second] << endl;
        }
    }
}

void Operate_book::selete_book_date(Date d)
{
    multimap<Date, int>::iterator i;
    for (i = map_book_date.begin(); i != map_book_date.end(); i++)
    {
        if(i->first == d)
        {
            cout << book[i->second] << endl;
        }

    }

}

void Operate_book::selete_book_name_author(string book_name, string author_name)
{
    vector<int> book1;
    vector<int> book2;
    vector<int> v;

    multimap<string, int>::iterator it1, it2;
    for(it1 = map_book_name.begin(); it1 != map_book_name.end(); it1 ++)
    {
        if(it1->first==book_name)
        {
            book1.push_back(it1->second);
        }
    }
    for(it2 = map_book_author.begin(); it2 != map_book_author.end(); it2 ++)
    {
        if(it2->first==author_name)
        {
            book2.push_back(it2->second);
        }
    }
    set_intersection(book1.begin(), book1.end(), book2.begin(), book2.end(), insert_iterator<vector<int>>(v, v.begin()));

    vector<int>::iterator it;
    for(it=v.begin(); it!=v.end(); it++)
    {
        cout<<book[*it] <<endl;
    }
}


void Operate_book::selete_book_press_author(string book_press, string author_name)
{

    vector<int> book1;
    vector<int> book2;
    vector<int> v;

    multimap<string, int>::iterator it1, it2;
    for(it1 = map_book_press.begin(); it1 != map_book_press.end(); it1 ++)
    {
        if(it1->first==book_press)
        {
            book1.push_back(it1->second);
        }
    }
    for(it2 = map_book_author.begin(); it2 != map_book_author.end(); it2 ++)
    {
        if(it2->first==author_name)
        {
            book2.push_back(it2->second);
        }
    }
    set_intersection(book1.begin(), book1.end(), book2.begin(), book2.end(), insert_iterator<vector<int>>(v, v.begin()));

    vector<int>::iterator it;
    for(it=v.begin(); it!=v.end(); it++)
    {
        cout<<book[*it] <<endl;
    }
}

void Operate_book::borrow_book(string n, Reader reader, Date date_now)
{
    Operate_record op_record;
    multimap<string, int>::iterator it;
    it = map_book_id.find(n);
    if (it == map_book_id.end())
        return;
    else
    {
        if(book[it->second].get_Book_Lib_now() > 0 && reader.get_Reader_book_num() < Base::get_book_max())
        {
            reader.set_Reader_book_num(reader.get_Reader_book_num() + 1);
            book[it->second].set_Book_Lib_now(book[it->second].get_Book_Lib_now() - 1);
            //Date d = date_now + Base::get_day_max();
            Record r1(date_now, n, reader.get_Reader_id(), "借出", book[it->second].get_Book_type());
            op_record.record_add(r1);
        }
    }
}

void Operate_book::book_renew(string n, Reader reader, Date date_now)
{
    Operate_record op_record;
    multimap<string, int>::iterator it;
    it = map_book_id.find(n);
    if (it == map_book_id.end())
        return;
    else
    {
        if(book[it->second].get_Book_Lib_now() > 0 && reader.get_Reader_book_num() < Base::get_book_max())
        {
            Record r1(date_now, n, reader.get_Reader_id(), "续借", book[it->second].get_Book_type());
            op_record.record_add(r1);
        }
    }
}

void Operate_book::book_return(string n, Reader reader, Date date_now)
{
    Operate_record op_record;
    multimap<string, int>::iterator it;
    it = map_book_id.find(n);
    if (it == map_book_id.end())
        return;
    else
    {
        reader.set_Reader_book_num(reader.get_Reader_book_num() - 1);
        book[it->second].set_Book_Lib_now(book[it->second].get_Book_Lib_now() + 1);
        //Date d = date_now + Base::get_book_max();
        Record r1(date_now, n, reader.get_Reader_id(), "已还", book[it->second].get_Book_type());
        op_record.record_add(r1);
    }
}


void Operate_book::selete_book_name_vague(string n)
{
    vector<Book>::iterator it;
    for (it = book.begin(); it != book.end(); it ++)
    {
        if (it->get_Book_name().find(n) != string::npos)
        {
            cout << *it << endl;
        }
    }
}

void Operate_book::selete_book_date_range(Date d1, Date d2)
{
    multimap<Date, int>::iterator itbegin = map_book_date.upper_bound(d1);
	multimap<Date, int>::iterator itend = map_book_date.lower_bound(d2);
	if (itbegin == itend)
	{
		cout << "没找到" << endl;
	}
	else
	{
		for (multimap<Date, int>::iterator it = itbegin; it != itend; it++)
		{
			cout <<book[it->second];
		}
	}

}



class Operate
{
private:

    Reader reader;
    Date date_now;
public:
    Operate();
    ~Operate()
    {

    }
    Operate(Reader reader, Date date_now);
};

Operate::Operate(Reader reader, Date date_now)
{
    this->reader = reader;
    this->date_now = date_now;
}

void testDate()
{
    /*
      测试日前类：包括年月日，重载输入运算符时，要进行数据的合法性检验；重载输出运算符时，按照“年/月/日”
      形式输出；重载+运算符；
    */
    Date test1(2007, 4, 29);
    cout << test1 << endl;
    test1 = test1 + 365;
    cout << test1 << endl;
    cout << endl;
}

void testBook()
{
    // 测试图书类：书号、书名、作者、出版社、出版日期、图书类型（基础/文学休闲/专业）、馆藏总量、在馆数量、借阅记录向量；
    Book test4;
    Date test1(2022, 4, 29);
    Book b1("ISBN 978-5-455-5644-1-65", "数据结构", "严蔚敏", "清华大学出版社", test1, "专业", 10, 1);
    test4.set_Book_id("87692");
    test4.set_Book_name("老人与海");
    test4.set_Book_author("海明威");
    test4.set_Book_press("吉林出版社");
    test4.set_Book_date(test1);
    test4.set_Book_type("文学休闲");
    test4.set_Book_Lib_sum(10);
    test4.set_Book_Lib_now(5);

    cout << b1 << endl;
    cout << test4 << endl;
}


void testRecords()
{
    // 测试借阅记录类：包括日期、书号、读者学号、类型（借出/还回/续借）、图书类型（基础/文学休闲/专业）；
    Date test1(2022, 4, 29);
    Record test2;
    test2.set_Book_id("ISBN 978-7-115-56-033-5");
    test2.set_Book_type("文学休闲");
    test2.set_Record_date(test1);
    test2.set_Reader_id("2019232342");
    test2.set_Record_type("续借");
    cout << test2 << endl;
}

void testReader()
{
    //测试 读者类：学号、姓名、专业、班级、已借图书数量、借阅记录向量
    Reader test1;
    test1.set_Reader_id("2020214380");
    test1.set_Reader_name("杨佳辉");
    test1.set_Reader_major("计算机科学与技术");
    test1.set_Reader_class("计算机2004");
    test1.set_Reader_book_num(6);
    cout << test1 << endl;
    Reader test2("2020214333", "王明军", "计算机科学与技术", "计算机2004", 5);
    cout << test2 << endl;

}

void testRecords_operate()
{
    Date test01(2018, 8, 1);
    Date test02(2020, 1, 3);
    Date test03(2021, 7, 2);
    Date test04(2021, 3, 4);
    Record test1(test01, "ISBN-978-7-115-56050-6-1", "2021214096", "续借", "专业");
    Record test2(test02, "ISBN-978-7-109-24290-6-1", "2021213057", "借出", "专业");
    Record test3(test03, "ISBN-978-7-109-28070-0-1", "2021213456", "已还", "专业");
    Record test4(test04, "ISBN-978-986-479-477-5-2", "2021214096", "借出", "专业");
    Record test5(test04, "ISBN-978-7-115-56050-6-1", "2021214000", "续借", "专业");
    Operate_record op_record1;
    op_record1.record_add(test1);
    op_record1.record_add(test2);
    op_record1.record_add(test3);
    op_record1.record_add(test4);
    op_record1.record_add(test5);
    op_record1.selete_record_date(test04);
    //op_record1.record_write();
}

void testWork()
{
    Reader reader1("2020214380", "杨佳辉", "计算机", "2004", 6);
    Date date1(2022,1,1);
    Date date2(2018,8,1);
    Operate op1(reader1, date1);
    Operate_book op_book;
    op_book.selete_book_id("ISBN-978-7-169-24290-6");
    op_book.selete_book_name("骆驼祥子");
    op_book.selete_book_press("清华大学出版社");
    op_book.selete_book_date(date2);
    //op_book.selete_book_name_vague("骆驼");
    //op_book.selete_book_date_range(date2, date1);
    //op_book.selete_book_name_author("设计模式", "程杰");
    //op_book.selete_book_press_author("清华大学出版社", "程杰");
    op_book.borrow_book("ISBN-978-7-169-24290-6", reader1, date1);
    op_book.book_return("ISBN-978-6-105-23297-7", reader1, date1);
    op_book.book_renew("ISBN-976-986-47-437-5", reader1, date1);
    Operate_record op_record;
    //op_record.record_show(reader1);



}

int main()
{
    //testDate();
    //testReader();
    //testBook();
    //testRecords();
    //testRecords_operate();
    testWork();
}