图书馆管理系统C++实现

最新推荐文章于 2024-10-01 14:31:15 发布
最新推荐文章于 2024-10-01 14:31:15 发布
阅读量1.7w 收藏 201
点赞数 31
分类专栏： 项目 文章标签： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuimzzs/article/details/80377381
版权

写了一个小项目，图书馆系统，功能如下：
1，添加书籍
2，删除书籍（可删除还没外借的书籍）
3，读者借书
4，读者还书
5，按书籍登入号查看信息（每一本书的书籍登入号唯一，如有5本相同书名作者的书，那就有5个不同的书籍登入号）
6，查询所有图书信息（可以直接查看到同本书在图书馆中的剩余和借出情况）
7，查看指定读者的借书详情
8，注册新读者
9，查看所有书籍信息（可以详细到每个登入号和此登入号书籍的借阅情况：如谁借的，借阅日期）

采用客户端和服务器模式，服务器端接收客户端，一旦接收到便启用线程，然后相应来自此客户端的不同请求

server端

serverHead.h

#ifndef SERVERHEAD
#define SERVERHEAD

#include <iostream>
#include <string>
#include <cstdlib>
#include <list>
#include <iterator>
#include <fstream>
#include <cstring>
#include <thread>
#include<WINSOCK2.H>  
#include <mysql.h>
#pragma comment(lib,"ws2_32.lib")

struct infoData
{
    int flag;               //各种命令
    int borFlag;            //借阅情况1表示借出，0表示未出借
    char enterName[20];     //书籍登入号，一本份
    char bookName[50];      //书籍名
    char bookNum[20];       //书编号   
    char bookWriter[50];    //书作者
    int remainBook;         //最初设置的库存
    char readerName[50];    //借书者
    char readerNum[50];     //借书证
    char borrowTime[30];    //借书时间
    int remain;             //库中还剩此书数量
    int lend;               //从库中借出的此书数量
};

class Book_mysql
{
public:
    Book_mysql();
    bool connectAndCreate();                            //链接创建数据库和表
    bool selectWhetherEmpty();                          //检测是否为空表
    bool testTheBookWhetherExist(const infoData& Data); //判断书籍存在
    bool insertTo(infoData & Data);                     //插入书籍
    int deleteFrom(infoData & Data);                    //删除相应书籍
    bool readerBorrowBook(infoData & Data);             //读者借书
    int readerReturnBook(infoData & Data);              //还书
    bool whetherSurpass(infoData & Data);               //判断是否超过借书上限（上限一本书最多借两本）
    bool selectBookByEntername(infoData & Data);        //通过书籍登入号查询书籍
    void displayInformation(infoData & Data, const SOCKET& sClient);//打印（笼统）
    void showTheReaderBook(infoData & Data, SOCKET & sClient);//打印指定读者借书情况
    void DISPLAY(infoData & Data, SOCKET& sClient);     //打印（详细）
private:
    char user[30];                  //登陆名字    
    char pswd[10];                  //密码
    char host[20];                  //表示本地数据库           
    unsigned int port;              //端口
    MYSQL myCont;                   
    MYSQL_RES *result;
    MYSQL_ROW sql_row;
    int res;
};

class Reader_mysql
{
public:
    Reader_mysql();
    bool connectAndCreate();
    bool testTheReaderWhetherExist(infoData & Data);//检测该读者是否已经存在
    void insertTo(infoData & Data); //注册
    bool readerBorrowBook();        //借书
    bool readerReturnBook();        //还书
private:
    char user[30];                   //登陆名字    
    char pswd[10];                   //密码
    char host[20];                   //表示本地数据库
    unsigned int port;
    MYSQL myCont;
    MYSQL_RES *result;
    MYSQL_ROW sql_row;
    int res;
};

class serverSocket
{
public:
    serverSocket(int port);
    ~serverSocket();
    SOCKET serverAccpetSocket();//阻塞accept
private:
    WSADATA wsd;
    SOCKET sServer;             //客户端套接字  用来监听
    std::list<SOCKET> listScli; //客户端套接字  用链表来接收，接送一个放一个
    SOCKET temp;                //用来存放中间值
    SOCKADDR_IN addrServ;       //服务器地址
};

void addBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql);
void deleteBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql);
void borrowBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql, Reader_mysql & reader_mysql);
void returnBook(infoData& Data, SOCKET& sClient, Book_mysql & book_mysql, Reader_mysql & reader_mysql);
void searchBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql);
void displayAllBook(infoData& Data, SOCKET& sClient, Book_mysql & book_mysql);
void DISPLAY(infoData& Data, SOCKET& sClient, Book_mysql & book_mysql);
void showTheReaderBook(infoData & Data, SOCKET & sClient, Book_mysql & book_mysql, Reader_mysql & reader_mysql);
void setNewReader(infoData & Data, const SOCKET & sClient, Reader_mysql & reader_mysql);
void clientSocketThreadFunction(SOCKET sClient);

#endif

套接字类的实现
serverSocket.cpp


#include "serverHead.h"

serverSocket::serverSocket(int port)
{
    //初始化套结字动态库
    if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
    {
        std::cout << "WSAStartup failed!" << std::endl;
        return;
    }

    //开始创建服务端socket
    //创建套接字  AF_INET：ipv4   SOCK_STREAM：使用tcp
    sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (INVALID_SOCKET == sServer)
    {
        std::cout << "socket failed!" << std::endl;
        return;
    }

    //服务器套接字地址   
    addrServ.sin_family = AF_INET;//IPv4 
    addrServ.sin_port = htons(port);//设置端口 建议大于1024
    addrServ.sin_addr.s_addr = INADDR_ANY; //表示接受任何客户端的请求

    //绑定套接字  绑定服务端socket 和 端口
    int ret = bind(sServer, (LPSOCKADDR)&addrServ, sizeof(SOCKADDR_IN));
    if (SOCKET_ERROR == ret)
    {
        std::cout << "bind failed!" << std::endl;
        return;
    }

    //开始监听   
    ret = listen(sServer, 10);
    if (SOCKET_ERROR == ret)
    {
        std::cout << "listen failed!" << std::endl;
        return;
    }
}

serverSocket::~serverSocket()
{
    closesocket(sServer);   //关闭套接字  
    WSACleanup();           //释放套接字资源;  
}

SOCKET serverSocket::serverAccpetSocket()
{
    //接受客户端请求  
    sockaddr_in addrClient;
    int addrClientlen = sizeof(addrClient);
    temp = accept(sServer, (sockaddr FAR*)&addrClient, &addrClientlen);
    if (INVALID_SOCKET == temp)
    {
        std::cout << "accept failed!" << std::endl;
        return -1;
    }
    listScli.push_front(temp);
    return temp;
}

MySQL中书籍表的实现

bookMysql.cpp

#include "serverHead.h"

Book_mysql::Book_mysql()
{
    strcpy_s(user, "root");
    strcpy_s(pswd, "123456");
    strcpy_s(host, "localhost");
    port = 3306;
    mysql_init(&myCont);
    if (mysql_real_connect(&myCont, host, user, pswd, "mysql", port, NULL, 0))//先链接自带的数据库，以便后面创建专属数据库
    {
        res = mysql_query(&myCont, "create database if not exists zhanghsun");
        mysql_query(&myCont, "SET NAMES GBK");
        if (res)
        {
            std::cout << "创建库失败" << std::endl;
            system("pause");
            exit(-1);;
        }
        res = mysql_query(&myCont, "use zhanghsun");
        if (res)
        {
            std::cout << "use 失败" << std::endl;
            system("pause");
            exit(-1);
        }
        char order[1024];
        sprintf_s(order, "create table IF NOT EXISTS m_book(书籍登入号 char(10) not null, 书名 char(20) default null, 书编号 char(20) default null, 书作者 char(50) default null, 借阅 int default 0, 读者名 char(20) default '%s', 读者借书号 char(20) default '%s', 借阅时间 char(20) default '%s')", "无", "无", "无");
        res = mysql_query(&myCont, order);
        if (res)
        {
            std::cout << "创建表失败" << std::endl;
            system("pause");
            exit(-1);
        }
    }
    else
    {
        std::cout << "链接失败" << std::endl;
        system("pause");
        exit(-1);
    }
}
//判断指定书籍是否存在
bool Book_mysql::testTheBookWhetherExist(const infoData& Data)
{
    char order[1024];
    //检测是否存在该书
    sprintf_s(order, "SELECT * FROM m_book WHERE 书名='%s' and 书作者 = '%s'", Data.bookName, Data.bookWriter);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            if (sql_row = mysql_fetch_row(result))//如果查询不为空
            {
                return 1;//已有该书
            }                   
        }
    }
    else
    {
        std::cout << "查询失败" << std::endl;
        system("pause");
        exit(-1);
    }
    return 0;//没有该书 
}
//插入书籍操作
bool Book_mysql::insertTo(infoData & Data)
{
    char order[1024];
    sprintf_s(order, "insert into m_book (书籍登入号,书名,书编号,书作者) values('%s','%s','%s','%s')", Data.enterName,Data.bookName, Data.bookNum, Data.bookWriter);
    res = mysql_query(&myCont, order);
    if (res)
    {
        std::cout << "插入失败" << std::endl;
        system("pause");
        exit(-1);
    }
    return 1;
}
//判断表是否为空
bool Book_mysql::selectWhetherEmpty()
{
    char order[1024];
    sprintf_s(order, "SELECT * FROM m_book");
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            if (sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                return 0;//表不为空
            }
        }
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
    return 1;//表为空
}
//判断该读者要借书籍是否超出上限
bool Book_mysql::whetherSurpass(infoData & Data)
{
    char order[1024];
    int num = 0;
    sprintf_s(order, "select 读者名,读者借书号 from m_book where 书名 = '%s' and 书作者 = '%s'", Data.bookName, Data.bookWriter);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            while (sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                if (strcmp(Data.readerName, sql_row[0]) == 0
                    && strcmp(Data.readerNum, sql_row[1]) == 0)
                {
                    ++num;
                }
                if (num >= 2)
                {
                    return 1;//已达上限
                }
            }
        }
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
    return 0;//没超
}
//删除书籍
int Book_mysql::deleteFrom(infoData & Data)
{
    char order[1024];
    int flag = 0;
    sprintf_s(order, "SELECT * FROM m_book WHERE 书名='%s' AND 书作者 = '%s' AND 借阅 = '%d'", Data.bookName, Data.bookWriter, 0);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            while (sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                flag = 1;
                std::cout << "删除登入号:" << sql_row[0] << std::endl;
                //根据得到的登入号一一删除
                sprintf_s(order, "DELETE FROM m_book WHERE 书籍登入号 = '%s'", sql_row[0]);
                res = mysql_query(&myCont, order);
                if (res)
                {
                    std::cout << "删除failed" << std::endl;
                    system("pause");
                    exit(-1);
                }
            }
            if (flag == 0)
            {
                return -1;//全借出
            }
            else if (flag == 1)
            {
                return 1;//删除了相关书籍
            }
        }   
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
}
//读者借阅书籍
bool Book_mysql::readerBorrowBook(infoData & Data)
{
    char order[1024];
    sprintf_s(order, "SELECT 书籍登入号 FROM m_book WHERE 书名='%s' AND 书作者 = '%s' AND 借阅 = '%d'", Data.bookName, Data.bookWriter, 0);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            if(sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                std::cout << "借的书的登入号:" << sql_row[0] << std::endl;
                sprintf_s(order, "UPDATE m_book SET 借阅 = '%d',读者名 = '%s',读者借书号 = '%s', 借阅时间 = NOW() WHERE 书籍登入号 = '%s'", 1, Data.readerName,Data.readerNum, sql_row[0]);
                res = mysql_query(&myCont, order);
                if (res)
                {
                    std::cout << "更新failed" << std::endl;
                    system("pause");
                    exit(-1);
                }
            }
            else
            {
                return 0;//书全借光
            }
        }
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
    return 1;//借书成功
}
//还书
int Book_mysql::readerReturnBook(infoData & Data)
{
    char order[1024];
    sprintf_s(order, "SELECT * FROM m_book WHERE 书籍登入号='%s'", Data.enterName);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            if (sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                std::cout << "登入号:" << sql_row[0] << std::endl;
                sprintf_s(order, "UPDATE m_book SET 借阅 = 0, 读者名 = '%s', 读者借书号 = '%s', 借阅时间 = '%s' WHERE 书籍登入号 = '%s'","无", "无", "无", Data.enterName);
                res = mysql_query(&myCont, order);
                if (res)
                {
                    std::cout << "更新failed" << std::endl;
                    system("pause");
                    exit(-1);
                }
            }
            else
            {
                return 0;//没找到该登入号
            }
        }
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
    return 1;//成功
}
//更具书籍登入号查询书籍信息
bool Book_mysql::selectBookByEntername(infoData & Data)
{
    char order[1024];
    int flag = 0;
    sprintf_s(order, "SELECT * FROM m_book WHERE 书籍登入号='%s'", Data.enterName);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            if(sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                flag = 1;
                strcpy_s(Data.enterName, sql_row[0]);
                strcpy_s(Data.bookName, sql_row[1]);
                strcpy_s(Data.bookNum, sql_row[2]);
                strcpy_s(Data.bookWriter, sql_row[3]);
                if (atoi(sql_row[4]) == 1)
                {
                    Data.borFlag = 1;
                    strcpy_s(Data.readerName, sql_row[5]);
                    strcpy_s(Data.readerNum, sql_row[6]);
                    strcpy_s(Data.borrowTime, sql_row[7]);
                }               
                else
                {
                    Data.borFlag = 0;
                }
            }
            if (flag == 0)
            {
                return 0;//登入号没找到
            }
        }
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
    return 1;
}
//笼统打印
void Book_mysql::displayInformation(infoData & Data, const SOCKET& sClient)
{
    char order[1024];
    char tempName[30];
    char tempWriter[30];
    int lend = 0;
    int remain = 0;
    sprintf_s(order, "SELECT 书名,书编号,书作者 FROM m_book");
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            while (sql_row = mysql_fetch_row(result))//获取具体的数据
            {
                strcpy_s(Data.bookName, sql_row[0]);
                strcpy_s(Data.bookNum, sql_row[1]);
                strcpy_s(Data.bookWriter, sql_row[2]);
                if (strcmp(Data.bookName, tempName) == 0
                    && strcmp(Data.bookWriter, tempWriter) == 0)//相同书籍不予计算
                {
                    continue;
                }
                lend = 0;
                remain = 0;
                char _order[1024];//已借书情况
                sprintf_s(_order, "SELECT count(*) FROM m_book where 书名= '%s' and 书作者 = '%s' and 借阅 = 1", Data.bookName, Data.bookWriter);
                res = mysql_query(&myCont, _order);
                if (!res)
                {
                    MYSQL_RES *_result = mysql_store_result(&myCont);
                    if (_result)
                    {
                        MYSQL_ROW _sql_row;
                        while (_sql_row = mysql_fetch_row(_result))//获取具体的数据
                        {
                            lend = atoi(_sql_row[0]);
                        }
                    }
                }
                else
                {
                    std::cout << "查询failed" << std::endl;
                    system("pause");
                    exit(-1);
                }
                //剩余没借情况
                sprintf_s(_order, "SELECT count(*) FROM m_book where 书名= '%s' and 书作者 = '%s' and 借阅 = 0", Data.bookName, Data.bookWriter);
                res = mysql_query(&myCont, _order);
                if (!res)
                {
                    MYSQL_RES *_result = mysql_store_result(&myCont);
                    if (_result)
                    {
                        MYSQL_ROW _sql_row;
                        while (_sql_row = mysql_fetch_row(_result))//获取具体的数据
                        {
                            remain = atoi(_sql_row[0]);
                        }
                    }
                }
                else
                {
                    std::cout << "查询failed" << std::endl;
                    system("pause");
                    exit(-1);
                }
                Data.lend = lend;
                Data.remain = remain;
                if (strcmp(Data.bookName, tempName) != 0
                    && strcmp(Data.bookWriter, tempWriter) != 0)
                {
                    Data.flag = 0;
                    send(sClient, (char*)&Data, sizeof(Data), 0);
                }
                strcpy_s(tempName, Data.bookName);
                strcpy_s(tempWriter, Data.bookWriter);
            }
        }
    }
    else
    {
        std::cout << "查询failed" << std::endl;
        system("pause");
        exit(-1);
    }
    Data.flag = 1;
    send(sClient, (char*)&Data, sizeof(Data), 0);
}
//打印指定读者借书情况
void Book_mysql::showTheReaderBook(infoData & Data, SOCKET & sClient)
{
    char order[1024];
    int flag = 0;
    sprintf_s(order, "select 书籍登入号,书名,书编号,书作者,借阅时间 from m_book where 读者名 = '%s' and 读者借书号 = '%s';", Data.readerName, Data.readerNum);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            while (sql_row = mysql_fetch_row(result))//如果查询不为空
            {
                flag = 1;
                strcpy_s(Data.enterName, sql_row[0]);
                strcpy_s(Data.bookName, sql_row[1]);
                strcpy_s(Data.bookNum, sql_row[2]);
                strcpy_s(Data.bookWriter, sql_row[3]);
                strcpy_s(Data.borrowTime, sql_row[4]);
                Data.flag = 6;
                send(sClient, (char*)&Data, sizeof(Data), 0);
            }
        }
    }
    else
    {
        std::cout << "查询失败" << std::endl;
        system("pause");
        exit(-1);
    }
    if (flag == 0)
    {
        Data.flag = 0;//没有借书
        send(sClient, (char*)&Data, sizeof(Data), 0);
    }
    Data.flag = -1;
    send(sClient, (char*)&Data, sizeof(Data), 0);
}
//打印（详细）
void Book_mysql::DISPLAY(infoData & Data, SOCKET& sClient)
{
    char order[1024];
    int flag = 0;
    int i = 0;
    sprintf_s(order, "select * from m_book");
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            while (sql_row = mysql_fetch_row(result))//如果查询不为空
            {
                flag = 1;
                strcpy_s(Data.enterName, sql_row[0]);
                strcpy_s(Data.bookName, sql_row[1]);
                strcpy_s(Data.bookNum, sql_row[2]);
                strcpy_s(Data.bookWriter, sql_row[3]);

                if (atoi(sql_row[4]) == 1)
                {
                    Data.borFlag = 1;
                    strcpy_s(Data.readerName, sql_row[5]);
                    strcpy_s(Data.readerNum, sql_row[6]);
                    strcpy_s(Data.borrowTime, sql_row[7]);
                }
                else
                {
                    Data.borFlag = 0;
                }
                Data.flag = 6;      
                send(sClient, (char*)&Data, sizeof(Data), 0);
            }
        }
        if (flag == 0)//没有结果
        {
            Data.flag = -2;
            send(sClient, (char*)&Data, sizeof(Data), 0);
        }
    }
    Data.flag = -1;//打印退出flag
    send(sClient, (char*)&Data, sizeof(Data), 0);
}

MySQL读者表的实现

readerMysql.cpp

#include "serverHead.h"

Reader_mysql::Reader_mysql()
{
    strcpy_s(user, "root");
    strcpy_s(pswd, "123456");
    strcpy_s(host, "localhost");
    port = 3306;
    mysql_init(&myCont);
    if (mysql_real_connect(&myCont, host, user, pswd, "mysql", port, NULL, 0))
    {
        res = mysql_query(&myCont, "create database if not exists zhanghsun");
        mysql_query(&myCont, "SET NAMES GBK");
        if (res)
        {
            std::cout << "创建库失败" << std::endl;
            system("pause");
            exit(-1);
        }
        res = mysql_query(&myCont, "use zhanghsun");
        if (res)
        {
            std::cout << "use 失败" << std::endl;
            system("pause");
            exit(-1);
        }
        char order[1024];
        sprintf_s(order, "create table IF NOT EXISTS m_reader(读者名 char(20) default null, 读者借书号 char(20) default null)");
        res = mysql_query(&myCont, order);
        if (res)
        {
            std::cout << "创建表failed" << std::endl;
            system("pause");
            exit(-1);
        }
    }
    else
    {
        std::cout << "链接失败" << std::endl;
        system("pause");
        exit(-1);
    }
}
//判断是否重复注册
bool Reader_mysql::testTheReaderWhetherExist(infoData & Data)
{
    char order[1024];
    sprintf_s(order, "select * from m_reader where 读者名 = '%s' and 读者借书号 = '%s'", Data.readerName, Data.readerNum);
    res = mysql_query(&myCont, order);
    if (!res)
    {
        result = mysql_store_result(&myCont);
        if (result)
        {
            if (sql_row = mysql_fetch_row(result))//如果查询不为空
            {
                return 1;//有该读者
            }           
        }
    }
    else
    {
        std::cout << "查询失败" << std::endl;
        system("pause");
        exit(-1);
    }
    return 0;//没有此人     
}
//插入新读者
void Reader_mysql::insertTo(infoData & Data)
{
    char order[102];
    sprintf_s(order, "insert into m_reader (读者名, 读者借书号) values('%s','%s')", Data.readerName, Data.readerNum);
    res = mysql_query(&myCont, order);
    if (res)
    {
        std::cout << "插入失败" << std::endl;
        system("pause");
        exit(-1);
    }
    //else 注册成功
}

服务器端总实现
server.cpp

#include "serverHead.h"

//增加书籍
void addBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql)
{
    std::cout << "客户端 " << sClient << " 正在录入书籍  !" << std::endl;
    if (book_mysql.testTheBookWhetherExist(Data))//数据库中判断该书是否已经存在
    {
        std::cout << "客户端" << sClient << " 添加书籍重复已退回" << std::endl;
        Data.flag = -1;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        return;
    }
    //按库存随机每本书的登入号并插入
    srand((unsigned)time(NULL));//通过时间来随机登入号
    for (int i = 0; i < Data.remainBook; i++)
    {
        int x = rand() % 1000;
        _itoa_s(x, Data.enterName, 10);
        book_mysql.insertTo(Data);//在数据库中插入
    }
    Data.flag = 0;
    send(sClient, (char*)&Data, sizeof(Data), 0);
    std::cout << "客户端 " << sClient << " 录入书籍成功 !" << std::endl;
}
//删除书籍
void deleteBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql)
{
    std::cout << "客户端 " << sClient << " 正在删除书籍" << std::endl;
    int flag = 0;
    if (!(book_mysql.testTheBookWhetherExist(Data)))//首先判断该书是否存在
    {
        std::cout << "没有该书" << std::endl;
        Data.flag = -1;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        return;
    }
    //删除
    switch (book_mysql.deleteFrom(Data))
    {
    case -1:
        Data.flag = -2;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        std::cout << "该书全部出借，无法进行删除" << std::endl;
        break;
    case 1:
        Data.flag = 0;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        std::cout << "已删除此书的所有未出借书籍" << std::endl;
        break;
    }
}
//借阅书籍
void borrowBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql, Reader_mysql & reader_mysql)
{   
    std::cout << "客户端 " << sClient << " 正在借阅书籍" << std::endl;
    //判断该读者是否存在
    switch (reader_mysql.testTheReaderWhetherExist(Data))
    {
    case 0:Data.flag = -1; send(sClient, (char*)&Data, sizeof(Data), 0); return;//没有找到该读者，直接return
    case 1:Data.flag = 0; send(sClient, (char*)&Data, sizeof(Data), 0); break;//找到该读者，继续操作
    }
    recv(sClient, (char*)&Data, sizeof(Data), 0);
    if (book_mysql.selectWhetherEmpty())
    {
        std::cout << "未录入任何书籍" << std::endl;
        Data.flag = -1;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        return;
    }
    if (!(book_mysql.testTheBookWhetherExist(Data)))
    {
        Data.flag = -2;
        std::cout << "没有这本书" << std::endl;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        return;
    }
    //判断是否多借
    if (!(book_mysql.whetherSurpass(Data)))
    {
        switch (book_mysql.readerBorrowBook(Data))
        {
        case 1:Data.flag = 0; break;//借书成功
        case 0:Data.flag = -3; break;//书全借光
        }
    }
    else
    {
        Data.flag = -4;//借此书已达上限
    }
    send(sClient, (char*)&Data, sizeof(Data), 0);
}
//归还书籍
void returnBook(infoData& Data, SOCKET& sClient, Book_mysql & book_mysql, Reader_mysql & reader_mysql)
{
    std::cout << "客户端 " << sClient << " 正在归还书籍" << std::endl;
    showTheReaderBook(Data, sClient, book_mysql, reader_mysql);
    recv(sClient, (char*)&Data, sizeof(Data), 0);
    switch (book_mysql.readerReturnBook(Data))
    {
    case 0:std::cout << "没有找到该登入号" << std::endl; Data.flag = -1; send(sClient, (char*)&Data, sizeof(Data), 0); break;
    case 1:std::cout << "还书成功" << std::endl; Data.flag = 0; send(sClient, (char*)&Data, sizeof(Data), 0); break;
    }
}
//通过登入号搜索书籍
void searchBook(infoData& Data, const SOCKET& sClient, Book_mysql & book_mysql)
{
    std::cout << "客户端 " << sClient << " 正在通过登入号搜索书籍" << std::endl;
    switch(book_mysql.selectBookByEntername(Data))
    {
    case 1:send(sClient, (char*)&Data, sizeof(Data), 0);return;
    case 0:Data.flag = 3; send(sClient, (char*)&Data, sizeof(Data), 0); return;                     
    }
}
//打印书籍（笼统打印，不打印登入号）
void displayAllBook(infoData& Data, SOCKET& sClient, Book_mysql & book_mysql)
{
    std::cout << "客户端 " << sClient << " 正在打印书籍(概括)" << std::endl;
    if (book_mysql.selectWhetherEmpty())
    {
        std::cout << "还没有录入书籍" << std::endl;
        Data.flag = -1;
        send(sClient, (char*)&Data, sizeof(Data), 0);
        return;
    }
    book_mysql.displayInformation(Data, sClient);
}
//打印每一本书籍的信息（打印每一本书的详细信息）
void DISPLAY(infoData& Data, SOCKET& sClient, Book_mysql & book_mysql)
{
    std::cout << "客户端 " << sClient << " 正在打印全部书籍信息" << std::endl;
    book_mysql.DISPLAY(Data, sClient);
}
//打印指定读者的借书情况
void showTheReaderBook(infoData & Data, SOCKET & sClient, Book_mysql & book_mysql,Reader_mysql & reader_mysql)
{
    std::cout << "客户端 " << sClient << " 正在打印指定读者的借书情况" << std::endl;
    switch (reader_mysql.testTheReaderWhetherExist(Data))
    {
    case 0:Data.flag = -1; send(sClient, (char*)&Data, sizeof(Data), 0); return;//没有找到该读者，直接return
    case 1:Data.flag = 0; send(sClient, (char*)&Data, sizeof(Data), 0); break;//找到该读者，继续操作
    }
    book_mysql.showTheReaderBook(Data, sClient);
}
//注册新的读者
void setNewReader(infoData & Data, const SOCKET & sClient, Reader_mysql & reader_mysql)
{
    std::cout << "客户端 " << sClient << " 正在注册新读者" << std::endl;
    switch (reader_mysql.testTheReaderWhetherExist(Data))
    {
    case 1:Data.flag = -1; break;//已有该读者
    case 0:Data.flag = 1; reader_mysql.insertTo(Data); break;//注册成功
    }
    send(sClient, (char*)&Data, sizeof(Data), 0);
}
//线程
void clientSocketThreadFunction(SOCKET sClient)
{   
    Book_mysql book_mysql;
    Reader_mysql  reader_mysql;
    //对客户端的数据进行解析
    while (true)
    {
        infoData Data;
        int ret = recv(sClient, (char*)&Data, sizeof(Data), 0);
        if (SOCKET_ERROR == ret)
        {
            std::cout << sClient << "可能下线" << std::endl;
            return;
        }
        int flag = 0;
        switch (Data.flag)//错误：控制传输跳过的实例化，方法，加{}
        {
            //增加书籍
        case 1:addBook(Data, sClient, book_mysql); break;
            //删除书籍
        case 2:deleteBook(Data, sClient, book_mysql); break;
            //借书
        case 3:borrowBook(Data, sClient, book_mysql, reader_mysql); break;
            //还书
        case 4:returnBook(Data, sClient, book_mysql, reader_mysql); break;
            //搜索借书者
        case 5: searchBook(Data, sClient, book_mysql); break;
            //浏览所有书籍信息
        case 6: displayAllBook(Data, sClient, book_mysql); break;
            //查看登入读者的借书情况
        case 7:showTheReaderBook(Data, sClient,book_mysql, reader_mysql); break;
            //注册
        case 8:setNewReader(Data, sClient,reader_mysql); break;
            //退出flag
        case 9: flag = 1; break;
            //所有书被借情况一览表
        case -10:DISPLAY(Data, sClient, book_mysql); break;
        default:std::cout << "输入错误 请重新输入：" << std::endl;
        }
        if (flag == 1)
        {
            std::cout << "客户端 " << sClient << " 下线" << std::endl;
            break;
        }
    }
}

int main(int argc, char* argv[])
{
    serverSocket mySocket(8888);
    while (1)
    {   
        SOCKET sClient = mySocket.serverAccpetSocket();
        if (sClient == -1)
        {
            continue;
        }
        else
        {
            std::cout << "接收到一个客户端 :" << sClient << std::endl;
        }
        std::thread t1(clientSocketThreadFunction, sClient);//启用线程
        t1.detach();
    }
    return 0;
}

client

头文件
clientHead.h

#ifndef CLIENTHEAH
#define CLIENTHEAH

#include <WINSOCK2.H>  
#include <iostream>  
#include <string> 
#include <thread>

using namespace std;

#pragma comment(lib, "ws2_32.lib")

struct infoData
{
    int flag;               //各种命令
    int borflag;            //借阅情况1表示借出，0表示未出借
    char enter_name[20];    //书籍登入号，一本份
    char book_name[50];     //书籍名
    char book_num[20];      //书编号   
    char book_writer[50];   //书作者
    int remain_book;        //最初设置的库存
    char reader_name[50];   //借书者
    char reader_num[50];    //借书证
    char borrow_time[30];   //借书时间
    int remain;             //库中还剩此书数量
    int lend;               //从库中借出的此书数量
};

class clientSocket
{
public:
    clientSocket(string ipAdress, short port);
    ~clientSocket();
    bool connectToServer();
    void receiveData(infoData & data);
    void sendData(infoData & data);

private:
    WSADATA wsd;            //WSADATA变量  
    SOCKET sClient;         //客户端套接字  
    SOCKADDR_IN servAddr;   //服务器地址  
    int ret;                //返回值 
};

void menu();
void tapAnyKeyNext();
int addBook(infoData & Data, clientSocket & mySocket);
int displayAllbook(infoData Data, clientSocket & mySocket);
int deleteBook(infoData & Data, clientSocket & mySocket);
int borrowBook(infoData & Data, clientSocket & mySocket);
int returnBook(infoData & Data, clientSocket & mySocket);
int searchBook(infoData & Data, clientSocket & mySocket);
int showTheReaderBook(infoData & Data, clientSocket & mySocket);
int setNewReader(infoData & Data, clientSocket & mySocket);
void DISPLAY(infoData & Data, clientSocket & mySocket);

#endif

套接字类的实现
mySocket.cpp

#include "clientHead.h"

clientSocket::clientSocket(string ipAdress, short port)
{
    //初始化套结字动态库  
    if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
    {
        cout << "WSAStartup failed!" << endl;
        return;
    }
    //创建套接字  
    sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (INVALID_SOCKET == sClient)
    {
        cout << "socket failed!" << endl;
        return;
    }
    servAddr.sin_family = AF_INET;
    //如果编译通不过 属性 c++ 常规  sdl 改成否
    servAddr.sin_addr.s_addr = inet_addr(ipAdress.c_str());//设置服务端地址  这里表示本机
    servAddr.sin_port = htons(port);
    int nServAddlen = sizeof(servAddr);
}

bool clientSocket::connectToServer()
{
    //连接服务器  
    ret = connect(sClient, (LPSOCKADDR)&servAddr, sizeof(servAddr));
    if (SOCKET_ERROR == ret)
    {
        cout << "connect failed!" << endl;
        system("pause");
        return false;
    }
    //成功建立连接  可以开始通信了
    return true;
}

void clientSocket::sendData(infoData & Data)
{
    //向服务器发送数据  
    ret = send(sClient, (char*)&Data, sizeof(Data), 0);
    if (SOCKET_ERROR == ret)
    {
        cout << "send failed!" << endl;
        return;
    }
}

void clientSocket::receiveData(infoData & Data)
{
    // 接收服务器端的数据
    recv(sClient, (char*)&Data, sizeof(Data), 0); 
    /*if (ret < 0)
    {
        cout << "recv failed" << endl;
        return;
    }*/
}

clientSocket::~clientSocket()
{
    closesocket(sClient); //关闭套接字  
    WSACleanup(); //释放套接字资源  
}

客户端总实现
client

#include "clientHead.h"

void menu()
{
    cout << "*****************************" << endl;
    cout << endl;
    cout << "1.录入书籍"<<endl;
    cout << "2.删除书籍" << endl;
    cout << "3.借书" << endl;
    cout << "4.还书" << endl;
    cout << "5.按书籍登入号查看信息" <<endl;
    cout << "6.查询所有图书信息" << endl;
    cout << "7.查看你的借书详情" << endl; 
    cout << "8.注册" << endl;
    cout << "9.退出" << endl;
    cout << "-10.查看所有书籍信息" << endl;
    cout << endl;
    cout << "*****************************" << endl;
}
//增加书籍
int addBook(infoData & Data, clientSocket & mySocket)
{
    Data.flag = 1;
    cout << "开始录入书籍  !" << endl;
    cout << "输入书名：";
    cin >> Data.book_name;
    cout << "输入书编号：";
    cin >> Data.book_num;
    cout << "输入书作者：";
    cin >> Data.book_writer;
    cout << "输入书库存：";
    cin >> Data.remain_book;

    mySocket.sendData(Data);
    mySocket.receiveData(Data);

    if (Data.flag == -1)
    {
        cout << "已有此书，请勿重复添加" << endl;
    }
    if (Data.flag == 0)
    {
        cout << "添加成功" << endl;
    }

    cout << "是否继续增加书籍操作? 1 : 0 ";
    while (1)
    {
        int x;
        cin >> x;
        switch (x)
        {
        case 0:return 0;//退出
        case 1:return 1;//继续
        default:cout << "输入错误 请重新输入：";
        }
    }
}
//删除书籍
int deleteBook(infoData & Data, clientSocket & mySocket)
{
    if (displayAllbook(Data, mySocket))
    {
        tapAnyKeyNext();
        return 0;
    }
    cout << "已经外借的那本无法删除" << endl;
    cout << "输入书名：";
    cin >> Data.book_name;
    cout << "输入作者：";
    cin >> Data.book_writer;
    Data.flag = 2;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == -1)
    {
        cout << "没有该书" << endl;
    }
    else if (Data.flag == -2)
    {
        cout << "该书全部出借，无法进行删除" << endl;
    }
    else if (Data.flag == 0)
    {
        cout << "删除成功" << endl;
    }

    cout << "是否继续删除书籍操作? 1 : 0 ";
    while (1)
    {
        int x;
        cin >> x;
        switch (x)
        {
        case 0:return 0;//退出
        case 1:return 1;//继续
        default:cout << "输入错误 请重新输入：";
        }
    }
}
//借书
int borrowBook(infoData & Data, clientSocket & mySocket)
{
    Data.flag = 3;
    cout << "输入你的姓名：" << endl;
    cin >> Data.reader_name;
    cout << "输入你的借书号：" << endl;
    cin >> Data.reader_num;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == -1)
    {
        cout << "没有找到该读者，是否重新输入？1:2" << endl;
        char ch[10];
        cin >> ch;
        int x = atoi(ch);
        switch (x)
        {
        case 1:return 1; break;
        case 2:return 0; break;
        }
    }
    else if (Data.flag == 0)
    {
        cout << "登入成功" << endl;
    }
    cout << "输入书籍名：";
    cin >> Data.book_name;
    cout << "输入书作者：";
    cin >> Data.book_writer;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == 0)
    {
        cout << "借书成功" << endl;
    }
    else if (Data.flag == -1)
    {
        cout << "未录入任何书籍" << endl;
    }
    else if (Data.flag == -2)
    {
        cout << "没有这本书" << endl;
    }
    else if (Data.flag == -3)
    {
        cout << "该书已借光" << endl;
    }
    else if (Data.flag == -4)
    {
        cout << "借此书此书已达上限" << endl;
    }
    cout << "是否继续借书操作? 1 : 0 ";
    while (true)
    {
        while (1)
        {
            int x;
            cin >> x;
            switch (x)
            {
            case 0:return 0;//退出
            case 1:return 1;//继续
            default:cout << "输入错误 请重新输入：";
            }
        }
    }
}
//还书
int returnBook(infoData & Data, clientSocket & mySocket)
{
    Data.flag = 4;
    cout << "输入你的姓名：" << endl;
    cin >> Data.reader_name;
    cout << "输入你的借书号：" << endl;
    cin >> Data.reader_num;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == -1)
    {
        cout << "没有找到该读者，是否重新输入？1:2" << endl;
        char ch[10];
        cin >> ch;
        int x = atoi(ch);
        switch (x)
        {
        case 1:return 1; break;
        case 2:return 0; break;
        }
    }
    else if (Data.flag == 0)
    {
        cout << "登入成功" << endl;
    }
    cout << "您所借书如下:" << endl;
    cout << endl;
    mySocket.receiveData(Data);
    if (Data.flag == 0)
    {
        cout << endl;
        std::cout << "你没有借书" << std::endl;
        cout << endl;
        return 1;
    }
    while (Data.flag == 6)
    {
        cout << "登入号   ：" << Data.enter_name << endl;
        cout << "书籍名   ：" << Data.book_name << endl;
        cout << "书籍号   ：" << Data.book_num << endl;
        cout << "作者名   : " << Data.book_writer << endl;
        cout << "借阅时间 ：" << Data.borrow_time << endl;
        cout << endl;
        mySocket.receiveData(Data);
    }
    cout << "输入登入号还书：" << endl;
    cin >> Data.enter_name;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == -1)
    {
        cout << "没有查询到该登入号" << endl;
    }
    else if (Data.flag == 0)
    {
        cout << "还书成功" << endl;
    }
    cout << "是否继续还书操作? 1 : 0 ";
    while (true)
    {
        while (1)
        {
            int x;
            cin >> x;
            switch (x)
            {
            case 0:return 0;//退出
            case 1:return 1;//继续
            default:cout << "输入错误 请重新输入：";
            }
        }
    }
}
//打印（笼统）
int displayAllbook(infoData Data, clientSocket & mySocket)
{
    Data.flag = 6;
    mySocket.sendData(Data);
    cout << endl;
    while (true)
    {   
        mySocket.receiveData(Data);
        if (Data.flag == -1)
        {
            cout << "没有录入书籍" << endl;
            return -1;
        }
        else if (Data.flag == 1)
        {
            break;
        }
        else if (Data.flag == 0)
        {
            cout << "书籍名 ：" << Data.book_name << endl;
            cout << "书籍号 ：" << Data.book_num << endl;
            cout << "作者名 ：" << Data.book_writer << endl;
            cout << "还剩余 ：" << Data.remain << " 本" << endl;
            cout << "已借出 ：" << Data.lend <<" 本"<< endl;
            cout << endl;
        }       
    }
    return 0;
}
//通过书籍登入号查找书籍信息
int searchBook(infoData & Data, clientSocket & mySocket)
{
    Data.flag = 5;
    cout << "请输入书籍登入号" << endl;
    cin >> Data.enter_name;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == 3)
    {
        cout << "没有这个登入号" << endl;
        tapAnyKeyNext();
        return 0;
    }
    cout << endl;
    cout << "查询结果如下" << endl;
    cout << endl;
    cout << "登入号 ：" << Data.enter_name << endl;
    cout << "书籍名 ：" << Data.book_name << endl;
    cout << "书籍号 ：" << Data.book_num << endl;
    cout << "作者名 : " << Data.book_writer << endl;
    if (Data.borflag == 1)
    {
        cout << "**该书已被借**" << endl;
        cout << "借书者 ：" << Data.reader_name << endl;
        cout << "借书证 ：" << Data.reader_num << endl;
    }
    else if (Data.borflag == 0)
    {
        cout << "**该书没被借**" << endl;
    }
    cout << endl;
    cout << "查询完成" << endl;
    cout << "是否继续查询操作? 1 : 0 ";
    while (true)
    {
        while (1)
        {
            int x;
            cin >> x;
            switch (x)
            {
            case 0:return 0;//退出
            case 1:return 1;//继续
            default:cout << "输入错误 请重新输入：";
            }
        }
    }
}
//查看指定读者借书情况
int showTheReaderBook(infoData & Data, clientSocket & mySocket)
{
    Data.flag = 7;
    cout << "输入你的姓名：" << endl;
    cin >> Data.reader_name;
    cout << "输入你的借书号：" << endl;
    cin >> Data.reader_num;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == -1)
    {
        cout << "没有找到该读者，是否重新输入？1:2" << endl;
        char ch[10];
        cin >> ch;
        int x = atoi(ch);
        switch (x)
        {
        case 1:return 1; break;
        case 2:return 0; break;
        }
    }
    else if (Data.flag == 0)
    {
        cout << "登入成功" << endl;
    }
    mySocket.receiveData(Data);
    if (Data.flag == 0)
    {
        cout << "你还没借书" << endl;
    }
    else
    {
        cout << endl;
        cout << "查询结果如下" << endl;
        cout << endl;
        while (Data.flag == 6)
        {       
            cout << "登入号   ：" << Data.enter_name << endl;
            cout << "书籍名   ：" << Data.book_name << endl;
            cout << "书籍号   ：" << Data.book_num << endl;
            cout << "作者名   : " << Data.book_writer << endl;
            cout << "借书时间 ：" << Data.borrow_time << endl;
            cout << endl;
            mySocket.receiveData(Data);
        }
    }
    cout << "以上是您所有的借书情况" << endl;
    cout << "是否继续此查询操作? 1 : 0 ";
    while (true)
    {
        while (1)
        {
            int x;
            cin >> x;
            switch (x)
            {
            case 0:return 0;//退出
            case 1:return 1;//继续
            default:cout << "输入错误 请重新输入：";
            }
        }
    }
}
//创建新读者
int setNewReader(infoData & Data, clientSocket & mySocket)
{
    Data.flag = 8;
    cout << "输入你的姓名：" << endl;
    cin >> Data.reader_name;
    cout << "输入你的借书号：" << endl;
    cin >> Data.reader_num;
    mySocket.sendData(Data);
    mySocket.receiveData(Data);
    if (Data.flag == 1)
    {
        cout << "注册成功" << endl;
        tapAnyKeyNext();
        return 0;
    }
    else if (Data.flag == -1)
    {
        cout << "名字借书号重复，是否重新输入？1:2" << endl;
        char ch[10];
        cin >> ch;
        int x = atoi(ch);
        switch (x)
        {
        case 1:return 1; break;
        case 2:return 0; break;
        }
    }
}
//遍历每一本书的详情信息
void DISPLAY(infoData & Data, clientSocket & mySocket)
{
    Data.flag = -10;
    int i = 0;
    mySocket.sendData(Data);
    cout << endl;
    while (true)
    {
        mySocket.receiveData(Data);
        if (Data.flag == -2)
        {
            cout << "没有录入书籍" << endl;
            tapAnyKeyNext();
            return;
        }
        if (Data.flag == -1)
        {
            break;
        }
        /*std::cout << "i = " << i << std::endl;
        ++i;*/
        cout << "登入号  ：" << Data.enter_name << endl;
        cout << "书籍名  ：" << Data.book_name << endl;
        cout << "书籍号  ：" << Data.book_num << endl;
        cout << "作者名  : " << Data.book_writer << endl;
        if (Data.borflag == 1)
        {
        cout << "**该书已被借**" << endl;
        cout << "借书者   ：" << Data.reader_name << endl;
        cout << "借书证   ：" << Data.reader_num << endl;
        cout << "借阅时间 ：" << Data.borrow_time << endl;
        }
        else if (Data.borflag == 0)
        {
            cout << "**该书没被借**" << endl;
        }
        cout << endl;

    }
    cout << "查询完成" << endl;
    cout << endl;
    tapAnyKeyNext();
}
//按任意键退出
void tapAnyKeyNext()
{
    while (1)
    {
        cout << "按任意键返回主菜单" << endl;
        string x;
        cin >> x;
        return;
    }
}

int main()
{   
    clientSocket mySocket("127.0.0.1", 8888);
    if (!mySocket.connectToServer())
    {
        return 0;
    }
    //向服务端发送数据
    while (true)
    {
        menu();
        infoData Data;
        char ch[20];
        cout << "输入操作：";
        cin >> ch;
        int x = atoi(ch);   
        int flag = 0;
        switch (x)
        {
        case 1:
        {
            while (1)
            {
                if (addBook(Data, mySocket) == 0)
                {
                    break;
                }
            }
        } break;
        case 2:
        {
            while (1)
            {
                if (deleteBook(Data, mySocket) == 0)
                {
                    break;
                }
            }
        }break;
        case 3:
        {
            while (1)
            {
                if (borrowBook(Data, mySocket) == 0)
                {
                    break;
                }
            }
        }break;
        case 4:
        {
            while (1)
            {
                if (returnBook(Data, mySocket) == 0)
                {
                    break;
                }
            }
        }break;
        case 5:
        {
            while (1)
            {   
                if (searchBook(Data, mySocket) == 0)
                {
                    break;
                }
            }
        }break;
        case 6:displayAllbook(Data, mySocket); tapAnyKeyNext(); break;
        case 7:
        {
            while (1)
            {
                if (showTheReaderBook(Data, mySocket) == 0)
                {
                    break;
                }
            }
        }break;
        case 8:
        {
            while (1)
            {
                if (setNewReader(Data, mySocket) == 0)
                {
                    break;
                }
            }
        }break;
        case 9:flag = 1; break;
        case -10:DISPLAY(Data, mySocket); break;
        default:cout << "输入错误 请重新输入：" << endl;
        }
        if (flag == 1)
        {
            Data.flag = 9;
            mySocket.sendData(Data);
            break;
        }
    }
    WSACleanup();
    return 0;
}

平台：vs2013
MySQL5.7

综合了MySQL，网络通信，线程等相关知识，看了不少书，但难免有些幼稚的地方请见谅

手把手教你用 c++ 做 图书管理系统
Gettler的博客
05-22 5万+
图书管理系统设计题目要求思路分析各个模块的实现“书”类的创建管理模块的创建及实现管理权限添加图书查找图书修改图书删除图书销售模块的创建与实现统计模块的创建与实现创建简易登录界面文件的读取与存储 题目要求 1、问题描述 : 定义图书类，属性有：书名、出版社、ISBN 号、作者、库存量、价格等信息和相关的 对属性做操作的行为。 主要完成对图书的销售、统计和图书的简单管理。 2、功能要求 （1）销售功能: 购买书籍时，输入相应的 ISBN 号，并在书库中查找该书的相关信息。 如果有库存量，输入购买的册数，进行相应
图书管理系统（C++）
徐小mu的博客
10-04 2075
这个项目还是很完善的，也建议看看。 #include <stdlib.h> #include <iostream> #include <conio.h> #include <string.h> #define MAXREADER 20 using namespace std; struct Date /*日期结构*/ { int Y...
C++入门基础 (超详解)
最新发布
2301_79601095的博客
10-01 6161
C++是在C语言的基础上发展而来的一种面向对象编程语言，它在保留C语言强大功能的同时，引入了许多新的特性。比如面向对象编程（OOP）：类, 封装, 继承, 多态四大件，引用（Reference）模板（Template）命名空间（Namespace）异常处理（Exception Handling）标准模板库（STL）C++在很多领域有着广泛的应用，比如游戏开发，操作系统开发，嵌入式系统开发， 数据库管理系统，图形图像处理和网络通信(QT)，虚拟现实（VR）和增强现实（AR），航空航天与军工领域等等。
图书管理系统（C++语言实现）
10-04
此程序是用标准C++编写的控制台下的一个简易图书管理系统。
图书馆管理系统（c++）
12-31
使用c++语言，开发一个基于控制台的简单的图书管理系统，使用文件的方式存放各种信息（不允许使用数据库）。具体功能要求如下： 1． 图书管理：增加图书、修改图书、删除图书、统计图书(各类图书库存数量)； 2． 借阅管理：查找图书、借阅图书、归还图书、借阅图书统计(某日借出)、至某日到期图书统计、罚款统计 ； 3． 读者管理：申请读者卡、删除读者卡、修改读者卡、(某人)借书统计、卡号统计； 4． 馆员管理：添加管理员、修改管理员信息、删除管理员、馆员统计
图书馆管理系统（c++语言编写）
05-13
这是我们老师布置的大作业啊，我们用了N久才终于做好了哈，嘿嘿。。。。。
图书管理系统C++版
01-13
C++图书管理系统，命令行界面，增删查改图书信息等基本功能
C++实现简易图书馆管理系统
热门推荐
m0_51574586的博客
12-26 1万+
一个简易的C++图书管理系统。本人菜鸡，大佬勿进
图书馆管理系统C++
06-24
《C++实现的图书馆管理系统详解》 图书馆管理系统是信息技术在图书管理领域的重要应用，它能够高效、便捷地处理图书的借阅、归还、查询等一系列操作。本系统采用C++编程语言进行开发，充分体现了C++的强大功能和...
基于Qt使用C++实现图书管理系统源码.zip
05-09
基于Qt使用C++实现图书管理系统源码 基于Qt使用C++实现图书管理系统源码 基于Qt使用C++实现图书管理系统源码 基于Qt使用C++实现图书管理系统源码 基于Qt使用C++实现图书管理系统源码 基于Qt使用C++实现...
C++编写的图书馆管理系统
03-30
C++编写的图书馆管理系统
基于C++的图书馆管理系统
10-09
基于C++的图书管理系统，主要功能是图书的增、删、改、查
c++语言写的 图书管理系统
08-06
本软件采用c++语言编写。实现图书信息的增删改查，读者信息的增删改查，用户信息登陆验证，以及用户信息管理，借书，还书等主体功能。采取SQL数据库连接方式，自带皮肤库。文件中包含了数据库文件，软件源码。在vc6.0下编译通过，可以直接运行。
图书管理系统C++代码
12-23
一、 课程设计的基本要求 利用《数据结构》课程的相关知识完成一个具有一定难度的综合设计题目，利用C/C++语言进行程序设计，并规范地完成课程设计报告。通过课程设计，巩固和加深对线性表、栈、队列、字符串、树、图、查找、排序等理论知识的理解；掌握现实复杂问题的分析建模和解决方法（包括问题描述、系统分析、设计建模、代码实现、结果分析等）；提高利用计算机分析解决综合性实际问题的基本能力。 具体要求如下： 1、 对现实复杂问题中的数据对象特性及组织方法进行分析和研究，设计适当的数据逻辑结构、存贮结构以及相应运算操作，把现实世界问题建模转化为计算机内部表示并进行处理。 2、 采取模块化方式进行程序设计，要求程序的功能设计、数据结构设计及整体结构设计合理。学生也可根据自己对题目的理解增加新的功能模块（视情况可另外加分）。 3、 系统以菜单界面方式（至少采用文本菜单界面，如能采用图形菜单界面更好）工作，运行界面友好，演示程序以用户和计算机的对话方式进行，利用文件进行数据的提取与存储。 4、 程序算法说明清晰，理论分析与计算正确，运行情况良好，实验测试数据无误，容错性强（能对错误输入进行判断控制）。 5、 编程风格良好（包括缩进、空行、适当注释、变量名和函数名见名知意，程序容易阅读等）； 6、 写出规范的课程设计报告，具体要求见相关说明文档。 二、 课程设计的主要内容 [问题描述] 英文图书管理系统主要包括增加图书、查询图书、删除图书、图书借阅、还书、按照书号进行排序和统计当前借出和借入情况几个模块。 [基本要求] 　　要求数据结构用链表的形式，并能利用文件进行数据的提取与存储。 [测试数据]
简易图书管理系统c++
09-02
一个简易的图书管理系统，功能不是很全，可能需要大家的简易，对初学者来说是个很不错的哦，含数据库的
mfc c++实现 图书馆管理系统
01-05
总结，使用MFC C++实现的图书馆管理系统具备良好的可扩展性和稳定性，能够满足现代图书馆的管理需求。开发过程中，我们需要充分理解MFC框架的原理，熟练掌握C++的面向对象编程，以及数据库和用户界面设计的相关知识...
期末大作业C++课程设计基于Qt实现图书管理系统源码.zip
06-17
期末大作业C++课程设计基于Qt实现图书管理系统源码，VS开发。期末大作业C++课程设计基于Qt实现图书管理系统源码，VS开发。期末大作业C++课程设计基于Qt实现图书管理系统源码，VS开发。期末大作业C++课程设计基于Qt...
图书馆信息管理系统C++.rar
06-19
(1)图书管图书基本信息管理，包括添加、查询、删除等; (2)图书借阅信息管理，包括借阅时修改图书借阅状态和还书时取消借阅状态等; (3)还可以查看图书的借阅状态，是否可借。 (4)借阅信息用图形界面方式展示或以...
C++实现学生图书馆借阅管理系统
这个简单的C++学生图书馆管理系统展示了基本的面向对象设计原则，包括封装、继承（虽然此代码没有展示）和多态（通过虚函数实现）。此外，它还涉及文件操作、数组管理和条件判断等基础编程概念。为了实现更完整和...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值