============
#ifndef _DATA_STRUCT_H_
#define _DATA_STRUCT_H_
/ *Estructura del libro*/
Estructura del libro
{
ID del libro largo sin firmar/*Número del libro*/
char Nombre del libro[512] ;/*Título*/
char Writer[512];/*Autor*/
int Número actual/*Cantidad existente*/
Libro * pSiguiente/ *Información del siguiente libro*/
};
/*Estructura del índice del libro*/
Índice estructural
{
ID de libro largo sin firmar/*número de libro*/
Índice * pNext/*puntero de índice siguiente*/
};
/*Estructura de información de préstamo */
Préstamo de estructura
{
ID de libro largo sin firmar/*Número de libro de préstamo*/
char BookName[512];/ *Título*/
Entero largo sin signo StuID/*Número de identificación de biblioteca*/
Tiempo de devolución de caracteres[512];/*Fecha de devolución*/
Préstamo * pNext/*próxima información de préstamo*/
};
#endif/*_DATA_STRUCT_H_*/
Archivo de implementación:
= ==============
// BookManage.cpp: define el punto de entrada para la aplicación de consola.
//
# incluir ltstdio.h gt
# incluir ltstdlib.h gt
# incluir ltstring.h gt
# include lttime.h gt
#Include " DataStruct.h "
/*
Diseño del curso de estructura de datos (basado en C) Sistema de gestión de libros
Puntos de bonificación: 100-14 días Hace 23 horas, la edición finalizó.
Descripción del problema
Las actividades comerciales básicas de la gestión de libros incluyen el almacenamiento, despacho, préstamo y devolución de libros. Intente diseñar un sistema de gestión de biblioteca para completar las actividades comerciales anteriores con la ayuda de un sistema informático.
Requisitos básicos
(1) El registro de cada libro incluye al menos cinco elementos: número de libro, título, cantidad disponible por el autor e inventario total.
(2) Cree una tabla de índice (tabla lineal) para el número de libro para mejorar la eficiencia de la búsqueda.
(3) Las operaciones y funciones a implementar por el sistema se definen a continuación:
1 Catalogación y almacenamiento: los libros nuevos se compran, clasifican y cuentan, para luego registrarse en la cuenta de la biblioteca. Si el libro ya está en la cuenta, sólo se incrementará el inventario total.
2 Préstamo: Si la cantidad actual de un libro es mayor que cero, se prestará un libro y se cancelará el número de tarjeta de biblioteca del prestatario y la fecha de devolución.
Devolución: cancela el registro del prestatario y cambia la cantidad de libros existente.
*/
/*Obtener la cadena de entrada*/
void GetInput(char *pInOutStr, int StrLen, bool only getnumber = false);
p>
/*Mostrar el menú principal y volver a la selección*/
int ShowMainMenu();
/*Para la operación de almacenamiento de libros, el parámetro Se pasa el encabezado de la lista de libros. El puntero del puntero y el puntero del encabezado de información del índice, porque el valor del puntero del encabezado puede cambiar dentro de esta función */
void PutBookInLib(Book **pHead , Index * * pIndex);
/*Consulta el inventario de la biblioteca, la consulta no cambia los datos, por lo que el puntero entrante puede ser*/
void query booklib(Book * pHead );
/*Pedir prestado un libro* /
void BorrowBook(Préstamo **pPréstamo, libro * pHead
/*Consulta y préstamo*/);
void query Préstamo(Préstamo * p Préstamo );
/*Devolución Libro*/
void DevoluciónLibro(Préstamo**pPréstamo, Libro * pHead);
/*Publicar libros, indexar y pedir prestado información de la lista enlazada*/
void eliminar lista de libros(Libro * * pHead);
void DeleteIndexList(Index * * pIndex);
void DeleteBorrowList(Borrow * * p Borrow);
int main()
{
/*Lista de libros puntero de título*/
Libro * pBookHead = NULL
/*Puntero de encabezado de índice de libro*/
Índice * pIndexHead = NULL
/*Puntero de encabezado de información de préstamo*/
Préstamo * pBorrowHead = NULL
/*Se utiliza para guardar la entrada del usuario actual*/
int elegido num =- 1;
while(true)
{
núm elegido = ShowMainMenu();
Cambiar (seleccionar menú)
{
Caso 0 ：/*Salir*/
{
Regresar 0
Romper
}
Caso 1:/*Almacenamiento de libros*/
{
PutBookInLib( amp; pBookHead amp; pIndexHead
);Pausa;
}
Caso 2: /*Consultar inventario*/
{
QueryBookLib(pBookHead);
Printf("Presione Enter para continuar...");
fflush(stdin);
getchar();
sistema ("cls");
Pausa ;
}
Caso 3: /*Préstamo de libros*/
{
QueryBookLib(pBookHead);
Pedir prestados libros.
pBorrowHead, pBookHead);
Break;
}
Caso 4: /*Consultar y pedir prestado*/
{
consulta de préstamo(pBorrowHead);
Printf("Presione Enter para continuar...");
fflush(stdin);
getchar ();
Sistema ("cls");
Romper
}
Caso 5: /*Devolver el libro* /
{
consulta pedir prestado(pBorrowHead);
devolver libro(amp; pBorrowHead, pBookHead
Break; p >
}
}
}
Eliminar lista de libros (amppBookHead);
DeleteIndexList(amp; pIndexHead);
DeleteBorrowList(amp;pBorrowHead);
fflush(stdin);
getchar();
Devuelve 0;
}
/*Obtener la cadena de entrada*/
void GetInput(char *pInOutStr, int StrLen, bool OnlyGetNumber)
{
memset(pInOutStr, 0x0, StrLen);
fflush(stdin);
int Count = 0
mientras (verdadero)
p>{
char TmpC = 0;
fred(ampTmpC, 1, 1, stdin
if ( 10 =); = TmpC)
{
break;
}
if(solo obtiene el número amp; ampTmpC gt= ' 0 ' amp ampTmpC lt = '9' )
{
pinout str[Count]= TmpC;
count;
}
Otros
{
pinout str[Count]= TmpC;
count;
}
}
}
/*Mostrar el menú principal y volver a la selección*/
int ShowMainMenu()
{
char InPutStr[1024];
Sin entrada:
printf(" \ n \ n \ n ");
printf("); * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
Printf("*Sistema de gestión de biblioteca* \ n ");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");
printf("\n");
Printf("Por favor seleccione:\n");
Printf("\t1. Almacenamiento de libros\n");
p>
Printf("\t2. Comprobar inventario\n ");
Printf("\t3.Préstamo de libros\n");
Printf("\t4 . Consulta de préstamo\n");
Printf("\t5. Devolver el libro\n");
Printf("\t0.
Salir \n ");
printf(" \n ");
printf(" \t entrada: ");
GetInput(InPutStr, 1024 , verdadero);
if(strlen(input str) lt; 1)
{
System("cls");
ir a NO _ INPUT
}
Regresar atoi(input str);
}
/*Operación de almacenamiento de libros*/
void PutBookInLib(Libro * * phe head, Index **pIndex)
{
Libro * pWork = * pHead
Ninguno Símbolo length BookID = 1;
char InPutStr[1024];
/*Primero calcule el número de identificación del libro almacenado actualmente*/
if ( NULL = = pWork)
{
ID de libro = 1;
}
Otro
{
mientras(pWork- gt; pNext! = vacío)
{
p trabajo = p trabajo- gt; p>
}
BookID = pWork- gt; BookID 1;
}
Libro * pTmpNewBook = (Libro *)(malloc(sizeof(Book))
memset(pTmpNewBook, 0x0, sizeof(Book));
Índice * PTM Índice = (Índice *)(malloc(sizeof(Index))); (Índice PTM, 0x0, tamaño de (Índice));
pTmpNewBook- gt; BookID = BookID
PTM index- gt; "cls ");
Printf("Ingrese el nombre del libro: ");
GetInput(InPutStr, 1024);
strcpy(pTmpNewBook- gt; BookName); , input str);
System("cls");
printf(" lt; lt s gt gt\n ", pTmpNewBook- gt; título del libro
Printf("Autor del libro:");
GetInput(InPutStr, 1024);
strcpy(pTmpNewBook- gt;Writer, input str);
System("cls");
printf(" lt; lt s gt gt\n ", pTmpNewBook- gt; título del libro);
Printf("Autor: s\ n ", pTmpNewBook- gt; escritor);
Printf("Cantidad de recibo: ");
GetInput(InPutStr, 1024, true);
pTmpNewBook- gt; número actual =
atoi(input str);
if(pTmpNewBook- gt; número actual lt1)
{
System("cls");
Printf("¡Cantidad de compra incorrecta! (Presione Enter para continuar...) ");
fflush(stdin);
getchar(); >Sistema("cls");
Retorno;
}
if ( NULL == *pHead)
{< / p>
* pHead = pTmpNewBook
* pIndex = pTmpIndex
}
Otros
{
Libro * pWork = * pHead
mientras (pWork!=null)
{
if(strcmp(p work- gt;BookName, pTmpNewBook- gt ; BookName) = = 0 amp; ampstrcmp(p work- gt; Writer, pTmpNewBook- gt; Writer) == 0)
{
Work- gt; - gt; número actual;
Regreso
}
p trabajo = p trabajo- gt; >
pWork = * pHead
while(pWork- gt; pNext!=null)
{
p work = p work- gt;
}
Work- gt; pNext = pTmpNewBook
Índice * pWork2 = * pIndex
mientras(pwork 2- gt; pNext ! = vacío)
{
pwork 2 = pwork 2- gt;pNext
}
pwork 2- gt;pNext = pTmpIndex
}
System("cls");
Printf("Libro:
fflush(stdin);
p>
getchar();
System("cls");
}
/*Publicar lista enlazada e índice de libros lista enlazada*/
void DeleteBookList(Libro **pHead)
{
Libro * pWork = * pHead
Libro * pNext = pWork
mientras (NULL! = pWork)
{
pNext = p work- gt; pNext
Gratis (pWork);
pWork = pNext
}
}
anular eliminar lista de índice(Índice * * pIndex)
{
Índice * pWork = * pIndex
Índice * pNext = pWork
mientras ( NULL!= pWork)
{
>
pNext = p trabajo- gt;pNext
Gratis (pWork);
pWork = pNext
}
}
void DeleteBorrowList(Préstamo * * p Préstamo)
{
Préstamo * pWork = * pPréstamo
Préstamo * pNext = pWork
mientras ( NULL!= pWork)
{
pNext = p trabajo- gt;pNext
Gratis(pWork);
p>
pWork = pNext
}
}
/*Consulta el inventario de la biblioteca La consulta no cambia los datos. , por lo que el puntero entrante puede ser */
void QueryBookLib(Book *pHead)
{
Book * pWork = pHead
int recuento total = 0;
mientras (NULL! = pWork)
{
recuento total;
p trabajo = p trabajo - gt; pNext
}
System("cls");
Printf("Actualmente hay ***d libros en stock, de la siguiente manera: \n = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
pWork = pHead
mientras (NULL! = pWork)
{
Printf("Número: [ d] Título:
p>
p trabajo = p trabajo- gt;pNext
}
printf(" = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \n", recuento total);
}
/*Préstamo de libro*/
void BorrowBook(Préstamo **pPréstamo, Libro *pHead)
{
char InPutStr[1024 ];
bool HadTheBook = false
Préstamo * pTmpBorrow =(Préstamo *)(malloc(sizeof(Préstamo)));
memset(pTmpBorrow, 0x0 , sizeof(Borrow));
Printf("Ingrese el número de libros que desea pedir prestado:");
GetInput(InPutStr, 1024, verdadero);
pTmpBorrow- gt;BookID = atoi(input str);
Libro * pWorkBook = pHead
while ( pWorkBook! =nulo)
{<
/p>
if(pWorkBook- gt; BookID = = pTmpBorrow- gt; BookID)
{
HadTheBook = true
Break;
p>
}
p libro de trabajo = p libro de trabajo- gt; pNext
}
if (HadTheBook)
{
if(pWorkBook- gt; número actual lt1)
{
System("cls");
Printf("Libro
fflush(stdin);
getchar();
system("cls");
gratis( pTmpBorrow);
p>
Devolver;
}
}
Otros
{
System("cls ");
Printf("¡El número de libro d no existe!\n(Presione Enter para continuar...)", pTmpBorrow- gt; BookID);
fflush(stdin);
getchar();
system("cls");
gratis(pTmpBorrow);
return;
}
strcpy(pTmpBorrow- gt; BookName, pWorkBook- gt; título del libro);
Printf("Por favor); ingrese su número de tarjeta de la biblioteca: ");
GetInput(InPutStr, 1024, true);
pTmpBorrow- gt; StuID = atoi(input str);
if(0 = = pTmpBorrow- gt; StuID)
{
System("cls");
Printf("El número de tarjeta de la biblioteca no existe (ingrese un número entero para el número de tarjeta de la biblioteca)!\n(Presione la tecla Intro para continuar...) ");
fflush(stdin);
getchar();
Sistema("cls");
Gratis(pTmpBorrow);
Devolución;
}
time_t time;
struct tm * today
Time (ampltime);
ltime = 60 * 60 * 24 * 30;
hoy = hora local.
ltime);
sprintf(pTmpBorrow- gt; ReturnTime, "d año d mes d día", hoy- gt; tm_year 1900,
Hoy- gt; tm_mon 1,
p>
Hoy - gt;TM_mday);
if ( *pBorrow == NULL)
{
* pBorrow = pTmpBorrow
}
Otros
{
Préstamo * pWork = * pPréstamo
mientras ( NULL! = p trabajo- gt; pNext)
{
p trabajo = p trabajo- gt; pNext
}
Trabajo- gt; pNext = pTmpBorrow
}
pWorkBook- gt; número actual-;
System("cls"); Número de tarjeta de biblioteca: d \Préstamo de libros:
fflush(stdin);
getchar();
System("cls");
}
/*Consulta y préstamo*/
void QueryBorrow(Préstamo *pPréstamo)
{
Préstamo * pWork = pPréstamo
p>int recuento total = 0;
mientras (NULL! = pWork)
{
recuento total;
p trabajo = p trabajo- gt; pNext
}
System("cls");
Printf("Hay * **d elementos de información sobre préstamos actualmente, enumerados a continuación: \n = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
pWork = pPréstamo
mientras (NULL!= pWork)
{
Printf("Número de préstamo: [d] Nombre del préstamo:
p work = p work- gt; pNext
}
printf (" = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n ", recuento total);
}
/*Devolver el libro*/
void ReturnBook(pedir prestado* *pedir prestado, libro*pHead)
{
char InPutStr[1024];
Préstamo TmpBorrow
bool HasFindBorrwo = false
memset( amp; TmpBorrow, 0x0, sizeof(préstamo tmp));
Printf("Ingrese el número de tarjeta de la biblioteca:
GetInpu"
t(InPutStr, 1024, verdadero);
TmpBorrow. StuID = atoi(input str);
Printf("Ingrese el número del libro devuelto: ");
GetInput(InPutStr, 1024, true);
TmpPréstamo. BookID = atoi(input str);
Préstamo * pWorkBorrow = * pPréstamo
Préstamo * pDeletePre = NULL
mientras ( NULL!= pWorkBorrow)
{
if(pWorkBorrow- gt; BookID == TmpBorrow. BookID amp amppWorkBorrow- gt; StuID == TmpBorrow. StuID)
{
HasFindBorrwo = true
Break;
}
pDeletePre = pWorkBorrow
pWorkBorrow = pWorkBorrow- gt;pNext
}
If (!HasFindBorrwo)
{
System("cls");
Printf("Lo que ingresaste ¡La información de préstamo no existe!\n(Presione Enter para continuar...) ");
fflush(stdin);
getchar();
Sistema ("cls");
Retorno;
}
if (NULL == pDeletePre)
{
* p pedir prestado = pWorkBorrow- gt; pNext
}
Otro
{
pDeletePre- gt; pWorkBorrow- gt;pNext
}
Libro * pWorkBook = pHead
mientras ( NULL!= pWorkBook)
{
if(pWorkBook- gt; BookID == pWorkBorrow- gt; BookID)
{
pWorkBook- gt; número actual
}
p libro de trabajo = p libro de trabajo- gt; pNext
}
System("cls");
Printf("Número de tarjeta de biblioteca .: d \Devolver el libro:
fflush(stdin);
getchar()
System("cls"); p>Gratis (pWorkBorrow);
}