精华内容
下载资源
问答
  • 这是老师布置的要求用C语言编程设计一个图书管理系统,可以参考一下
  • 通过对图书的收录,创建出动态链表(存在文件中,并...对图书编号、书名、作者、现存本数、出版社、出版日期、摘要等信息进行管理;使其有按图书编号的查找、排序以及添加、删除等操作功能。文档末尾附带可编程源代码。
  • 这是为要编写大的程序的 对编程不太熟悉的编程者提供的,里面包括对图书管理系统的怎么编写有详细的描写
  • 图书店需要管理图书的租借信息,试设计一图书租借管理系统,使之能提供以下功能: (1) 能从文件导入图书的租借信息 (2) 能从键盘录入图书的租借信息,图书号,租借人,租借日期 (3) 能根据日期查询图书的...
  • /* Note:Your choice is C IDE */ #include<stdio.h> #include #include #include #include #include using namespace std; class book { public: book();//默认构造函数 char inter_face();...
  • C语言是面向过程的,而C++是面向对象的C和C++的区别:C是一个结构化语言,它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程,对输入(或环境条件)进行运算处理得到输出(或实现过程(事务)控制)...

    C语言是面向过程的,而C++是面向对象的

    C和C++的区别:

    C是一个结构化语言,它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程,对输入(或环境条件)进行运算处理得到输出(或实现过程(事务)控制)。

    C++,首要考虑的是如何构造一个对象模型,让这个模型能够契合与之对应的问题域,这样就可以通过获取对象的状态信息得到输出或实现过程(事务)控制。 所以C与C++的最大区别在于它们的用于解决问题的思想方法不一样。之所以说C++比C更先进,是因为“ 设计这个概念已经被融入到C++之中 ”。

    C与C++的最大区别:在于它们的用于解决问题的思想方法不一样。之所以说C++比C更先进,是因为“ 设计这个概念已经被融入到C++之中 ”,而就语言本身而言,在C中更多的是算法的概念。那么是不是C就不重要了,错!算法是程序设计的基础,好的设计如果没有好的算法,一样不行。而且,“C加上好的设计”也能写出非常好的东西。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    项目名称:图书管理系统

    开发工具:Visual Studio 2017

    编程语言:C语言

    意义:链表、文件存储、数据加解密、多文件开发综合应用

    功能描述:

    1:增、删、改、查

    2:数据加解密

    3:文件数据库,带记忆功能

    4:初始化

    5:搜索

    检查时间:2017年8月6日

    结构体原型:struct _book

    {

    char bid[10];//编号

    char name[30];//书名

    int page;//页数

    int price;//价格

    struct _book *next; //下一个节点的首地址

    };

    typedef struct _book BOOK;//简化结构体声明

    源代码截图:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    小编推荐一个学C语言/C++的学习裙【 七三零,一三零,二二一 】,无论你是大牛还是小白,是想转行还是想入行都可以来了解一起进步一起学习!裙内有开发工具,很多干货和技术资料分享!

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    效果截图:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    存储数据截图:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    作者:小辰带你看世界

    链接:https://www.jianshu.com/p/10e25dda1b43

    來源:简书

    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    展开全文
  • 马房山实验报告大学C语言实验图书系统——追求卓越实验内容开发环境说明代码源文件main.cWelcome.cLogin.cReader.cManager.cLibrarian.cLibrarian_file.cBorrow.cInquire.c头文件model.hglobal.h 实验内容 实验...

    实验内容

    实验要求我就不说了老师应该都给你们说的很清楚了(其实是我忘了)

    由于本次实验是组队编程,所以你们要cv也记得考虑接口的问题。

    开发环境

    macOS 10.14 Xcode
    使用bug 10的各位同学直接运行可能会出一点小问题。
    建议将代码导入工程阅读,体现代码结构

    说明

    以下代码均由我一人完成,代码除了相应的文字显示外没有实现任何功能,只是设计出了整个系统的整体框架,以及所有接口的预留;接口的统一便于团队后续的功能实现。这篇文章的目的是给不知道从何开始编写的同学们一个参考,而不是直接cv之后就可以交。(所以说为什么叫追求卓越)(这个工程绝对是我这辈子写过的注释最多的一个)(乐)

    代码

    源文件

    main.c

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "Welcome.h"
    #include "global.h"
    int main()
    {
    	FILE* fp = NULL;
    	Librarians boss;
    	char pwd[8] = { "boot" };
    
    	fp = fopen(ppPathReaderLib, "rb");
    	if (fp == NULL)
    	{
    		fp = fopen(ppPathReaderLib, "wb");
    		if (fp == NULL)
    		{
    			printf("error");
    			return 0;
    		}
    		boss.Level = 0;
    		boss.LibrarianID = 000;
    		strcpy(boss.LibrarianPwd, pwd);
    		boss.nDel = 0;
    		fwrite(&boss, sizeof(Librarians), 1, fp);
    		fclose(fp);
    	}
    	else fclose(fp);
    	
    	welcome();
    	Login();
    
    	return 0;
    }
    

    Welcome.c

    #include "Welcome.h"
    #include "global.h"
    
    /**
     读者端菜单选择
     此处将登陆时的读者结构体传递过来,便于读者信息的输出
     */
    void ReaderMenu(Readers* reader)
    {
    	int menuNum;
    	OutputReaderMenu();
    	do
    	{
    		puts("请输入菜单编号");
    		printf(">");
    		scanf("%d", &menuNum);
    		switch (menuNum)
    		{
    		case 1:
    			// insert code here...
    			// 读者信息
    			OutputReaderInfo(reader);
    			break;
    
    		case 2:
    			// insert code here...
    			// 已借书目
    			OutputBorrowedInfo(reader);
    			break;
    
    		case 3:
    			// insert code here...
    			// 查询图书
    			InquireBook();
    			break;
    
    		case 4:
    			// insert code here...
    			// 借阅归还图书
    			Borrow_ReturnBook(reader);
    			break;
    
    		case 0:
    			// insert code here...
    			//退出
    			puts("----------退出----------");
    			break;
    
    		default:
    			// insert code here...
    			puts("非法输入!");
    			break;
    		}
    
    	} while (menuNum);
    }
    
    
    /**
     管理员端菜单选择
     此处将登陆时的管理员结构体传递过来,便于读者信息的输出
    
     注意!!!!!!!!!!!!
     在视频中没有给出管理员相关功能函数的存放位置,所以我新建了一个视频中没有的 Librarian.c 文件及其头文件,
     并将管理员相关操作放入其中
     */
    void LibrarianMenu(Librarians* librarian)
    {
    	int menuNum;
    	OutputLibMenu();
    	do
    	{
    		puts("请输入菜单编号");
    		printf(">");
    		scanf("%d", &menuNum);
    		switch (menuNum)
    		{
    		case 1:
    			// insert code here...
    			// 管理员信息
    			OutputLibInfo(librarian);
    			break;
    
    		case 2:
    			// insert code here...
    			// 读者管理
    			ManageReader(librarian);
    			break;
    
    		case 3:
    			// insert code here...
    			// 图书管理
    			ManageBook(librarian);
    			break;
    
    		case 4:
    			// insert code here...
    			// 管理员管理
    			ManageLib(librarian);
    			break;
    
    		case 0:
    			// insert code here...
    			//退出
    			puts("----------退出----------");
    			break;
    
    		default:
    			// insert code here...
    			puts("非法输入!");
    			break;
    		}
    
    	} while (menuNum);
    }
    
    
    
    /**
     此函数功能为输出一段欢迎语,系统启动时调用此函数
     */
    void welcome(void)
    {
    	puts("Welcome to the Library Manager System!");
    }
    
    
    /**
     输出读者端菜单
     */
    void OutputReaderMenu(void)
    {
    	puts("读者端");
    	puts("----------菜单----------");
    	puts("1.读者信息");
    	puts("2.已借书目");
    	puts("3.查询图书");
    	puts("4.借阅图书");
    	puts("0.退出\n");
    }
    
    
    /**
     输出读者查询图书相应功能
     */
    void InquireBookMenu(void)
    {
    	puts("1.按图书名查询");
    	puts("2.按图书编号查询");
    	puts("0.返回上一级");
    }
    
    void InquireBookMENU(void)
    {
    	puts("1.按书名");
    	puts("2.按编号");
    }
    
    /**
     输出读者借阅图书相应功能
     */
    void ReaderBorrowMenu(void)
    {
    	puts("1.借阅");
    	puts("2.归还");
    	puts("0.返回上一级");
    }
    
    
    /**
     输出管理员端顶层菜单
     */
    void OutputLibMenu(void)
    {
    	puts("管理员端");
    	puts("----------菜单----------");
    	puts("1.管理员信息");
    	puts("2.读者管理");
    	puts("3.图书管理");
    	puts("4.管理员管理");
    	puts("0.退出\n");
    }
    
    
    /**
     输出读者管理相应菜单
     */
    void ManageReaderMenu(void)
    {
    	puts("1.读者查询");
    	puts("2.读者删除");
    	puts("3.读者修改");
    	puts("4.读者添加");
    	puts("0.返回上一级");
    }
    
    
    /**
     输出图书管理相应菜单
     */
    void ManageBookMenu(void)
    {
    	puts("1.图书查询");
    	puts("2.图书删除");
    	puts("3.图书修改");
    	puts("4.图书添加");
    	puts("0.返回上一级");
    }
    
    
    /**
     输出管理员管理相应菜单
     */
    void ManageLibMenu(void)
    {
    	puts("1.管理员查询");
    	puts("2.管理员删除");
    	puts("3.管理员修改");
    	puts("4.管理员添加");
    	puts("0.返回上一级");
    }
    

    Login.c

    /**
     登录模块
     在菜单中直接调用的是 void Login(void) 函数
     登录模块分为两部分,分别为读者登录和管理员登录;
     读者登录调用 ReaderLogon 函数,管理员登录调用 LibrarianLogon 函数;
     两个函数内部实现的逻辑应类似
     */
    
    #include "Login.h"
    #include "global.h"
    
     /**
      登录函数用户层,用于判断是读者登录还是管理员登录
      */
    void Login(void)
    {
    	int log = 3;
    	int IDnum = 0;
    
    	while (log != 0)
    	{
    		printf("读者登录请输入1,管理员登录请输入2,退出系统请输入0.\n");
    		printf(">");
    		scanf("%d", &log);
    		switch (log)
    		{
    		case 0:
    			printf("----------退出系统----------\n");
    			break;
    
    		case 1:
    			printf("请输入ID:\n>");
    			scanf("%d", &IDnum);
    			ReaderLogin(InquireReaderByID(IDnum));
    			// 此处调用按ID查询读者
    
    			break;
    
    		case 2:
    			printf("请输入ID:\n>");
    			scanf("%d", &IDnum);
    			LibrarianLogin(InquireLibByID(IDnum));
    			// 此处调用按ID查询管理员
    
    			break;
    
    		default:
    			printf("非法的输入!\n");
    			break;
    		}
    	}
    }
    
    
    /**
     读者登录函数
     */
    void ReaderLogin(Readers* reader)
    {
    	char pwd[10];
    	printf("请输入密码:\n>");
    	scanf("%s", pwd);
    	if (reader != NULL)
    	{
    		if ((strcmp(pwd, reader->ReaderPwd) == 0)&&(reader->nDel==0))
    		{
    			printf("登录成功!\n");
    			// 这里可以输出一些相关信息,例如姓名,ID号,登录时间等
    			printf("读者ID:%d\n",reader->ReaderID);
    			// insert code here..
    			ReaderMenu(reader);
    		}
    		else
    			printf("ID号或者密码不正确!\n");
    	}
    	else
    		printf("ID号或者密码不正确!\n");    // 这里的输出也可以替换成 ”此卡号不存在“ 之类的,随意
    }
    
    
    /**
     管理员登录函数
     逻辑与读者登录函数类似
     */
    void LibrarianLogin(Librarians* librarian)
    {
    	char pwd[10];
    	printf("请输入密码:\n>");
        scanf("%s", pwd);
    	if (librarian != NULL)
    	{
    		if (strcmp(pwd, librarian->LibrarianPwd) == 0)
    		{
    			printf("登录成功!\n");
    			// 这里可以输出一些相关信息,例如姓名,ID号,管理员等级,登录时间等
    
    			// insert code here..
    			LibrarianMenu(librarian);
    
    		}
    		else
    			printf("ID号或者密码不正确!\n");
    	}
    	else
    		printf("ID号或者密码不正确!\n");    // 这里的输出也可以替换成 ”此卡号不存在“ 之类的,随意
    
    }
    

    Reader.c

    /**
     读者管理模块
     */
    
    #include "Reader.h"
    #include "global.h"
    #include<string.h>
    #include "Reader.h"
    int temp = 0;
    int* nIndex = &temp;
    
     /**
      此函数用于输出登陆的读者信息(已借阅书籍除外,因为这是另外一个函数的功能)
      外部会将登陆的读者结构体传递进此函数
      */
    void OutputReaderInfo(Readers* reader)
    {
    	printf("读者ID:%3d\n", reader->ReaderID);
    	printf("读者密码:%s\n", reader->ReaderPwd);
    	printf("读者状态:%d\n", reader->nDel);
    }
    
    
    
    /**
     此函数用于输出已登陆读者的已借阅书目
     */
    void OutputBorrowedInfo(Readers* reader)
    {
    	int n = 0;
    	for (int i = 0; i < 6; i++)
    		if (reader->BorrowedBook[i].BookNum >= 0)
    			n++;
    	if (n == 0)
    	{printf("未借阅图书\n"); return;}
    	else
    	{for (int i = 0; i < n; i++)
    	{
    		printf("借阅书目:\n");
    		printf("图书名:%s\n", reader->BorrowedBook[i].BookName);
    		printf("作者:%s\n", reader->BorrowedBook[i].Author);
    		printf("图书编号:%d\n\n", reader->BorrowedBook[i].BookNum);
    	}
        }
    }
    
    
    /**
     删除读者函数
     此函数由管理员模块调用
     先进行管理员等级的判断,再进行读者的删除
     需修改相应的链表以及文件
     底层代码由你们编写,可以新建底层函数完成相应功能
     需用到读者查询函数 void InquireReader(Librarians* librarian)
     */
    void DeleteReader(Librarians* librarian)
    {
    	int pId = 0;
    	int result = 0;
    	Readers* pReader = NULL;
    	int index = 0;
    	if (librarian->Level == 1)
    	{
    		printf("权限不够!\n");
    		return;
    	}
    	printf("欢迎您,亲爱的管理员!\n");
    	printf("请输入需要删除的读者ID:");
    	scanf_s("%d", &pId);
    	pReader = InquireReaderByID(pId);
    	if (pReader == NULL)
    	{
    		printf("此读者不存在!\n");
    		return;
    	}
    	pReader->nDel = 1;
    	checkReader(pReader->ReaderID, pReader->ReaderPwd);
    	result = updateReader(pReader, temp);
    	if (result == false)
    	{
    		printf("删除失败!\n");
    		return;
    	}
    	printf("删除成功!\n");
    	return;
    }
    
    
    
    /**
     修改读者函数
     此函数由管理员模块调用
     先进行管理员等级的判断,再进行读者的修改
     需修改相应的链表以及文件
     底层代码由你们编写,可以新建底层函数完成相应功能
     需用到读者查询函数 void InquireReader(Librarians* librarian)
     */
    void ReviseReader(Librarians* librarian)
    {
    	int pId = 0;
    	int result = 0;
    	char newpPwd[10];
    	char aPwd[10] = {0};
    	Readers* pReader = NULL;
    	if (librarian->Level == 1)
    	{
    		printf("权限不够!\n");
    		return;
    	}
    	printf("欢迎您,亲爱的管理员!\n");
    	printf("请输入需要修改的读者ID:");
    	scanf_s("%d", &pId);
    	pReader = InquireReaderByID(pId);
    	if (pReader == NULL)
    	{
    		printf("此读者不存在!\n");
    		return;
    	}
    	printf("现如今只能修改密码,是否继续?:");
    	printf("是:1   否:2\n");
    	scanf("%d", &result);
    	if (result == 2)
    		return;
    	else
    		result = 0;
    	printf("请输入新密码:");
    	scanf("%s", aPwd);
    	strcpy(pReader->ReaderPwd, aPwd);
    	checkToUpdate(pReader->ReaderID);
    	result = updateReader(pReader, temp);
    	if (result == 0)
    	{
    		printf("修改失败!\n");
    		return;
    	}
    	printf("修改成功!\n");
    	return;
    }
    
    
    /**
     添加读者函数
     此函数由管理员模块调用
     先进行管理员等级的判断,再进行读者的添加
     需修改相应的链表以及文件
     底层代码由你们编写,可以新建底层函数完成相应功能
     需用到读者查询函数 void InquireReader(Librarians* librarian) 判断是否有重复卡号
     */
    void AddReader(Librarians* librarian)
    {
    	if (librarian->Level > 1)
    		return;
    	else {
    		Readers reader;
    		char password[10] = { 0 };
    		printf("请输入读者ID:");
    		scanf("%d", &reader.ReaderID);
    		if (InquireReaderByID(reader.ReaderID) != NULL)
    		{
    			printf("ID 已存在\n");
    			return;
    		}
    		int flag = 1;
    		while (flag) {
    			printf("请输入读者密码:");
    			scanf("%s", &password);
    			if (strlen(password) > 10)
    			{
    				printf("密码过长,输入无效\n");
    			}
    			else flag = 0;
    		}
    		strcpy(reader.ReaderPwd, password);
    		memset(reader.BorrowedBook, 0, sizeof(Books) * 6);
    		reader.nDel = 0;
    
    		saveReader(reader);
    	}
    }
    
    /*
    保存读者信息到二进制文件
    */
    void saveReader(Readers reader)
    {
    	FILE* fp = NULL;
    	fp = fopen(pPathReader, "ab");
    	if (fp == 0)
    	{
    		fp = fopen(pPathReader, "wb");
    		if (fp == 0)
    		{
    			printf("打开文件错误\n");
    			return;
    		}
    	}
    	fwrite(&reader, sizeof(reader), 1, fp);
    	printf("添加成功!!\n书上有路,学海无涯,养成读书习惯,加油加油再加油哦!!!\n");
    	OutputReaderInfo(&reader);
    	fclose(fp);
    }
    
    /*
    查找二进制文件中读者信息所在位置
    */
    int checkReader(const int id, const char* pPwd)
    {
    	Readers* preader = (Readers*)malloc(sizeof(Readers));
    	FILE* fp = NULL;
    	fp = fopen(pPathReader, "rb");
    	if (fp == NULL)
    	{
    		
    			printf("打开文件失败!\n");
    			return 0;
    		
    	}
    	temp = 0;
    	while (!feof(fp))
    	{
    		if (fread(preader, sizeof(Readers), 1, fp) != 0)
    		{
    			temp++;
    			if (preader->ReaderID == id)
    			{
    				if (strcmp(preader->ReaderPwd, pPwd) == 0)
    					return temp;
    			}
    		}
    	}
    	free(preader);
    }
    
    
    /*
    修改二进制文件中读者信息
    */
    int updateReader(const Readers* preader, int nIndex)
    {
    	FILE* fp = NULL;
    	int nline = 0;
    	long position = 0;
    	Readers reader;
    	fp = fopen(pPathReader, "rb+");
    	if (fp == NULL)
    		return 0;
    
    	while (!feof(fp) && nline < nIndex)
    	{
    		if (fread(&reader, sizeof(Readers), 1, fp) != 0) {
    			position = ftell(fp);
    			nline++;
    		}
    	}
    	fseek(fp, position, 0);
    	fwrite(preader, sizeof(Readers), 1, fp);
    	fclose(fp);
    	return 1;
    }
    
    void checkToUpdate(const int id)
    {
    	Readers* preader = (Readers*)malloc(sizeof(Readers));
    	FILE* fp = NULL;
    	fp = fopen(pPathReader, "rb");
    	if (fp == NULL)
    	{
    
    		printf("打开文件失败!\n");
    		return;
    
    	}
    	temp = 0;
    	while (!feof(fp))
    	{
    		if (fread(preader, sizeof(Readers), 1, fp) != 0)
    		{
    			temp++;
    			if (preader->ReaderID == id)
    			{
    					return;
    			}
    		}
    	}
    	free(preader);
    }
    

    Manager.c

    /**
     图书管理模块
     */
    #include "global.h"
    #include "Manager.h"
    #include"Librarian_file.h"
     /**
      借阅函数
      底层代码由你们编写,可以新建底层函数完成相应功能
      此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
      借阅成功时需要修改 reader -> BorrowedBook 数组中的变量,相应书籍的 Books -> BookQuantity,以及借阅信息结构体
      并修改文件以及链表中信息
      */
    void BorrowBook(Readers* reader)
    {
    	char bookname[20] = { 0 };
    	char bookauthor[20] = { 0 };
    	int booknum = 0;
    	int i,num=0;
    	Borrow borrow;
    	//输入要借阅的图书名字及编号
    	printf("-----读者归还模块----\n");
    	printf("请输入图书名字及编号\n");
    	printf("图书名字:");
    	scanf("%s", bookname);
    	printf("作者名字:");
    	scanf("%s", bookauthor);
    	printf("图书编号:");
    	scanf("%d", &booknum);
    	//判断该图书是否存在
    	if ((InquireBookByNameNum(bookname, booknum)) == NULL)
    	{
    		printf("该书不存在\n");
    		return;
    	}
    	//判断该用户借书数目
    	for ( i = 0; i < 6; i++)
    	{
    		if ((reader->BorrowedBook[i].BookNum) >= 0)
    		{
    			num++;
    		}
    	}
    	if (0<num < 6)
    	{
    		strcpy(reader->BorrowedBook[num].BookName, bookname);
    		strcpy(reader->BorrowedBook[num].Author, bookauthor);
    		reader->BorrowedBook[num].BookNum = booknum;
    		reader->BorrowedBook[num].nDel = 1;
    		num = checkReader(reader->ReaderID,reader->ReaderPwd);
    		updateReader(reader,i);
    		borrow.p = reader;
    		borrow.BorrowDate = time_t(NULL);
    		num = checkBorrow(reader->ReaderID,reader->ReaderPwd);
    		if (InquireBorrow(reader->ReaderID, &i) == false)
    			saveBorrow(borrow);
    		else updateBorrow(&borrow, num);
    		printf("借书成功\n");
    	}
    	else printf("达到借书上限,无法借阅");
    }
    
    
    /**
     归还函数
     底层代码由你们编写,可以新建底层函数完成相应功能
     此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
     归还成功时需要修改 reader -> BorrowedBook 数组中的变量,相应书籍的 Books -> BookQuantity,以及借阅信息结构体
     并修改文件以及链表中的信息
     */
    void ReturnBook(Readers* reader)
    {
    	// insert code here...
    	char bookname[20] = { 0 };
    	int booknum = 0;
    	int num;
    	Borrow borrow;
    	
    	//输入要归还的图书名字及编号
    	printf("-----读者归还模块----\n");
    	printf("请输入图书名字及编号\n");
    	printf("图书名字:");
    	scanf("%s", bookname);
    	printf("图书编号:");
    	scanf("%d", &booknum);
    
    
    	//判断此卡是否被借出,如果被借出,进行归还
    	for (int i = 0; i < 6; i++)
    	{
    		if ((reader->BorrowedBook[i].BookNum) == booknum && strcmp(reader->BorrowedBook[i].BookName, bookname) == 0)
    		{
    			if (reader->BorrowedBook[i].nDel != 1)
    			{
    				printf("该图书未被借出,还书失败\n");
    				return;
    			}
    			reader->BorrowedBook[i].nDel = 0;
    			num = checkReader(reader->ReaderID, reader->ReaderPwd);
    			updateReader(reader, i);
    			borrow.p = reader;
    			borrow.ReturnDate = time_t(NULL);
    			num = checkBorrow(reader->ReaderID, reader->ReaderPwd);
                updateBorrow(&borrow, num);
    			printf("归还成功\n");
    			return;
    		}	
    	}
    	printf("未借阅该书\n");
    	/*判断此卡是否被借出
    		Books* book = NULL;
    	book = (Books*)malloc(sizeof(Books));
    	book = InquireBookByNameNum(bookname, booknum,reader);
    	if (book == NULL)
    	{
    		printf("图书不存在,还书失败\n");
    		return ;
    	}
    	if (book->nDel != 1)
    	{
    		printf("该图书未被借出,还书失败\n");
    		return;
    	}*/
    }
    
    
    /**
     删除书籍函数
     需先判断管理员等级,再判断是否存在此书籍
     需修改相应的链表以及文件
     底层代码由你们编写,可以新建底层函数完成相应功能
     此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
     */
    void DeleteBook(Librarians* librarian)
    {
    	// insert code here...
    }
    
    
    // 注意!我的框架中将添加书籍的书目功能放在了修改书籍函数中
    // 虽然有一个叫做 添加书籍 的函数,但我的理解为那个函数的功能是添加书籍名称,与 添加读者 类似,而不是改变某书籍的书目
    
    
    /**
    修改书籍函数
    需先判断管理员等级,再判断是否存在此书籍
    需修改相应的链表以及文件
    底层代码由你们编写,可以新建底层函数完成相应功能
    此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
    */
    void ReviseBook(Librarians* librarian)
    {
    	// insert code here...
    }
    
    
    /**
    添加书籍函数
    需先判断管理员等级,再判断是否存在相同书籍
    注意,若两个书籍相同,需要书籍的书名,作者,以及出版社均相同
    需修改相应的链表以及文件
    底层代码由你们编写,可以新建底层函数完成相应功能
    此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
    */
    void AddBook(Librarians* librarian)
    {
        if (librarian->Level > 2)
        {
            printf("宁都不是管理员,在想什么?\n");
            return;
        }
        Books* newbook = NULL;
        int aBookNum = 0;
        char aBookName[40] = {};
        char aAuthor[10] = {};
        int nDel = 0;
        printf("请输入图书编号:");
        scanf("%d",&aBookNum);
        printf("请输入图书名:");
        scanf("%s", aBookName);
        printf("请输入作者:");
        scanf("%s", aAuthor);
        newbook = NumInquireBook(aBookNum);
        if (newbook!=NULL)
        {
            printf("编号已存在\n");
            return;
        }
        newbook = (Books*)malloc(sizeof(Books));
        strcpy(newbook->Author, aAuthor);
        newbook->BookNum = aBookNum;
        newbook->nDel = nDel;
        strcpy(newbook->BookName,aBookName);
        if (saveBooks(newbook) == 0)
        {
            printf("添加失败\n");
            return;
        }
        printf("添加成功!\n图书编号为:%d",aBookNum);
    }
    

    Librarian.c

    /**
     管理员管理模块
     由于所有的管理员操作都要涉及管理员等级,所以所有管理员函数我都传入了登录的管理员结构体,方便等级的查询
     */
    
    #include "Librarian.h"
    #include "Librarian_file.h"
    #include "global.h"
     /**
      此函数用于输出登陆的管理员信息
      外部会将登陆的管理员结构体传递进此函数
      */
    
    void OutputLibInfo(Librarians* librarian)
    {
    	printf("登陆成功");
    		printf("your ID is:%d\nyou level is:%d\n", librarian->LibrarianID, librarian->Level);
    	// insert code here...
    }
    
    
    /**
     此函数为管理读者的上层函数
     会在此选择对读者的操作
     外部会将登陆的管理员结构体传递进此函数
     */
    void ManageReader(Librarians* librarian)
    {
    	int menuNum;
    	ManageReaderMenu();
    	do
    	{
    		puts("请输入菜单编号");
    		printf(">");
    		scanf("%d", &menuNum);
    		switch (menuNum)
    		{
    		case 1:
    			// insert code here...
    			// 读者查询
    			InquireReader(librarian);
    			break;
    
    		case 2:
    			// insert code here...
    			// 读者删除
    			DeleteReader(librarian);
    			break;
    
    		case 3:
    			// insert code here...
    			// 读者修改
    			ReviseReader(librarian);
    			break;
    
    		case 4:
    			// insert code here...
    			// 读者添加
    			AddReader(librarian);
    			break;
    
    		case 0:
    			// insert code here...
    			// 返回上一级目录
    			OutputLibMenu();
    			break;
    
    		default:
    			// insert code here...
    			puts("非法输入!");
    			break;
    		}
    	} while (menuNum);
    }
    
    
    /**
     此函数为管理书籍的上层函数
     会在此选择对书籍的操作
     外部会将登陆的管理员结构体传递进此函数
     */
    void ManageBook(Librarians* librarian)
    {
    	int menuNum;
    	ManageBookMenu();
    	do
    	{
    		puts("请输入菜单编号");
    		printf(">");
    		scanf("%d", &menuNum);
    		switch (menuNum)
    		{
    		case 1:
    			// insert code here...
    			// 图书查询
    			// 此处直接调用通用的 void InquireBook(void) 函数
    			// 这里就无需判断管理员等级了,随便来个读者都能干这事儿
    			InquireBook();
    			break;
    
    		case 2:
    			// insert code here...
    			// 图书删除
    			DeleteBook(librarian);
    			break;
    
    		case 3:
    			// insert code here...
    			// 图书修改
    			ReviseBook(librarian);
    			break;
    
    		case 4:
    			// insert code here...
    			// 图书添加
    			AddBook(librarian);
    			break;
    
    		case 0:
    			// insert code here...
    			// 返回上一级目录
    			OutputLibMenu();
    			break;
    
    		default:
    			// insert code here...
    			puts("非法输入!");
    			break;
    		}
    	} while (menuNum);
    }
    
    
    /**
    此函数为管理管理员的上层函数
    会在此选择对管理员的操作
    外部会将登陆的管理员结构体传递进此函数
    */
    void ManageLib(Librarians* librarian)
    {
    	int menuNum;
    	ManageLibMenu();
    	do
    	{
    		puts("请输入菜单编号");
    		printf(">");
    		scanf("%d", &menuNum);
    		switch (menuNum)
    		{
    		case 1:
    			// insert code here...
    			// 管理员查询
    			InquireLibrarian(librarian);
    			break;
    
    		case 2:
    			// insert code here...
    			// 管理员删除
    			DeleteLibrarian(librarian);
    			break;
    
    		case 3:
    			// insert code here...
    			// 管理员修改
    			ReviseLibrarian(librarian);
    			break;
    
    		case 4:
    			// insert code here...
    			// 管理员添加
    			AddLibrarian(librarian);
    			break;
    
    		case 0:
    			// insert code here...
    			// 返回上一级目录
    			OutputLibMenu();
    			break;
    
    		default:
    			// insert code here...
    			puts("非法输入!");
    			break;
    		}
    	} while (menuNum);
    }
    
    
    /**
    删除管理员函数
    此函数由管理员模块调用
    先进行管理员等级的判断,再进行管理员的删除
    需修改相应的链表以及文件
    底层代码由你们编写,可以新建底层函数完成相应功能
    需用到管理员查询函数 void InquireLibrarian(Librarians* librarian)
    */
    void DeleteLibrarian(Librarians* librarian)
    {
    	// insert code here...
    }
    
    
    /**
    修改管理员函数
    此函数由管理员模块调用
    先进行管理员等级的判断,再进行管理员的修改
    需修改相应的链表以及文件
    底层代码由你们编写,可以新建底层函数完成相应功能
    需用到管理员查询函数 void InquireLibrarian(Librarians* librarian)
    */
    void ReviseLibrarian(Librarians* librarian)
    {
    	// insert code here...
    }
    
    
    /**
    添加管理员函数
    此函数由管理员模块调用
    先进行管理员等级的判断,再进行管理员的添加
    需修改相应的链表以及文件
    底层代码由你们编写,可以新建底层函数完成相应功能
    需用到管理员查询函数 void InquireLibrarian(Librarians* librarian) 判断是否有相同管理员
    */
    void AddLibrarian(Librarians* librarian)
    {
    	if (librarian->Level > 0)
    	{
    		printf("您的权限不够,努力升职吧!!!\n");
    		return;
    	}
    	Librarians* newLib = NULL;
    	int aID = 0;
    	//char aName[18] = {};
    	char aPwd[8] = {};
    	//int phoneNumber = 0;
    	printf("请输入需要添加的管理员的ID:");
    	scanf("%d", &aID);
    	//printf("请输入您的姓名");
    	//scanf("%s", aName);
    	printf("请输入新密码");
    	scanf("%s", aPwd);
    	//printf("请输入您的联系电话");
    	//scanf("%d", &phoneNumber);
    	newLib = InquireLibByID(aID);
    	if (newLib!= NULL)
    	{
    		printf("ID 已存在!");
    		return;
    	}
    /*	newLib = InquireLibByName(aName);
    	if (newLib != NULL)
    	{
    		printf("姓名已存在!");
    		return;
    	}*/
        newLib=(Librarians*)malloc(sizeof(Librarians));//新的管理员
    	newLib->Level = 1;
    	newLib->LibrarianID = aID;
    	//strcpy(newLib->LibrarianName, aName);
    	strcpy(newLib->LibrarianPwd, aPwd);
    	newLib->nDel = 0;
    	//newLib->LibrarianPhoneNum = phoneNumber;
    	if (saveLibrarian(newLib) == 0)
    	{
    		printf("添加失败!");
    		return;
    	}
    	printf("添加成功!\n您的ID为:%3d\n您的等级为:1\n",aID);
    	// insert code here...
    }
    

    Librarian_file.c

    #include"Librarian_file.h"
    #include "global.h"
    int saveLibrarian(const Librarians* lib)
    {
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderLib, "ab");
    	if (fp == 0)
    	{
    		fp = fopen(ppPathReaderLib, "wb");
    		if (fp == 0)
    		{
    			printf("打开文件错误\n");
    			return 0;
    		}
    	}
    	fwrite(lib, sizeof(Librarians), 1, fp);
    	fclose(fp);
    	return 1;
    }
    int saveBooks(const Books* book)
    {
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderBook, "ab");
    	if (fp == 0)
    	{
    		fp = fopen(ppPathReaderBook, "wb");
    		if (fp == 0)
    		{
    			printf("打开文件错误\n");
    			return 0;
    		}
    	}
    	fwrite(book, sizeof(Books), 1, fp);
    	fclose(fp);
    	return 1;
    }
    

    Borrow.c

    /**
     借阅模块
     */
    
    #include "Borrow.h"
    #include "global.h"
     /**
      借阅 / 归还上层函数
      在此函数中选择借阅或者f归还
      将已登陆读者结构体传入此函数,以便于对读者的已借阅书籍进行修改
      */
    void Borrow_ReturnBook(Readers* reader)
    {
    	int menu;
    	ReaderBorrowMenu();
    	do
    	{
    		printf(">");
    		scanf("%d", &menu);
    		switch (menu)
    		{
    		case 1:
    			// 借阅
    			BorrowBook(reader);
    			break;
    
    		case 2:
    			// 归还
    			ReturnBook(reader);
    			break;
    
    		case 0:
    			// 返回上一级目录
    			OutputReaderMenu();
    			break;
    
    		default:
    			puts("非法输入!");
    			break;
    		}
    
    	} while (menu);
    }
    
    /**
     借阅函数
     底层代码由你们编写,可以新建底层函数完成相应功能
     此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
     借阅成功时需要修改 reader -> BorrowedBook 数组中的变量,相应书籍的 Books -> BookQuantity,以及借阅信息结构体
     并修改文件以及链表中信息
     */
    /*void BorrowBook(Readers* reader)
    {
    	// insert code here...
    }*/
    
    
    /**
     归还函数
     底层代码由你们编写,可以新建底层函数完成相应功能
     此函数或者你创建的底层函数可以调用 Inquire.c 中的查询书籍函数
     归还成功时需要修改 reader -> BorrowedBook 数组中的变量,相应书籍的 Books -> BookQuantity,以及借阅信息结构体
     并修改文件以及链表中的信息
     */
    /*void ReturnBook(Readers* reader)
    {
    	// insert code here...
    }*/
    /*
    保存读者信息到二进制文件
    */
    void saveBorrow(Borrow borrow)
    {
    	FILE* fp = NULL;
    	fp = fopen(BORROWPATH, "ab");
    	if (fp == 0)
    	{
    		fp = fopen(BORROWPATH, "wb");
    		if (fp == 0)
    		{
    			printf("打开文件错误\n");
    			return ;
    		}
    	}
    	fwrite(&borrow, sizeof(borrow), 1, fp);
    	fclose(fp);
    }
    
    /*
    查找二进制文件中读者信息所在位置
    */
    int checkBorrow(const int id, const char* pPwd)
    {
    	Borrow* borrow = (Borrow*)malloc(sizeof(Borrow));
    	FILE* fp = NULL;
    	fp = fopen(BORROWPATH, "rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		return 0;
    	}
    	int temp = 0;
    	while (!feof(fp))
    	{
    		if (fread(borrow, sizeof(Borrow), 1, fp) != 0)
    		{
    			temp++;
    			if (borrow->p->ReaderID == id)
    			{
    				if (strcmp(borrow->p->ReaderPwd, pPwd) == 0)
    					return temp;
    			}
    		}	
    		free(borrow);
    	}
    }
    int updateBorrow(const Borrow* pborrow, int nIndex)
    {
    	FILE* fp = NULL;
    	int nline = 0;
    	long position = 0;
    	Borrow borrow;
    	fp = fopen(BORROWPATH, "rb+");
    	if (fp == NULL)
    		return 0;
    
    	while (!feof(fp) && nline < nIndex)
    	{
    		if (fread(&pborrow, sizeof(Borrow), 1, fp) != 0) {
    			position = ftell(fp);
    			nline++;
    		}
    	}
    	fseek(fp, position, 0);
    	fwrite(&pborrow, sizeof(borrow), 1, fp);
    	fclose(fp);
    	return 1;
    }
    

    Inquire.c

    /**
     查询模块
     这个模块是一个偏底层的模块,因为其它所有功能几乎都需要进行查询
     */
    
    #include"Inquire.h"
    #include "global.h"
    
     /**
      读者查询上层函数
      在此函数中进行判断,先判断管理员等级
      然后判断是按ID查询还是按姓名查询,并调用相关函数
      */
    void InquireReader(Librarians* librarian)
    {
    	int readerID = 0;
    	Readers* theReader = NULL;
    	theReader = (Readers*)malloc(sizeof(Readers));
    	printf("请输入想要查找的读者ID:");
    	scanf("%d", &readerID);
    	theReader=InquireReaderByID(readerID);
    	if (theReader == NULL||theReader->nDel==1)
    	{
    		printf("查无此人\n");
    		free(theReader);
    		return;
    	}
    	
    	printf("查找成功!\n");
    	OutputReaderInfo(theReader);
    
    }
    
    
    /**
     管理查询上层函数
     在此函数中进行判断,先判断管理员等级
     然后判断是按ID查询还是按姓名查询,并调用相关函数
     */
    void InquireLibrarian(Librarians* librarian)
    {
    	// 内部逻辑我懒得写了,你自己写吧
    	// 我搭框架搭了一天了
    	// insert code here...
    
    }
    
    
    
    /**
     按读者ID号对读者进行查询,若查询到相应读者,返回对应结构体指针;若未查询到,返回NULL
     此处应在读者信息链表中进行查询
     */
    Readers* InquireReaderByID(int readerID)
    {
    	Readers* reader = NULL;
    	reader = (Readers*)malloc(sizeof(Readers));
    	if (reader == NULL)
    	{
    		printf("储存空间不足,查询失败(位置1)");
    		free(reader);
    		return NULL;
    	}
    	FILE* fp = NULL;
    	fp = fopen(pPathReader, "rb");
    	if (fp == NULL)
    	{
    		fp = fopen(pPathReader, "ab+");
    		if (fp == NULL) {
    			printf("打开文件失败!\n");
    			free(reader);
    			return NULL;
    		}
    	}
    	while (!feof(fp))
    	{
    		if (fread(reader, sizeof(Readers), 1, fp) != 0)
    		{
    			if (reader->ReaderID == readerID)
    			{
    				if (reader->nDel == 0)
    					return reader;
    			}
    		}
    	}
    	free(reader);
    	return NULL;
    }
    
    
    /**
     按读者姓名对读者进行查询,若查询到相应读者,返回对应结构体指针;若未查询到,返回NULL
     此处应在读者信息链表中进行查询
     */
    Readers* InquireReaderByName(int readerName)
    {
    	Readers* reader = NULL;
    	//insert code here...
    
    	return reader;
    }
    
    
    
    /**
     按管理员ID对管理员进行查询
     此函数要求与 Readers* InquireReaderByID(int readerID) 函数类似
     */
    Librarians* InquireLibByID(const int libID)
    {
    	Librarians* librarian =(Librarians*)malloc(sizeof(Librarians));
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderLib, "rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		return NULL;
    	}
    	while (!feof(fp))
    	{
    		if (fread(librarian, sizeof(Librarians), 1, fp) != 0)
    		{
    			if (librarian->LibrarianID == libID)
    			{
    				if (librarian->nDel == 0)
    					return librarian;
    			}
    		}
    	}
    	//insert code here...
    	free(librarian);
    	return NULL;
    }
    
    
    /**
     按管理员姓名对管理员进行查询
     此函数要求与 Readers* InquireReaderByName(int readerID) 函数类似
     */
    /*Librarians* InquireLibByName(const char* libName)
    {
    	Librarians* librarian = (Librarians*)malloc(sizeof(Librarians));
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderLib, "rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		free(librarian);
    		return NULL;
    	}
    	while (!feof(fp))
    	{
    		if (fread(librarian, sizeof(Librarians), 1, fp) != 0)
    		{
    			if (strcmp(librarian->LibrarianName, libName) == 0)
    			{
    				
    				return librarian;
    			}
    		}
    	}
    	free(librarian);
    		return NULL;
    }*/
    
    
    /**
     查询图书顶层函数
     */
    void InquireBook(void)
    {
    	int menu,num;
    	char bookname[10] = {};
    	Books* abook=(Books*)malloc(sizeof(Books));
    	InquireBookMenu();
    	do
    	{
    		printf(">");
    		scanf("%d", &menu);
    		switch (menu)
    		{
    		case 1:
    			//按图书名查询
    			printf("请输入查询书名:");
    			scanf("%s", &bookname);
    			abook = NameInquireBook(bookname);
    			if (abook != NULL)
    			{
    				printf("查找成功");
    				printf("\n编号%d\n书名%s\n作者%s\n状态%d\n", abook->BookNum, abook->BookName, abook->Author, abook->nDel);
    			}
    			else printf("查找失败\n");
    			break;
    			/* 普通查询
    			SimpleInquireBook();
    			*/
    
    		case 2:
    			//按图书编号查询
    			printf("请输入查询书编号:");
    			scanf("%d", &num);
    			abook = NumInquireBook(num);
    			if (abook != NULL)
    			{
    				printf("查找成功");
    				printf("\n编号%d\n书名%s\n作者%s\n状态%d\n", abook->BookNum, abook->BookName, abook->Author, abook->nDel);
    			}
    			else printf("查找失败\n");
    			break;
    			/* 高级查询
    			AdvanceInquireBook();
    			*/
    
    		case 0:
    			// 返回上一级目录
    			OutputReaderMenu();
    			break;
    
    		default:
    			puts("非法输入!");
    			break;
    		}
    
    	} while (menu);
    }
    
    
    /**
     普通查询书籍
     底层代码由你们编写,可以新建底层函数完成相应功能
     */
    void SimpleInquireBook()
    {
    	int menu1;
    	int num = 0;
    	Books* tbook;
    	InquireBookMENU();
    	do {
    		printf(">");
    		scanf("%d",&menu1);
    		switch (menu1)
    		{
    		case 1:
    			AuthorInquireBook();
    			break;
    
    		case 2:
    			printf("请输入查询书编号:");
    			scanf("%d", &num);
    			tbook = NumInquireBook(num);
    			if(tbook!=NULL)
    			printf("查找成功");
    			printf("\n编号%d\n书名%s\n作者%s\n状态%d\n",tbook->BookNum,tbook->BookName,tbook->Author,tbook->nDel);
    			break;
    		case 0:
    			InquireBookMenu();
    			break;
    		}
    	} while (menu1);
    }
    
    
    /**
     高级查询书籍
     底层代码由你们编写,可以新建底层函数完成相应功能
     */
    void AdvanceInquireBook()
    {
    	// insert code here...
    }
    
    Books* AuthorInquireBook()
    {
    	Books* abook = (Books*)malloc(sizeof(Books));
    	char bookauthor[10] = {};
    	printf("请输入查询书作者名:");
    	scanf("%s",bookauthor);
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderBook,"rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		free(abook);
    		return NULL;
    	}
    	while (!feof(fp))
    	{
    		if (fread(abook, sizeof(Books), 1, fp) != 0)
    		{
    			if (strcmp(abook->Author, bookauthor) == 0)
    			{
    				return abook;
    			}
    		}
    		free(abook);
    		return NULL;
    	}
    	return NULL;
    }
    
    Books* NumInquireBook(int num)
    {
    	Books* abook = (Books*)malloc(sizeof(Books));
    	/*int num = 0;
    	printf("请输入查询书编号:");
    	scanf("%d", &num);*/
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderBook, "rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		free(abook);
    		return NULL;
    	}
    	while (!feof(fp))
    	{
    		if (fread(abook, sizeof(Books), 1, fp) != 0)
    		{
    			if ((abook->BookNum) == num)
    			{
    				return abook;
    			}
    		}
    		free(abook);
    		return NULL;
    	}
    	return NULL;
    }
    
    Books* NameInquireBook(char bookname[10])
    {
    	Books* abook = (Books*)malloc(sizeof(Books));
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderBook, "rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		free(abook);
    		return NULL;
    	}
    	while (!feof(fp))
    	{
    		if (fread(abook, sizeof(Books), 1, fp) != 0)
    		{
    			if (strcmp(abook->Author, bookname) == 0)
    			{
    				return abook;
    			}
    		}
    		free(abook);
    		return NULL;
    	}
    	return NULL;
    }
    
    //根据编号和书名查询书籍
    Books* InquireBookByNameNum(char* pbookname, int booknum)
    {
    	Books* abook = (Books*)malloc(sizeof(Books));
    	FILE* fp = NULL;
    	fp = fopen(ppPathReaderBook, "rb");
    	if (fp == NULL)
    	{
    		printf("打开文件失败!\n");
    		free(abook);
    		return NULL;
    	}
    	while (!feof(fp))
    	{
    		if (fread(abook, sizeof(Books), 1, fp) != 0)
    		{
    			if ((abook->BookNum) == booknum && strcmp(abook->BookName, pbookname) == 0)
    			{
    				return abook;
    			}
    		}
    		free(abook);
    		return NULL;
    	}
    }
    
    //根据给出的借阅人编号查询是否第一次借阅
    //是的话返回true
    //不是的话获得文件中的位置
    int InquireBorrow(int borrowernum, int* index)
    {
    	Borrow* pBorrow = NULL;
    	FILE* fp = NULL;
    
    	pBorrow = (Borrow*)malloc(sizeof(Borrow));
    
    	fp = fopen(BORROWPATH, "rb");
    	if (fp == NULL)
    	{
    		return false;
    	}
    
    	while (!feof(fp))
    	{
    		if (fread(pBorrow, sizeof(Borrow), 1, fp) != 0)
    		{
    			if (pBorrow->p->ReaderID == borrowernum)
    			{
    				return true;
    			}
    			index++;
    		}
    		free(pBorrow);
    		return false;
    	}
    }
    

    头文件

    头文件基本上都是函数的声明以及文件的引用,这里我只列出两个具有其它功能的头文件。

    model.h

    #ifndef model_h
    #define model_h
    
    
    /**
     图书信息结构体
     */
    typedef struct Books
    {
    	int BookNum=0;
    	char BookName[40];          // 图书名
    	char Author[10];            // 作者
    	int  nDel;					//借阅状态:0未借出,1已借出,2已删除
    }Books;
    
    
    /**
     借阅信息结构体
     */
    typedef struct Borrow
    {
    	struct Readers* p;          // 借阅人信息
    	int BorrowDate;             // 借阅日期     按视频要求,这里使用 int 型, 应该是按年/月/日的方式保存
    	int ReturnDate;             // 归还日期
    }Borrow;
    
    
    /**
     读者信息结构体
     */
    typedef struct Readers
    {
    	int nDel;					//0未删除,1已删除
    	int ReaderID;               // 读者ID
    	//char ReaderName[18];        // 读者姓名
    	char ReaderPwd[10];         // 密码
    	Books BorrowedBook[6];      // 已借书目, 这里用结构体表示, 同时借阅书目不能超过6本
    	//long int ReaderPhoneNum;    // 读者联系电话
    }Readers;
    
    
    /**
     管理员信息结构体
     */
    typedef struct Librarians
    {
    	int nDel;					//0未删除,1已删除
    	int LibrarianID;            // 管理员ID
    	//char LibrarianName[18];     // 管理员姓名/卡号
    	char LibrarianPwd[10];      // 密码
    	int Level;                  // 管理员等级
    	//long int LibrarianPhoneNum; // 管理员联系电话
    }Librarians;
    
    #endif /* model_h */
    

    global.h

    这个文件用于保存路径。
    一定要记得改这个文件中的路径!

    #define ppPathReaderLib "C:\\Users\\29799\\Desktop\\Library\\Library\\Library\\data\\Librarian.ams"
    #define ppPathReaderBook "C:\\Users\\29799\\Desktop\\Library\\Library\\Library\\data\\Book.ams"
    #define pPathReader "C:\\Users\\29799\\Desktop\\Library\\Library\\Library\\data\\Reader.ams"
    #define BORROWPATH "C:\\Users\\29799\\Desktop\\Library\\Library\\Library\\data\\Borrow.ams"
    
    展开全文
  • c语言 图书管理系统

    千次阅读 2020-06-23 08:56:00
    通过设计一个图书管理系统的程序,全面运用课程的主要知识点,巩固对模块化程序设计、文件操作的理解,提高软件编程能力。 二、涉及的知识点 循环、分支语句、函数、数组、函数、结构体、指针、链表、文件读取操作...

    一、目的
    通过设计一个图书管理系统的程序,全面运用课程的主要知识点,巩固对模块化程序设计、文件操作的理解,提高软件编程能力。
    二、涉及的知识点
    循环、分支语句、函数、数组、函数、结构体、指针、链表、文件读取操作等等
    三、程序已经实现的功能点(用100-200字进行说明)
    (1)程序具有以下功能,操作流程见下图:
    登录界面:
    输入用户名(admin)、密码(20190611),只有用户名、密码同时正确(信息存放在文件中)才能进入系统主菜单,否则需要重新输入用户名、密码。(同时输入3次错误将退出程序)。
    操作功能:分为7个功能:输入1进行图书入库,输入2进行修改信息,输入3进行删除信息,输入4进行图书查询,输入5进行图书总览,输入6进行退出软件,输入7进行修改密码;
    在这里插入图片描述
    修改信息:输入对应的书名与编号,然后进行相应的修改。

    删除信息:输入对应的编号,然后在确认删不删除。如果输入对应的编号不对,则可重新检索和返回主菜单,之后可返回主菜单;
    图书查询:输入1进行书名查询,输入2进行作者查询,输入3进行登录号查询,输入4进行出版社查询,输入5进行模糊查询,查询信息与已有信息符合进入图书总览。输入0返回主菜单;
    图书总览:可查看已录入的全部书籍信息;
    退出软件:退出图书管理信息系统;
    修改密码:先输入旧密码,旧密码正确再连续输入两次新密码(两次输入结果完全相同)后,新密码取代旧密码,并存放到帐户信息文件中,之后跳到登陆界面重新登陆。如果旧密码不对则可返回主菜单;
    (2)定义如下结构体类型:
    “用户名”结构体user:成员有:账号,密码;
    “图书信息”结构体BOOK:成员有:number(登录号)、name(书名)、author(作者名)、type(类型)、publish(出版单位)、time(出版时间)、price(价格)、num(数量);
    (3)帐户信息存放在name.txt文件,图书信息记录保存在mybook中;
    (4)采用模块化程序设计方法来实现,即main()显示主菜单、调用相关函数实现相应功能,起主控作用。
    (5)附加功能:
    用户连续输错密码的次数超过3次,将退出程序;
    四、程序运行截图及说明(要求对每幅图做简要说明,每图限50到100字)
    登录界面:
    输入用户名(admin)、密码(20190611),只有用户名、密码同时正确(信息存放在文件中)才能进入系统主菜单,否则需要重新输入用户名、密码。(同时输入3次错误将退出程序)。如图所示:
    在这里插入图片描述
    操作功能:分为7个功能:输入1进行图书入库,输入2进行修改信息,输入3进行删除信息,输入4进行图书查询,输入5进行图书总览,输入6进行退出软件,输入7进行修改密码,如下图所示:
    在这里插入图片描述
    图书入库:把图书的信息录入一个二进制的文件种。保存成功返回主菜单;按任意键返回主菜单;如下图所示:
    在这里插入图片描述
    修改信息:输入对应的书名与编号,然后图书入库功能进行相应的修改。如下图所示:
    在这里插入图片描述
    删除信息:输入对应的编号,然后在确认删不删除。如果输入对应的编号不对,则可重新检索和返回主菜单,之后可返回主菜单;如下图所示:
    在这里插入图片描述
    图书查询:输入1进行书名查询,输入2进行作者查询,输入3进行登录号查询,输入4进行出版社查询,输入5进行模糊查询,查询信息与已有信息符合进入图书总览。输入0返回主菜单;如下图所示:
    在这里插入图片描述
    图书总览:可查看已录入的全部书籍信息;如下图所示:
    在这里插入图片描述
    退出软件:退出图书管理信息系统。如下图所示:
    在这里插入图片描述
    修改密码:先输入旧密码,旧密码正确再连续输入两次新密码(两次输入结果完全相同)后,新密码取代旧密码,并存放到帐户信息文件中,之后跳到登陆界面重新登陆。如果旧密码不对则可返回主菜单;如下图所示:
    在这里插入图片描述
    在这里插入图片描述
    五、设计心得(不能少于200字)
    本次课程设计,除去各种闲杂时间,大约在设计上花费10个小时,编程上花费20小时,在输入和调试上花费35小时,其中大概有30多个小时是在思考问题。
    这次在调试地过程中,也遇到了很多难题,比如编译不通过,在检查过程中也没有逻辑错误,百思不得其解后,我将出问题的那部分代码放到了新的源代码中来单独测试,通过调试后,从而发现问题并改正。编译通过,程序运行时发生警告,百思不得其解后,我也将出问题的那部分代码放到了新的源代码中来单独测试,通过调试后,发现问题大概出在fscanf语句和fprintf语句上,最后通过查询资料发现,原来在读写文件时,fscanf语句和fprintf语句,在输出和输入表列不用加&符号。这个问题也得到了解决。
    另外还遇到了很多问题,都是采用类似调试——锁定目标——查阅资料——解决的步骤去完成的。
    对于我的程序,我觉得功能还比较完善。但是还有很多可以添加的地方,比如添加一个借书榜单,逾期不还进行登记等等,代码方面还能可以简化一些,多设计一些更加通用的函数,比如建立链表函数,删除数据函数等等。有了这次设计的经验,我相信下次我能做到更好。
    收获:
    通过这次的课程设计我明白了完成一个好的程序,
    首先要有明确的需求分析,只有这样才更好地完善程序;
    第二,需要构建一个清晰合理的框架结构,来让各功能之间有条不紊地运行;
    第三,针对每一个功能,我们要设计准确,简便,人性化的算法及操作逻辑,使各个功能能够给用户带来更好的体验;
    第四,编写代码时要思路清晰,文本清楚,多记备注,画流程图,编写文档,这样能够使自己的思路更加清晰,从而更加有效地避免错误。
    第五,调试过程是整个程序实现最重要的步骤之一,在调试中遇到问题无法解决,应当对着自己的代码,在脑子里执行,逐个排除直至锁定目标,另外编译器上的调试功能也是十分的使用,你可以逐条语句执行和某个值的变化来快速地找到问题的症结。
    另外我对于C语言的知识也掌握得更加深入和牢固了,对于链表,指针,文件的知识也更加得心应手了。在此后我愿意更多地尝试实际地去完成一个程序来让自己的知识得到更好的巩固。
    代码:
    /*

    课程设计项目名称:图书管理信息系统
    
    作者:青春
    
    时间:2019.6.10
    

    */

    #include<stdio.h>
    #include<string.h>
    #include<windows.h>
    #include<conio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include <time.h>
    #define N sizeof(struct BOOK)

    char c;//输入任意键

    struct BOOK //图书信息

    {

    char number[10];   //登录号
    
    char name[10];     //书名
    
    char author[10];    //作者名
    
    char type[10];      //类型
    
    char publish[10];  //出版单位
    
    char time[8];        //出版时间
    
    float price;       //价格
    
    int num;         //数量
    
    int x;
    
    struct BOOK *next;   //指针域
    

    };

    typedef struct BOOK Book;

    typedef Book *book;

    void gaimi(); //修改密码

    void login(); //登录界面

    void HideCursor(); //隐藏光标
    void toxy(int x, int y); //将光标移动到X,Y坐标处

    void over(); //退出

    void menu(); //菜单

    void input_book(); //图书入库

    void save_book(book p);//将图书信息存入文件

    void find_book(); //图书查询

    void print_book(); //图书总览

    void del_book(); //删除图书

    void amend_book(); //修改信息
    book ss();

    void find_name_book(); //按书名查询

    void find_author_book(); //按作者查询

    void find_number_book(); //按登录号查询

    void find_publish_book(); //按出版社查询

    void fuzzy_search(); //模糊查找

    struct user
    {//存放用户名的结构体
    char pwd[20];
    }us;

    char username[15]=“admin”,pwd1[100]; //username[15]原始账号,pwd1修改密码时的比较

    void HideCursor() //隐藏光标

    {

    CONSOLE_CURSOR_INFO cursor_info = {1, 0};

    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);

    }

    void toxy(int x, int y) //将光标移动到X,Y坐标处

    {

    COORD pos = { x , y };

    HANDLE Out = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleCursorPosition(Out, pos);

    }

    void menu() //菜单

    {
    time_t T; //获取系统时间
    struct tm * timenow;
    time ( &T );
    timenow = localtime ( &T );
    do
    {
    system(“cls”); //清屏

        HideCursor();  //隐藏光标
    
        printf("\n\n");
        printf("\t 当前系统时间是: %s",asctime (timenow) );
    
        system("color 3f");//设置一个好看的颜色
    
        char t;
    
        toxy(50,5);//将光标移动到(50,5)坐标处
    
        printf(" 图书管理信息系统 ");
    
        toxy(48,8);
    
        printf("|     1.图书入库      |");
    
        toxy(48,10);
    
        printf("|     2.修改信息      |");
    
        toxy(48,12);
    
        printf("|     3.删除信息      |");
    
        toxy(48,14);
    
        printf("|     4.图书查询      |");
    
        toxy(48,16);
    
        printf("|     5.图书总览      |");
    
        toxy(48,18);
    
        printf("|     6.退出软件      |");
    
        toxy(48,20);
    
        printf("|     7.修改密码      |");
    
        t=getch();    //不回显函数
    
        switch(t)
    
        {
    
            case '1':input_book();break;
    
            case '2':amend_book();break;
    
            case '3':del_book();break;
    
            case '4':find_book();break;
    
            case '5':print_book();break;
    
            case '6':over();break;
    
            case '7':gaimi();break;
    
            default :break;
    
        }
    
    }while(1);
    

    }

    book ss() //将文件中的内容读出到链表中,返回值为表头地址

    {

    FILE *fp;       //文件指针
    
    int n=0;
    
    book head=NULL;
    
    book p2,p,pr=NULL;
    
    fp=fopen("mybook","ab+");     //以只读的方式打开文件
    
    if(fp==NULL)
    
    {
    
        printf("cannot open file\n");
    
    }
    
    while(!feof(fp))        //判断文件位置标志是否移动到文件末尾
    
    {
    
       n++;
    
        p=(book)malloc(N); //向内存申请一段空间
    
       fread(p,N,1,fp);     //将fp所指向的文件中的内容赋给p
    
       if(n==1)
    
       {
    
          head=p;
    
          p2=p;
    
        }
    
        else             //创建链表
    
        {
    
            pr=p2;
    
            p2->next=p;
    
            p2=p;
    
        }
    
    }
    
    if(pr!=NULL)
    
       pr->next=NULL;
    
    else
    
       head=NULL;
    
    fclose(fp);    //关闭文件
    
    return head;   //返回头指针
    

    }

    void input_book() //图书录入

    {

    do
    {
    
        system("cls");
    
        system("color 3f");
    
        char t;
    
        book p;
    
        p=(book)malloc(N);     //申请空间
    
        //输入图书信息
    
        toxy(48,8);
    
        printf("请输入图书登录号(小于10位数):");
    
        scanf("%s",p->number);getchar();
    
        toxy(48,10);
    
        printf("请输入书名(小于10位数):");
    
        scanf("%s",p->name);getchar();
    
        toxy(48,12);
    
        printf("请输入作者名(小于10位数):");
    
        scanf("%s",p->author);getchar();
    
        toxy(48,14);
    
        printf("请输入图书类别(小于10位数):");
    
        scanf("%s",p->type);getchar();
    
        toxy(48,16);
    
        printf("请输入图书出版单位(小于10位数):");
    
        scanf("%s",p->publish);getchar();
    
        toxy(48,18);
    
        printf("请输入图书出版时间(小于8位数):");
    
        scanf("%s",p->time);getchar();
    
        toxy(48,20);
    
        printf("请输入图书价格:");
    
        scanf("%f",&p->price);getchar();
    
        toxy(48,22);
    
        printf("请输入图书数量:");
    
        scanf("%d",&p->num);
    
        save_book(p);
    
        toxy(48,24);
    
        printf("正在保存....");
    
        Sleep(500);   //暂停0.5秒
    
        system("cls");
    
        toxy(46,8);
    
        printf("-------------------------");
    
        toxy(46,9);
    
        printf("|                       |");
    
        toxy(46,10);
    
        printf("| 保存成功!是否继续?  |");
    
        toxy(46,12);
    
        printf("| 1.是             2.否 |");
    
        toxy(46,13);
    
        printf("|                       |");
    
        toxy(46,14);
    
        printf("-------------------------");
    
        while(1)    //利用死循环可有效防止其他按键干扰
        {
    
            t=getch();
            if(t=='1')
            {
                break;
             }
             else if(t=='2')
             {
                menu();
             }
        }
    }while(1);
    

    }

    void amend_book() //修改图书信息

    {

    do
    
    {
    
        system("cls");
    
        system("color 3f");
    
        book head,p;
    
        int i=11,j=0,x;
    
        char ch,t;
    
        FILE *fp;    //文件指针
    
        char _name[10];
    
        char number[10];   //登录号
    
        char name[10];     //书名
    
        char author[10];    //作者名
    
        char type[10];      //类型
    
        char publish[10];  //出版单位
    
        char time[8];        //出版时间
    
        float price;       //价格
    
        int num;         //数量
    
        head=ss();
    
        p=head;
    
        toxy(48,10);
    
        printf("请输入你要修改的图书的书名:");
    
        gets(_name);
    
        while(p!=NULL)    //初始化p->x为0
    
        {
    
            p->x=0;
    
            p=p->next;
    
        }
    
        p=head;    //让p重新指向表头
    
        toxy(20,5);
    
        printf("***********************************************图书信息******************************************************\n");
    
        toxy(20,8);
    
        printf("-------------------------------------------------------------------------------------------------------------\n");
    
        toxy(20,10);
    
        printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量\n");
    
        toxy(20,15);
    
        printf("-------------------------------------------------------------------------------------------------------------");
    
        while(p!=NULL)
    
        {
    
            if(p!=NULL&&strcmp(p->name,_name)==0)
    
            {
    
                toxy(20,i);
    
                j++;
    
                printf("\n%12d:%12s%12s%12s%14s   %14s   %14s         %10.2f%12d\n",j,p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
                p->x=j;    //给符合查询标准的结点标号
    
                i++;
    
            }
    
            p=p->next;
    
        }
    
        if(j==0)                   //如果j=0,即没有进入前面的搜索循环,也就是没有找到相应的信息
    
        {
    
            toxy(50,i);
    
            printf("\n\t\t\t\t\t\t没有找到相应的信息!(按0返回,按1重新搜索)");
    
            while(1)               //死循环是为了防止除0和1的其他按键干扰
    
            {
    
                ch=getch();
    
                if(ch=='0')
    
                {
    
                    menu();break;
    
                }
    
                else if(ch=='1')
    
                {
    
                    break;
    
                }
    
            }
    
            if(ch=='1')     //如果输入的ch等于1,则结束本次循环
    
               continue;
    
        }
    
        while(1)
    
        {
    
            toxy(45,i);
    
            printf("\n\t\t\t\t\t\t请输入您要修改的图书的编号:");
    
            scanf("%d",&x);getchar();
    
            if(x>j||x==0)
    
            {
    
                toxy(45,++i);
    
                printf("输入错误,请重新输入!");
    
                Sleep(500);
    
            }
    
            else
    
            {
    
                break;
    
            }
    
        }
    
        p=head;     //让p重新指向表头
    
        while(p!=NULL&&p->x!=x)   //遍历链表查询符合条件的结点
    
        {
    
            p=p->next;
    
        }
    
        if(p)    //如果p不为空
    
        {
    
            system("cls");
    
            //输入要修改的信息
    
            toxy(48,8);
    
            printf("请输入图书登录号(小于10位数):");
    
            scanf("%s",number);getchar();strcpy(p->number,number);
    
            toxy(48,10);
    
            printf("请输入书名(小于10位数):");
    
            scanf("%s",name);getchar();strcpy(p->name,name);
    
            toxy(48,12);
    
            printf("请输入作者名(小于10位数):");
    
            scanf("%s",author);getchar();strcpy(p->author,author);
    
            toxy(48,14);
    
            printf("请输入图书类别(小于10位数):");
    
            scanf("%s",type);getchar();strcpy(p->type,type);
    
            toxy(48,16);
    
            printf("请输入图书出版单位(小于10位数):");
    
            scanf("%s",publish);getchar();strcpy(p->publish,publish);
    
            toxy(48,18);
    
            printf("请输入图书出版时间(小于8位数):");
    
            scanf("%s",time);getchar();strcpy(p->time,time);
    
            toxy(48,20);
    
            printf("请输入图书价格:");
    
            scanf("%f",&price);getchar();p->price=price;
    
            toxy(48,22);
    
            printf("请输入图书数量:");
    
            scanf("%d",&num);getchar();p->num=num;
    
        }
    
        system("color 3f");
    
        toxy(46,8);
    
        printf("-------------------------\n");
    
        toxy(46,9);
    
        printf("|                       |");
    
        toxy(46,10);
    
        printf("|     是否确认修改?    |\n");
    
        toxy(46,12);
    
        printf("| 1.是             2.否 |\n");
    
        toxy(46,13);
    
        printf("|                       |\n");
    
        toxy(46,14);
    
        printf("-------------------------\n");
    
        while(1)   //利用死循环防止其他按键干扰
    
        {
    
            t=getch();
    
            if(t=='1')
    
            {
    
                break;
    
            }
    
            else if(t=='2')
    
            {
    
                menu();
    
            }
    
        }
    
        system("cls");
    
        toxy(46,10);
    
        printf("正在修改,请稍后....");
    
        fp=fopen("mybook","wb");   //以只写的方式打开名为mybook的二进制文件,打开的同时清空文件中的内容
    
        if(fp==NULL)
    
        {
    
            printf("cannot open file");
    
        }
    
        if(fwrite(head,N,1,fp)!=1)   //将head写入fp所指向的文件中
    
        {
    
            printf("write error!");
    
        }
    
        fclose(fp);   //关闭文件
    
        if(head!=NULL)   //如果head不为空
    
        {
    
            p=head->next;     //让p指向第二个结点
    
            fp=fopen("mybook","ab");   //以追加的方式打开文件
    
            if(fp==NULL)
    
            {
    
                printf("cannot open file");
    
            }
    
            while(p!=NULL)
    
            {
    
                if(fwrite(p,N,1,fp)!=1)//将p写入fp所指向的文件中
    
                {
    
                    printf("write error!");
    
                }
    
                p=p->next;
    
            }
    
            fclose(fp);  //关闭文件
    
        }
    
        Sleep(500);   //暂停0.5秒
    
        system("cls");
    
        toxy(46,10);
    
        printf("修改成功!即将自动返回主菜单....");
    
        Sleep(500);
    
        break;
    
    }while(1);
    

    }

    void del_book() //删除信息

    {

    do
    
    {
    
        system("cls");
    
        system("color 3f");
    
        FILE *fp;
    
        book head,p,pre=NULL;
    
        int j=0,x,i=11;
    
        char name[10];
    
        char t,c,ch;
    
        head=ss();    //调用函数,返回表头地址
    
        toxy(48,10);
    
        printf("请输入你要删除的图书的书名:");
    
        scanf("%s",name);
    
        p=head;
    
        while(p!=NULL)
    
        {
    
            p->x=0;
    
            p=p->next;
    
        }
    
        p=head;
    
        toxy(20,5);
    
        printf("***********************************************图书信息******************************************************");
    
        toxy(20,8);
    
        printf("-------------------------------------------------------------------------------------------------------------");
    
        toxy(20,9);
    
        printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量");
    
        toxy(20,10);
    
        printf("-------------------------------------------------------------------------------------------------------------");
    
        while(p!=NULL)
    
        {
    
            if(p!=NULL&&strcmp(p->name,name)==0)
    
            {
    
                toxy(20,i);
    
                j++;
    
                printf("%d:%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",j,p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
                p->x=j;
    
                i++;
    
            }
    
            p=p->next;
    
        }
    
        if(j==0)                   //如果j=0,即没有进入前面的搜索循环,也就是没有找到相应的信息
    
        {
    
            toxy(50,i);
    
            printf("没有找到相应的信息!(按0返回,按1重新搜索)");
    
            while(1)               //死循环是为了防止除0和1的其他按键干扰
    
            {
    
                ch=getch();
    
                if(ch=='0')
    
                {
    
                    menu();break;
    
                }
    
                else if(ch=='1')
    
                {
    
                    break;
    
                }
    
            }
    
            if(ch=='1')     //如果输入的ch等于1,则结束本次循环
    
               continue;
    
        }
    
        while(1)
    
        {
    
            toxy(45,i);
    
            printf("请输入您要删除的图书的编号:");
    
            scanf("%d",&x);getchar();
    
            if(x>j||x==0)
    
            {
    
                toxy(45,++i);
    
                printf("输入错误,请重新输入!");
    
                Sleep(500);
    
            }
    
            else
    
            {
    
                break;
    
            }
    
        }
    
        system("color 3f");
    
        toxy(46,8);
    
        printf("-------------------------");
    
        toxy(46,9);
    
        printf("|                       |");
    
        toxy(46,10);
    
        printf("|     是否确认删除?    |");
    
        toxy(46,12);
    
        printf("| 1.是             2.否 |");
    
        toxy(46,13);
    
        printf("|                       |");
    
        toxy(46,14);
    
        printf("-------------------------");
    
        while(1)
    
        {
    
            t=getch();
    
            if(t=='1')
    
            {
    
                break;
    
            }
    
            else if(t=='2')
    
            {
    
                menu();
    
            }
    
        }
    
        p=head;
    
        while(p!=NULL&&p->x!=x)
    
        {
    
            pre=p;
    
            p=p->next;
    
        }
    
        if(p!=NULL)
    
        {
    
            if(pre==NULL)
    
            {
    
                head=head->next;
    
            }
    
            else
    
            {
    
                pre->next=p->next;
    
            }
    
        }
    
        free(p);
    
        fp=fopen("mybook","wb");
    
        if(fp==NULL)
    
        {
    
            printf("cannot open file");
    
        }
    
        if(fwrite(head,N,1,fp)!=1)
    
        {
    
            printf("write error!");
    
        }
    
        fclose(fp);
    
        if(head!=NULL)
    
        {
    
            p=head->next;
    
            fp=fopen("mybook","ab");
    
            if(fp==NULL)
    
            {
    
                printf("cannot open file");
    
            }
    
            while(p!=NULL)
    
            {
    
                if(fwrite(p,N,1,fp)!=1)
    
                {
    
                    printf("write error!");
    
                }
    
                p=p->next;
    
            }
    
            fclose(fp);
    
        }
    
        system("cls");
    
        toxy(46,10);
    
        printf("正在删除,请稍后....");
    
        Sleep(500);
    
        system("cls");
    
        toxy(46,8);
    
        printf("-------------------------");
    
        toxy(46,9);
    
        printf("|                       |");
    
        toxy(46,10);
    
        printf("|  删除成功,是否继续? |");
    
        toxy(46,12);
    
        printf("| 1.是             2.否 |");
    
        toxy(46,13);
    
        printf("|                       |");
    
        toxy(46,14);
    
        printf("-------------------------");
    
        while(1)
    
        {
    
            c=getch();
    
            if(c=='1')
    
            {
    
                break;
    
            }
    
            else if(c=='2')
    
            {
    
                menu();
    
            }
    
        }
    
    }while(1);
    

    }

    void print_book() //图书总览

    {

    system("cls");
    
    system("color 3f");
    
    book head,p;
    
    int i=11;
    
    int sum=0;
    
    head=ss();
    
    toxy(20,5);
    
    printf("***********************************************图书总览******************************************************\n");
    
    toxy(20,8);
    
    printf("-------------------------------------------------------------------------------------------------------------\n");
    
    toxy(20,9);
    
    printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量\n");
    
    toxy(20,11);
    
    printf("-------------------------------------------------------------------------------------------------------------\n");
    
    if(head==NULL)
    
    {
    
        toxy(45,11);
    
        printf("书库暂时没有书哦~赶快去添加几本吧^_^(按任意键返回)");
    
        getch();
    
        menu();
    
    }
    
    p=head;
    
    while(p!=NULL)
    
    {
    
        toxy(20,i);
    
        printf("%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
        i++;
    
        sum+=p->num;//计算图书总量
    
        p=p->next;
    
    }
    
    toxy(48,7);
    
    printf("图书总量为:%d",sum);
    
    toxy(45,i);
    
    printf("按任意键返回");
    
    getch();//不回显函数
    

    }

    void find_book() //查询图书

    {

    do
    
    {
    
        system("cls");  //清屏
    
        system("color 3f");
    
        char t;
    
        toxy(50,5);
    
        printf(" 图书查询");
    
        toxy(48,8);
    
        printf("|     1.书名  查询      |");
    
        toxy(48,10);
    
        printf("|     2.作者  查询      |");
    
        toxy(48,12);
    
        printf("|     3.登录号查询      |");
    
        toxy(48,14);
    
        printf("|     4.出版社查询      |");
    
        toxy(48,16);
    
        printf("|     5.模糊  查询      |");
    
        toxy(50,18);
    
        printf("按0返回主菜单");
    
        t=getch();
    
        switch(t)
    
        {
    
            case '0':menu();break;
    
            case '1':find_name_book();break;
    
            case '2':find_author_book();break;
    
            case '3':find_number_book();break;
    
            case '4':find_publish_book();break;
    
            case '5':fuzzy_search();break;
    
            default :break;
    
         }
    
    }while(1);
    

    }

    void find_name_book() //按名字查询

    {

    system("cls");
    

    system(“color 3f”);

    book head,p;
    
    int i=11;
    
    head=ss();
    
    char name[10];
    
    toxy(48,8);
    
    printf("请输入您要查询图书的书名:");
    
    gets(name);
    
    toxy(48,10);
    
    printf("正在查询....");
    
    Sleep(500);
    
    p=head;
    
    toxy(20,5);
    
    printf("***********************************************图书总览******************************************************");
    
    toxy(20,8);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    toxy(20,9);
    
    printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量");
    
    toxy(20,10);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    while(p!=NULL)
    
    {
    
        if(p!=NULL&&strcmp(p->name,name)==0)
    
        {
    
            toxy(20,i);
    
            printf("%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
            i++;
    
        }
    
        p=p->next;
    
    }
    
    toxy(45,i);
    
    printf("按任意键返回!");
    
    getch();
    
    find_book();
    

    }

    void find_author_book() //按作者名查询

    {

    system("cls");
    
    system("color 3f");
    
    book head,p;
    
    int i=11;
    
    head=ss();
    
    char author[10];
    
    toxy(48,8);
    
    printf("请输入您要查询图书的作者名:");
    
    gets(author);
    
    toxy(48,10);
    
    printf("正在查询....");
    
    Sleep(500);
    
    p=head;
    
    toxy(20,5);
    
    printf("***********************************************图书总览******************************************************");
    
    toxy(20,8);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    toxy(20,9);
    
    printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量");
    
    toxy(20,10);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    while(p!=NULL)
    
    {
    
        if(p!=NULL&&strcmp(p->author,author)==0)
    
        {
    
            toxy(20,i);
    
            printf("%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
            i++;
    
        }
    
        p=p->next;
    
    }
    
    toxy(45,i);
    
    printf("按任意键返回!");
    
    getch();
    
    find_book();
    

    }

    void find_number_book() //按图书编号查询

    {

    system("cls");
    

    system(“color 3f”);

    book head,p;
    
    int i=11;
    
    head=ss();
    
    char number[10];
    
    toxy(48,8);
    
    printf("请输入您要查询图书的登录号:");
    
    gets(number);
    
    toxy(48,10);
    
    printf("正在查询....");
    
    Sleep(500);
    
    p=head;
    
    toxy(20,5);
    
    printf("***********************************************图书总览******************************************************");
    
    toxy(20,8);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    toxy(20,9);
    
    printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量");
    
    toxy(20,10);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    while(p!=NULL)
    
    {
    
        if(p!=NULL&&strcmp(p->number,number)==0)
    
        {
    
            toxy(20,i);
    
            printf("%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
            i++;
    
        }
    
        p=p->next;
    
    }
    
    toxy(45,i);
    
    printf("按任意键返回!");
    
    getch();
    
    find_book();
    

    }

    void find_publish_book() //按出版商查询

    {

    system("cls");
    
    system("color 3f");
    
    book head,p;
    
    int i=11;
    
    head=ss();
    
    char publish[10];
    
    toxy(48,8);
    
    printf("请输入您要查询图书的出版社:");
    
    gets(publish);
    
    toxy(48,10);
    
    printf("正在查询....");
    
    Sleep(500);
    
    p=head;
    
    toxy(20,5);
    
    printf("***********************************************图书总览******************************************************");
    
    toxy(20,8);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    toxy(20,9);
    
    printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量");
    
    toxy(20,10);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    while(p!=NULL)
    
    {
    
        if(p!=NULL&&strcmp(p->publish,publish)==0)
    
        {
    
            toxy(20,i);
    
            printf("%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
            i++;
    
        }
    
        p=p->next;
    
    }
    
    toxy(45,i);
    
    printf("按任意键返回!");
    
    getch();
    
    find_book();
    

    }

    void fuzzy_search() //模糊查询

    {

    system("cls");
    

    system(“color 3f”);

    book head,p;
    
    int i=11;
    
    head=ss();
    
    char information[10];
    
    toxy(48,8);
    
    printf("请输入您要查询图书的信息:");
    
    gets(information);
    
    toxy(48,10);
    
    printf("正在查询....");
    
    Sleep(500);
    
    p=head;
    
    toxy(20,5);
    
    printf("***********************************************图书总览******************************************************");
    
    toxy(20,8);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    toxy(20,9);
    
    printf("登录号        书名        作者名         图书类别         出版单位         出版时间          价格        数量");
    
    toxy(20,10);
    
    printf("-------------------------------------------------------------------------------------------------------------");
    
    while(p!=NULL)
    
    {
    
        if(p!=NULL&&(strcmp(p->name,information)==0||strcmp(p->author,information)==0||strcmp(p->number,information)==0||strcmp(p->publish,information)==0))
    
        {
    
            toxy(20,i);
    
            printf("%s%14s%14s%14s   %14s   %18s         %.2f%12d\n",p->number,p->name,p->author,p->type,p->publish,p->time,p->price,p->num);
    
            i++;
    
        }
    
        p=p->next;
    
    }
    
    toxy(45,i);
    
    printf("按任意键返回!");
    
    getch();
    
    find_book();
    

    }

    void save_book(book p) //将p中内容写入文件

    {

    FILE *fp;    //文件指针
    
    fp=fopen("mybook","ab");   //以追加的方式打开名字为mybook的二进制文件
    
    if(fp==NULL)
    
    {
    
        printf("cannot open file");
    
    }
    
    if(fwrite(p,N,1,fp)!=1)   //将p所指向的一段大小为N的内容存入fp所指向的文件中
    
    {
    
        printf("write error");
    
    }
    
    fclose(fp);    //关闭文件
    

    }

    void over() //退出软件

    {
    system(“color 3f”);

    char t;
    
    toxy(48,11);
    
    printf("-----------------------");
    
    toxy(48,12);
    
    printf("|   您确定要退出吗?  |");
    
    toxy(48,14);
    
    printf("| 1.确定     2.取消   |");
    
    toxy(48,15);
    
    printf("-----------------------");
    
    while(1)
    
    {
    
        t=getch();         //输入t
    
        switch(t)
    
        {
    
            case '1':
    
            system("cls");
    
           system("color 3f");
    
            toxy(48,10);
    
            printf("正在安全退出....");
    
            Sleep(1000);     //暂停1秒
    
            system("cls");
    
            system("color 3f");
    
            toxy(48,10);
    
            printf("已安全退出软件");
    
            toxy(48,12);
    
            printf("谢谢使用!");
    
            toxy(48,14);
    
            printf("by-by^_^");
    
            exit(0);  break; //终止程序
    
            case '2':
    
            menu(); break;   //调用函数,进入菜单
    
            default :break;
    
        }
    
    }
    

    }

    void login()//登录界面

    {
    int i=0,k=0,j;

    FILE *fp;
    
    if((fp=fopen("name.txt","r"))==NULL)
    {
        strcpy(us.pwd,"20190611");
    }//如果文件打开错误初始密码
    
    fscanf(fp,"%s",us.pwd);
    
    char username1[15];   //定义与原始密码相比较的变量
    
    system("color 3f");		//系统函数,color显示颜色,3湖蓝色,f是亮白色
    
    printf("\n\n");
    
    printf("\t 系统默认用户名:admin,密码:20190611\n");
    
    printf("\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    
    printf("\t┃**********************************************************┃\n");
    
    printf("\t┃***┏━━━━━━━━━━━━━━━━━━━━━━━━┓***┃\n");
    
    printf("\t┃***┃************************************************┃***┃\n");
    
    printf("\t┃***┃***                                         ****┃***┃\n");
    
    printf("\t┃***┃***         欢迎使用图书管理信息系统        ****┃***┃\n");
    
    printf("\t┃***┃***                                         ****┃***┃\n");
    
    printf("\t┃***┃***                                         ****┃***┃\n");
    
    printf("\t┃***┃***                 张锦涛                  ****┃***┃\n");
    
    printf("\t┃***┃***                                         ****┃***┃\n");
    
    printf("\t┃***┃***               2019年6月11日              ****┃***┃\n");
    
    printf("\t┃***┃***                                         ****┃***┃\n");
    
    printf("\t┃***┃************************************************┃***┃\n");
    
    printf("\t┃***┗━━━━━━━━━━━━━━━━━━━━━━━━┛***┃\n");
    
    printf("\t┃**********************************************************┃\n");
    
    printf("\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
    
    for(i=0;i<3;i++){
    
    printf("\n请输入用户名:");
    
    gets(username1);
    
    printf("\n请输入6位密码:");
    
    for(j=0;j<100;j++)
    {
        pwd1[j]=getch();
    
        if(pwd1[j]=='\r')
    
        break;
    
        printf("*");
    }
    
    pwd1[j]='\0';
    
    if((strcmp(username,username1)==0)&&(strcmp(us.pwd,pwd1)==0))
    {
        printf("\n\n您已经成功登录");
    
        k=1;
    
        for(i=0;i<20;i++){
    
            printf(".");
    
            Sleep(100);	}
    
    system("cls");
    

    menu(); //跳转到主界面

    break;
    }
    

    else
    printf("\n\n用户名或密码无效,请重新输入:\n");

    continue;
    }
    if(k==0)
    printf("\n连续输入错误3次将退出程序\n");

    Sleep(1000);			//程序暂停函数(单位毫秒),本次暂停1000毫秒
    return;//连续三次错误跳转退出界面
    

    }

    void gaimi()//修改密码程序
    {

    int j;
    
    system("cls");
    
    FILE *fp;
    
    if((fp=fopen("name.txt","w"))==NULL){
    
        printf("文件打开错误!");exit(0); }
    
    printf("\n请输入您的原始密码:\n");
    
    fflush(stdin); 		//清除缓冲
    
    for(j=0;j<100;j++){
    
        us.pwd[j]=getch();
    
        if(us.pwd[j]=='\r')
    
        break;
    
        printf("*");	}
    
        us.pwd[j]='\0';
    
    if((strcmp(us.pwd,pwd1)==0)){
    
        printf("\n请输入您要修改的密码\n");
    
        for(j=0;j<100;j++){
    
        us.pwd[j]=getch();
    
        if(us.pwd[j]=='\r')
    
        break;
    
        printf("*");	}
    
        us.pwd[j]='\0';
    
        fflush(stdin); 		//清除缓冲
    
        printf("\n请再次确认你的密码\n");
    
        for(j=0;j<100;j++){
    
        pwd1[j]=getch();
    
        if(pwd1[j]=='\r')
    
        break;
    
        printf("*");	}
    
        pwd1[j]='\0';
    
        if((strcmp(us.pwd,pwd1)==0)){
    
            printf("\n\n密码修改成功,请重新登录。\n");
    
            fprintf(fp,"%s",us.pwd);
    
            Sleep(2000);
    
            system("cls");
    
            login();	}
    
        else {
    
            printf("\n\n两次密码不符合,本次服务到此结束!\n\n");
    
            printf("\n\n按任意键返回\n");
    
            c=getch();
    
            system("cls");
    
            menu();
        }
    }
    
    else{
    
        printf("\n密码输入错误!\n\n");
    
        printf("\n\n按任意键返回\n");
    
        c=getch();
    
        system("cls");
    
        menu();
       }
    

    }

    int main() //主函数
    {
    login();
    return 0;
    }

    展开全文
  • C语言 图书管理系统(课程设计)

    万次阅读 多人点赞 2018-12-28 09:13:06
    C语言编程模拟一个简单的图书管理系统,主要包括图书的库存信息,每一本书的借阅信息以及每一个人的借书信息。 系统功能: (1)借阅资料管理(对相关资料进行添加,删除,修改,查询等操作) (2)借阅管理...

    图书管理系统

    任务背景:
    18级软件工程大一上学期C语言课程设计。

    编写目的:
    把学习的C语言知识运用到实际上,强化能力。

    任务描述:
    C语言编程模拟一个简单的图书管理系统,主要包括图书的库存信息,每一本书的借阅信息以及每一个人的借书信息。

    系统功能:
    (1)借阅资料管理(对相关资料进行添加,删除,修改,查询等操作)
    (2)借阅管理(包括借出操作,还书操作,续借处理)
    (3)读者管理(定义读者借书数量和相关的借阅时间等信息)
    (4)统计分析(当前借阅和相关资料状态,资料状态统计,借阅统计)

    系统设计分析(程序流程图,函数模块分析):

    程序源代码:
    添加链接描述

    /*图书管理系统   终极确定版*/ 
    
    #include<stdio.h>
    #include<stdlib.h>  //有system函数
    #include<conio.h>   //有通过控制台进行数据输入和数据输出的函数
    #include<string.h>  //有字符数组
    #include<math.h>
    #define  LEN   sizeof(struct library)//有关图书信息的结构体
    #define  LEN1  sizeof(struct reader) //有关读者信息的结构体
    
    struct library//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%图书馆结构体
    {
    	int xcl;//库存
    	float price;//单价
    	char name[20],author[20],chuban[20],kind[20],shuhao[20];
    	struct library *next;
    };
    
    
    struct reader//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%读者结构体
    {
    	int zhenghao;
    	char mingzi[20],riqi[20],zname[20];
    	struct reader *next;
    };
    
    
    void mainmenu()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~主菜单
    { 
    	system ("cls");//清除屏幕先前显示的内容 ,往下运行(在stdlib.h头文件中) 
    	printf("\n\n\n				^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ");
    	printf("\n\n\n						1.__库存图书信息__\n\n");
    	printf("\n\n 						2.__借阅图书系统__\n\n");
    	printf("\n\n 						3.__退出管理系统__\n\n");
    	//printf("\n\n 					 ^~^请您按键选择and回车确定哦~.~\n\n\n");
    	printf(" 				^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ ^.^ \n");
    }
    
    
    void menu1() //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~显示 图书信息 菜单
    { 
    	system ("cls");
    	printf("\n\n\n				 ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ");
    	printf("\n\n 				    		1.__图书入库__\n\n");
    	printf("\n 						2.__图书清理__\n\n");
    	printf("\n 						3.__图书查询__\n\n");
    	printf("\n 						4.__库存概览__\n\n");
    	printf("\n 						5..返回上一层..\n\n");
    	//printf("\n 					^~^请您按键选择and回车确定哦*.*\n\n");
    	printf(" 				 ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ ^~^ \n");
    }
    
    
    void menu2() //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~显示 借阅系统 菜单
    { 
    	system ("cls");
    	printf("请输入书号,书名,作者或类别查询:\n");
    	printf("类别(科学技术 语言文学 政治经济 历史地理 意识形态 艺术)\n\n");
    }
    
    
    void main1()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~main1函数
    {
    	void tsgxx();//声明 图书馆信息 函数 
    	void jieshuxitong();//声明 借书系统 函数
    	char choose;
    	
    	mainmenu();//显示主菜单 
    	scanf("%c",&choose);
    	
    	switch(choose)//功能函数选择
    	{ 
    		case '1':	tsgxx();
    					break;
    					
    		case '2':	jieshuxitong();	
    					break;	
    					
    		case '3':   system ("cls");
    					printf("\n\n\n  删改内容已经保存了呢 ^、^\n\n\n  任意键安全退出哦 ^、^\n\n");
    					exit(0);//exit关闭所有文件,终止正在执行的程序。exit(0):正常退出
    					break;
    	}
    }
    
    
    void tsgxx()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~图书馆信息函数
    { 
    	void tsjinku();//声明 图书进库 函数 
    	void shanchu();//声明 删除图书信息 函数 
    	void chaxunts();//声明 查询图书 函数 
    	void kucunxinxi();//声明 显示库存 函数 
    	char choose;
    	
    	menu1();//显示 图书信息 菜单 
    	getchar();//吞掉一个显示出menu1函数后的进行下一步的回车      
    	                                                                                                                         
    	scanf("%c",&choose);
    	
    	for (;;)//在返回上一级前循环输入                                                                                                                                                    //??? 
    		switch(choose)
    		{ 
    			case '1':	tsjinku();
    						break;
    			case '2':	shanchu();
    						break;
    			case '3':	chaxunts();
    						break;
    			case '4':	kucunxinxi();
    						break;
    			case '5':	main1();//返回上一级 
    						break;
    		}
    }
    
    
    int kucungs()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~统计库存图书文本个数函数
    { 
    	FILE *fp;//定义一个指针 
    	int txcl=0,n;
    	float tprice=0;
    	char tname[20]={'\0'},tauthor[20]={'\0'},tchuban[20]={'\0'},tkind[20]={'\0'},tshuhao[20]={'\0'};
    	
    	fp=fopen("library.txt","r");//打开文件  fopen("文件名.文件类型","权限"); 
    	
    	for (n=0;!feof(fp);n++)//逐个读文件(feof(fp):检测是否以及读取到文件尾部,到达尾部返回1,否则返回0)
    		fscanf(fp,"%s%s%s%s%s%d%f",tshuhao,tname,tauthor,tchuban,tkind,&txcl,&tprice);
    	n--;
    	
    	fclose(fp);//关闭文件
    	return (n);//返回个数
    }
    
    
    int duzhegs()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~统计读者文本个数函数
    { 
    	FILE *fp;
    	int zhenghao=0,n;
    	char mingzi[20]={'\0'},riqi[20]={'\0'},zname[20]={'\0'};
    	
    	fp=fopen("reader.txt","r");//打开文件
    	
    	for (n=0;!feof(fp);n++)//逐个读文件
    		fscanf(fp,"%d%s%s%s ",&zhenghao,&mingzi,&riqi,&zname);
    		
    	fclose(fp);//关闭文件
    	return (n);//返回个数
    }
    
    
    void tsjinku()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~图书进库函数
    { 
    	FILE *fp;
    	int xcl=0,n=0;
    	float price=0;
    	char name[20]={'\0'},author[20]={'\0'},kind[20]={'\0'},chuban[20]={'\0'},shuhao[20]={'\0'};
    	char hitkey; 
    	
    	system ("cls");
    	
    	if ((fp=fopen("library.txt","a"))==NULL)//打开图书馆文件,不存在此文件则新建
    	{ 
    		fp=fopen("library.txt","w");
    		fclose(fp);
    	}
    	
    	fp=fopen("library.txt","a");//追加写打开进行录入数据 
    	
    	printf("\n	请您输入需要添加的图书信息:\n\n	书号	书名	作者	出版社	类别	进库量	单价");
    	printf("\n\n	(类别:哲学,文学,教育,艺术,科学,教材,小说,其它)\n	(书号:(XXX) )\n"); 
    	
    	for (;hitkey!=27;)//如果输入一组数据后敲了回车键则循环输入 
    	{ 
    		if (n!=0)
    			printf("请输入:\n");//从第二次输入开始提示请输入 
    			
    		scanf("%s%s%s%s%s%d%f",shuhao,name,author,chuban,kind,&xcl,&price);		
    		fprintf(fp,"%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",shuhao,name,author,chuban,kind,xcl,price);
    		
    		printf("继续输入请按回车\n结束输入请按Esc\n");
    		n++;
    		
    		hitkey=getch();//记录敲击进来的键                                                                                                                                          		
    		for (;hitkey!=13&&hitkey!=27;)//13:\r回车  27:ESC退出                                                                                                                          
    			hitkey=getch();//敲击错误可重复敲击 
    	}
    	fclose(fp);
    	
    	printf("\n保存成功,按任意键返回上一层!");
    	getch();
    	tsgxx();//返回上一层
    }
    
    
    void shanchu()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~删除图书信息
    { 
    	struct library *head=NULL;
    	struct library *p,*p1,*p2;
    	int txcl=0,n=0,j,i;
    	float tprice=0;
    	char tname[20]={'\0'},tauthor[20]={'\0'},tchuban[20]={'\0'},tkind[20]={'\0'},ttname[20]={'\0'},tshuhao[20]={'\0'};
    	char hitkey;
    	FILE *fp;
    	
    	if ((fp=fopen("library.txt","r"))==NULL)//打开文件
    	{ 
    		system ("cls");
    		
    		printf("\n库存图书为零!无法删除图书!\n请按任意键返回\n");
    		getch();
    		
    		tsgxx();
    	}
    	else
    	{ 
    		system ("cls");
    		
    		printf("\n请输入你要删除的书名:");//输入删除图书书名
    		scanf("%s",&ttname);
    		
    		printf("\n确认删除请回车,取消请按Esc\n");
    		
    		hitkey=getch();
    		
    		for(;hitkey!=13&&hitkey!=27;)
    			hitkey=getch();
    			
    		if (hitkey==27)
    			tsgxx();
    		
    		fp=fopen("library.txt","r");
    		
    		for (j=0;!feof(fp);)//读文件夹信息,统计在库图书个数
    		{ 
    			j++;
    			fscanf(fp,"%s%s%s%s%s%d%f",tshuhao,tname,tauthor,tchuban,tkind,&txcl,&tprice);
    		}
    		
    		fclose(fp);
    		
    		fp=fopen("library.txt","r");
    		
    		for (i=1;i<j;i++)
    		{ 
    			fscanf(fp,"%s%s%s%s%s%d%f",tshuhao,tname,tauthor,tchuban,tkind,&txcl,&tprice);
    			
    			if (strcmp(ttname,tname))//比较名字,将不同名字的信息复制到链表                                                                                     //??? 
    			{ 
    				n++;//相同返回值为0不执行if语句继续循环,不同则执行直到将所有不同的书名建立成链表
    				if (n==1)//建立链表
    				{ 
    					p1=p2=(struct library*)malloc(LEN);
    					head=p1;
    				}
    				else
    				{ 
    					p2->next=p1;
    					p2=p1;
    					p1=(struct library*)malloc(LEN);//新建链表
    				}
    				
    				strcpy(p1->shuhao,tshuhao);//复制书号
    				strcpy(p1->name,tname);//复制书名
    				strcpy(p1->author,tauthor);//复制作者名字
    				strcpy(p1->chuban,tchuban);//复制出版社
    				strcpy(p1->kind,tkind);//复制类别
    				p1->xcl=txcl;//复制个数
    				p1->price=tprice;//复制单价
    			}
    		}
    		
    		if (n==0)//如果图书只有一项且这一项刚好和要删除的相同
    		{ 
    			head=NULL;
    		}
    		else//建立链表的最后剩余一个储存空间,所以封底
    		{
    			p2->next=p1;
    			p1->next=NULL;
    			fclose(fp);
    		}
    	}
    	
    	fp=fopen("library.txt","w");//清空文件,只写打开,然后关闭
    	fclose(fp);
    	
    	fp=fopen("library.txt","a");//追加文件
    	p=head;
    	
    	for (;p!=NULL;)//把链表内容覆盖到文件
    	{
    		fprintf(fp,"%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",p->shuhao,p->name,p->author,p->chuban,p->kind,p->xcl,p->price);
    		p=p->next;
    	}
    	
    	fclose(fp);//关闭文件
    	system ("cls");
    	
    	printf("\n删除成功 \n按任意键返回上一层\n");
    	getch();//返回上一层
    	tsgxx();
    }
    
    
    void chaxunts()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~查询函数
    {
    	FILE *fp;
    	char choose;
    	int txcl=0,n=0,k=0,i,l;
    	float tprice=0;
    	char tname[20]={'\0'},tauthor[20]={'\0'},chazhao[20]={'\0'},tchuban[20]={'\0'},
    	tshuhao[20]={'\0'},tkind[20]={'\0'};
    	
    	if ((fp=fopen("library.txt","r"))==NULL)//打开文件
    	{ 
    		system ("cls");
    		printf("\n记录文件不存在!按任意键返回");
    		getch();
    		tsgxx();
    	}
    	
    	l=kucungs();//获得库存图书个数
    	menu2();//提示输入菜单 
    	scanf("%s",chazhao);
    	system ("cls");
    	
    	for (i=0;i<l;i++)
    	{ 
    		fscanf(fp,"%s%s%s%s%s%d%f",tshuhao,tname,tauthor,tchuban,tkind,&txcl,&tprice);//读文件信息
    		if(!strcmp(chazhao,tshuhao)||!strcmp(chazhao,tname)||!strcmp(chazhao,tauthor)||!strcmp(chazhao,tkind))//在库存图书里面模糊检索 
    		{
    			if (k==0)
    			{
    				printf("查询结果:\n\n");
    				printf("书号\t书名\t作者\t\t出版社\t\t类别\t\t现存量\t单价\n");
    			}
    			printf("%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",tshuhao,tname,tauthor,tchuban,tkind,txcl,tprice);
    			k++;
    		}
    	}
    	
    	if (k==0)//没有这本书 
    	{ 
    		system ("cls");
    		printf("\n无符合记录!\n");
    		getch();
    		tsgxx();
    	}
    	
    	fclose(fp);
    	getch();//返回
    	tsgxx();
    }
    
    	
    void kucunxinxi()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~显示库存图书信息
    {
    	FILE *fp;
    	int xcl=0,n=0,i=0,j=0;
    	float price=0;
    	char name[20]={'\0'},author[20]={'\0'},kind[20]={'\0'},chuban[20]={'\0'},shuhao[20]={'\0'};
    	
    	if ((fp=fopen("library.txt","r"))==NULL)//打开文件夹
    	{
    		system ("cls");
    		printf("\n记录文件不存在!");
    	}
    	n= kucungs();
    	
    	if (n==0)
    	{ 
    		system ("cls");
    		printf("\n无任何记录!");
    	}
    	
    	fp=fopen("library.txt","r");//打开只读文件
    	system ("cls");
    	printf("书号\t书名\t作者\t\t出版社\t\t类别\t\t库存量\t单价\n");
    	
    	for (i=0;i<n;i++)//输出所有在库图书信息
    	{
    		fscanf(fp,"%s%s%s%s%s%d%f",shuhao,name,author,chuban,kind,&xcl,&price);
    		printf("%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",shuhao,name,author,chuban,kind,xcl,price);
    	}
    	
    	fclose(fp);
    	printf("\n按任意键返回\n");
    	getch();//返回
    	tsgxx();
    }
    
    
    void menu3() //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~显示借书系统主菜单
    {
    	system ("cls");
    	
    	printf("\n 				`~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` ");
    	printf("\n\n						1.借书登记\n\n");
    	printf("\n\n						2.还书登记\n\n");
    	printf("\n\n						3.借阅情况查看\n\n");
    	printf("\n\n						4.返回上一层\n\n");
    	//printf("\n\n					^~^请按键选择and回车确定哦 *·*\n");
    	printf("\n 				`~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~` `~`\n ");	
    	
    	return ;
    }
    
    
    void jieshuxitong()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~借书系统函数
    { 
    	void jieshu();
    	void huanshu();
    	void duzhexinxi();//函数声明
    	char choose;
    	
    	menu3();
    	getchar();//吞掉一个显示出menu3函数后的进行下一步的回车 
    	
    	scanf("%c",&choose);//选择功能
    	
    	for (;;)
    		switch(choose)
    		{ 
    			case '1':	jieshu();
    						break;	
    						
    			case '2':	huanshu();
    						break;
    						
    			case '3':	duzhexinxi();
    						break;
    						
    			case '4':	main1();
    						break;
    		}
    }
    
    
    void jieshu()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~借书函数
    {
    	FILE *fp,*fp3;
    	struct library *head=NULL;
    	struct library *p,*p1,*p2;
    	int txcl=0,i,loop,zhenghao=0,n=0,k=0,t=0,flag=0;
    	float tprice=0;
    	char tname[20]={'\0'},tauthor[20]={'\0'},tchuban[20]={'\0'},tkind[20]={'\0'},tshuhao[20]={'\0'},
    	ttname[20]={'\0'},mingzi[20]={'\0'},riqi[20]={'\0'},zname[20]={'\0'};
    	char hitkey=0;
    	
    	system ("cls");
    	
    	{
    		if ((fp=fopen("library.txt","r"))==NULL)//打开图书馆文件
    	    {
    			system ("cls");
    			printf("\n 图书馆无库存!按任意键退出!");
    			getch();
    			exit (0);
    		}
    		else
    		{
    			{
    				printf("\n请输入借阅书名:\n请输入:\n");//输入书名
    				scanf("%s",zname);
    				k= kucungs();//统计图书馆文件个数
    				for (i=0;i<k;i++)//读入图书馆信息,存储到链表
    				{
    					fscanf(fp,"%s%s%s%s%s%d%f",tshuhao,tname,tauthor,tchuban,tkind,&txcl,&tprice);
    					n++;
    					if (n==1)
    					{ 
    						p1=p2=(struct library*)malloc(LEN);
    						head=p1;
    					}
    					else
    					{ 
    						p2->next=p1;
    						p2=p1;
    						p1=(struct library*)malloc(LEN);//新建链表
    					}
    				
    					strcpy(p1->shuhao,tshuhao);//复制书号	
    					strcpy(p1->name,tname);//复制书名
    					strcpy(p1->author,tauthor);//复制作者
    					strcpy(p1->chuban,tchuban);//复制出版社
    					strcpy(p1->kind,tkind);//复制类别
    					p1->xcl=txcl;//复制现存量
    					p1->price=tprice;//复制单价
    				}
    			
    				if (n==0)
    					head=NULL;
    				else
    				{
    					p2->next=p1;
    					p1->next=NULL;
    					fclose(fp);
    				}
    			}
    		}
    		
    		p=head;
    		for (;p!=NULL;)//读链表
    		{
    			if(!(strcmp(p->name,zname)))//判断要借书的是否存在
    			{
    				flag=1;//标记取1
    				loop=p->xcl;//现存量减1
    				(p->xcl)--;
    			}
    			p=p->next;
    		}
    		
    		if(flag&&(loop>0))//存在借书书名且现存量大于0,把库存量变化后的链表存入文件
    		{ 
    			fp=fopen("library.txt","w");
    			fclose(fp);
    			fp=fopen("library.txt","a");
    			p=head;
    			
    			for (;p!=NULL;)
    			{
    				fprintf(fp,"%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",p->shuhao,p->name,p->author,p->chuban,p->kind,p->xcl,p->price);
    				p=p->next;
    			}
    			free(p);//把链表内容覆盖文件
    			fclose(fp);
    		}
    			
    		if(flag&&(loop>0))//存在借书书名且现存量大于0
    		{
    			{
    				if ((fp3=fopen("reader.txt","r"))==NULL)//建读者文件夹
    				{ 
    					fp3=fopen("reader.txt","w");//打开只读文件
    					fclose(fp3);			
    				}			
    				fp3=fopen("reader.txt","a");//以附加的方式打开文件		
    			}
    				
    			{
    				{
    					if (n!=0)
    						printf("\n请按以下格式输入读者信息:\n 证号 姓名 归还日期 借书书名\n请输入:");//录入读者信息
    						
    					scanf("%d %s %s %s",&zhenghao,&mingzi[20],&riqi[20],&zname[20]);
    					fprintf(fp3,"\n%-8d%-23s%-18s%-10s\n",zhenghao,&mingzi[20],&riqi[20],&zname[20]);
    					fp=fopen("library.txt","w");//删除图书馆文件信息
    					fclose(fp);
    					fp=fopen("library.txt","a");//重新追加信息
    					p=head;
    					
    					for (;p!=NULL;)//把链表内容覆盖图书馆文件
    					{
    						fprintf(fp,"%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",p->shuhao,p->name,p->author,p->chuban,p->kind,p->xcl,p->price);	
    						p=p->next;
    					}
    					
    					fclose(fp);
    					fclose(fp3);
    					printf("成功!按任意键返回\n");
    					getch();//返回
    					
    					jieshuxitong();//调用借阅系统
    				}
    			}
    			jieshuxitong();//调用借阅系统
    		}
    		else
    			printf("此书已被借完!按任意键返回!");//否则输出此书已被借完
    
    		getch();//返回		
    		jieshuxitong();//调用借阅系统
    	}
    }
    
    
    void huanshu()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~还书函数
    {
    	FILE *fp,*fp3;	
    	struct reader *head=NULL;
    	struct reader *p,*p1,*p2;
    	struct library *lhead1=NULL;
    	struct library *zp1,*lp1,*lp2;
    	int txcl=0,i;
    	float tprice=0;
    	char tname[20]={'\0'},tauthor[20]={'\0'},tkind[20]={'\0'},
    	tchuban[20]={'\0'},ttname[20]={'\0'},tshuhao[20]={'\0'};
    	int ttzhenghao=0,tzhenghao=0,n=0,k=0,t=0,flag=0;
    	char tmingzi[20]={'\0'},triqi[20]={'\0'},tzname[20]={'\0'},ttzname[20]={'\0'};
    	char hitkey=0;
    	
    	system ("cls");
    	
    	{	
    		if ((fp=fopen("reader.txt","r"))==NULL)//不存在读者文件,则输出不能还书
    		{
    			system ("cls");
    			printf("\n 不存在借书者!按任意键退出!");
    			getch();
    			exit (0);
    		}
    		else
    		{
    			{			
    				printf("\n请输入读者证号和书名:\n请输入:");	
    				scanf("%d %s",&ttzhenghao,ttzname);//输入还书证号和书名
    				k=duzhegs();//获取读者文件夹信息个数
    				
    				for (i=0;i<k;i++)//读取读者文件夹信息
    				{
    					fscanf(fp,"%d%s%s%s\n ",&tzhenghao,tmingzi,triqi,tzname);
    					if((ttzhenghao==tzhenghao)&&!strcmp(ttzname,tzname))//如果证号书名存在,则标记为1
    					flag=1;//strcmp:将两个字符串进行比较返回比较结果,相同返回0 
    				}
    				fclose(fp);
    				
    				fp=fopen("reader.txt","r");//打开读者文件
    				if(flag)
    				{	
    					for (i=0;i<k;i++)//将读者文件复制到链表
    					{
    						fscanf(fp,"%d%s%s%s\n ",&tzhenghao,tmingzi,triqi,tzname);//读取文件信息	
    						if(!((ttzhenghao==tzhenghao)&&!strcmp(ttzname,tzname)))
    						{ 
    							n++;
    							if (n==1)
    							{ 
    								p1=p2=(struct reader*)malloc(LEN1);//新建链表开辟内存 
    								head=p1;//head指向第一个节点 
    							}
    							else
    							{ 
    								p2->next=p1;
    								p2=p1;
    								p1=(struct reader*)malloc(LEN1);//新建链表
    							}
    							
    							p1->zhenghao=tzhenghao;//复制证号
    							strcpy(p1->mingzi,tmingzi);//复制读者名字						
    							strcpy(p1->riqi,triqi);//复制日期						
    							strcpy(p1->zname,tzname);//复制书名					
    						}
    					}
    					
    					if (n==0)
    						head=NULL;
    					else
    					{
    						p2->next=p1;				
    						p1->next=NULL;					
    						fclose(fp);				
    					}
    					
    					fp=fopen("reader.txt","w");//清空读者文件
    					fclose(fp);
    					
    					fp=fopen("reader.txt","a");//追加信息
    					
    					p=head;
    					
    					for (;p!=NULL;)//把链表内容覆盖读者文件			
    					{				
    						fprintf(fp,"\n%-8d%-23s%-18s%-10s\n",p->zhenghao,p->mingzi,p->riqi,p->zname);						
    						p=p->next;					
    					}
    					
    					free(p);				
    					fclose(fp);				
    				}
    			}
    		}
    	}
    	
    	if(flag)//标记为1,即还书时
    	{
    		{
    			{
    				printf("确认还书请按回车!");
    				
    				for (;hitkey!=13&&hitkey!=27;)
    				
    				hitkey=getch();
    				
    				if (hitkey==13)
    					printf("成功!按任意键返回!");
    				
    				n=0;flag=0;
    				fp3=fopen("library.txt","r");//打开图书馆文件
    				k=kucungs();//获取图书馆文件个数
    				
    				for (i=0;i<k;i++)//将图书馆文件复制到链表
    				{					
    					fscanf(fp3,"%s%s%s%s%s%d%f",tshuhao,tname,tauthor,tchuban,tkind,&txcl,&tprice);//读取信息					
    					n++;				
    					if (n==1)				
    					{ 
    						lp1=lp2=(struct library*)malloc(LEN);//新建链表
    						lhead1=lp1;
    					}
    					else
    					{ 
    						lp2->next=lp1;
    						lp2=lp1;
    						lp1=(struct library*)malloc(LEN);//新建链表
    					}
    					
    					strcpy(lp1->shuhao,tshuhao);//复制书号				
    					strcpy(lp1->name,tname);//复制书名			
    					strcpy(lp1->author,tauthor);//复制作者					
    					strcpy(lp1->chuban,tchuban);//复制出版社					
    					strcpy(lp1->kind,tkind);//复制类别					
    					lp1->xcl=txcl; //复制现存量					
    					lp1->price=tprice;//复制单价					
    				}
    				
    				if (n==0)
    				{
    					lhead1=NULL;
    				}
    				else				
    				{				
    					lp2->next=lp1;				
    					lp1->next=NULL;	
    					fclose(fp3);		
    				}
    			}
    		}
    		
    		zp1=lhead1;		
    		for (;zp1!=NULL;)
    		{		
    			if(!(strcmp(zp1->name,ttzname)))//寻找书名相同			
    			++(zp1->xcl);//现存量加1			
    			zp1=zp1->next;
    		}
    		
    		fp3=fopen("library.txt","w");//清空图书馆文件
    		fclose(fp);
    		fp3=fopen("library.txt","a");//追加信息
    		zp1=lhead1;
    		
    		for (;zp1!=NULL;)//把链表内容覆盖图书馆文件
    		{
    			fprintf(fp3,"%-8s%-9s%-14s%-16s%-18s%-7d%-8.2f\n",		
    				zp1->shuhao,zp1->name,zp1->author,zp1->chuban,zp1->kind,zp1->xcl,zp1->price);		
    			zp1=zp1->next;
    		}
    		
    		fclose(fp3);
    		getch();//返回
    		jieshuxitong();//调用借阅系统
    	}
    	else
    		printf("不存在此信息!按任意键返回!");
    	
    	getch();//返回
    	jieshuxitong();//调用借阅系统
    }
    
    
    void duzhexinxi()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~显示读者借书情况函数
    {
    	FILE *fp;
    	int zhenghao=0,xcl=0,n=0,i=0,j=0;
    	char mingzi[20]={'\0'},riqi[20]={'\0'},zname[20]={'\0'};
    	
    	if ((fp=fopen("reader.txt","r"))==NULL)//打开读者文件夹
    	{
    		system ("cls");
    		printf("\n记录文件不存在!");
    	}
    	n=duzhegs();
    	
    	if (n==0)
    	{ 
    		system ("cls");
    		printf("\n无任何记录!");
    	}
    	
    	fp=fopen("reader.txt","r");
    	system ("cls");
    	printf("\n证号\t读者姓名\t\t还书日期\t书名\n");
    	
    	for (i=0;i<n;i++)//输出文件信息
    	{	
    		fscanf(fp,"%d%s%s%s\n ",&zhenghao,mingzi,riqi,zname);	
    		printf("\n%-8d%-23s%-18s%-10s\n", zhenghao,mingzi,riqi,zname);
    	}
    	
    	fclose(fp);
    	printf("\n按任意键返回\n");
    	getch();//返回
    	jieshuxitong();//调用借阅系统
    }
    
    void begin()
    {
    	char num;
    	printf("\n\n\n\n					教师端登录请按 1 \n\n					学生端登录请按 2 \n\n");
    	scanf("%c",&num);getchar();
    }
    
    int main()//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~主函数调用
    {
    	system("color 3F");//蓝色背景白色字体 
    	begin();
    	main1();
    	return 0;
    }
    
    												   ——2018.12.28
    												   ——by Z方 的 '^旧时光~'
    
    展开全文
  • C语言图书管理系统源代码

    热门讨论 2014-12-01 18:05:20
    这是一个关于图书管理系统的一个编程软件,实训期间的必备!里面代码运行完全正确,代码简单易懂,可操作性强!
  • 在大学学习编程快一年了,目前正在学习java,偶然翻到上学期C语言课程设计的课设---图书管理系统。今天跟大家分享一下,算是记录自己学习的足迹吧。水平有限,仅供参考。 #include<stdio.h> #include<...
  • 本次C语言课程设计的任务是综合运用C语言知识编程实现一个图书管理系统,其中图书管理信息(图书编号、名称、价格、作者、出借状态等)采用文件保存。主要完成如下功能,并提供选择菜单实现功能选择。 (1)数据录入...
  • 1. 要求利用C语言面向过程的编程思想来完成图书管理系统的设计; 2. 突出C语言的函数特征,以多个函数实现每一个子功能; 3. 画出功能模块图; 4. 进行简单界面设计,能够实现友好的交互; 5. 具有清晰的程序...
  • C语言课程设计票务管理系统 C语言课程设计1西安交通大学城市学院C语言程序设计课程设计报告题目图书信息管理系统专业自动化班级自动化101姓名陈蕾完成日期2012年5月31日C语言课程设计2目录第一章项目背景错误未定义...
  • 话不多说,直接上代码 ...学习C/C++编程知识,想要成为一个更加优秀的程序员,或者你学习C/C++的时候有难度,可以来博主的C语言C++零基础编程学习圈,里面不仅有学习视频和...微信公众号:C语言编程学习基地 ...
  • 项目名称:图书管理系统 项目作者:宁哥 开发工具:Visual Studio 2017 编程语言:C语言 意义:链表、文件存储、数据加解密、多文件开发综合应用 功能描述: 1:增、删、改、查 2:数据加解密 3:文件数据库,带记忆...
  • 大学C语言课程设计——图书管理系统C语言版本) 必不可缺的头文件: #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include <...
  • 关于图书管理系统c语言编程 具体流程及说明里面都有 大家看下
  • 图书管理系统C语言

    2013-06-14 16:17:56
    虽然是一个简单的系统,但确实花了不少时间,从最开始的三四十行,一步步完善,到现在的接近三百行,当然从中也学到了不少,获得了不少.每一个困难被克服后就是无尽的成就感.如果对这个感兴趣,可以到WIN-TC上运行试一下....
  • 图书管理系统提供图书信息管理以及借还管理。图书信息至少包括:图书编号、书名、价格、作者、借还状态,提供以下功能: 1.增加图书信息,录入; 2.查询已有的所有图书信息; 3.删除图书; 4.修改图书信息;...
  • 图书管理系统提供图书信息管理以及借还管理。图书信息至少包括:图书编号、书名、价格、作者、借还状态,提供以下功能: 1.增加图书信息,录入; 2.查询已有的所有图书信息; 3.删除图书; 4.修改图书信息;...
  • 纸上学来终觉浅,绝知此事要躬行。...图书管理系统提供图书信息管理以及借还管理。图书信息至少包括:图书编号、书名、价格、作者、借还状态,提供以下功能: 1.增加图书信息,录入; 2.查询已有的所有图书信息; 3..
  • 优秀设计 C语言程序设计实习报告 图书管理系统设计 SLUON SLUON 历时一周的计算机实习让我学到了很多知识换句话说让我重新认识了 C语言这门课程以前在我的脑海中计算机编程只是无数枯燥的代码很 是让人头疼的东西...
  • 图书管理系统C语言程序设计实验分析报告C语言程序设计实验报告系别专业班级姓名学号时间实验题目 图书信息管理系统一、实验目的(1)熟练掌握C语言的相关操作。(2)综合应用C语言的知识,独立完成一个完整的系统,提高...
  • 更多源码(比如,学生成绩管理系统、天气管理系统、员工管理系统、图书管理系统等等,都可以来我的编程学习基地) 自学C/C++不易,此路应携手前行。 如果你想跟着小编一起学编程的话! ...
  • 图书管理系统

    2013-03-29 13:28:53
    利用C语言编写系统 并设置密码。简洁明了。通俗易懂,完全是初学者走向编程之路的良药。

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 133
精华内容 53
关键字:

c语言编程图书管理系统

c语言 订阅