Diseñar un sistema de gestión informática para completar el negocio básico de la gestión bibliotecaria (método simple)

Archivo de encabezado:

============

#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 de la aplicación de consola.

//

# incluir & ltstdio.h & gt

# incluir & ltstdlib.h & gt

# incluir & ltstring .h & gt

# include & lttime.h & gt

#Include " DataStruct.h "

/*

datos Sistema de gestión de bibliotecas de diseño estructural de cursos (basado en C)

Puntos de bonificación: 100-14 días Hace 23 horas Pregunta finalizada.

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 de la siguiente manera:

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>

/*Muestra el menú principal y vuelve a la selección*/

int ShowMainMenu();

/*Para la operación de almacenamiento de libros, el parámetro pasado es 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 );

/*Devolver libro*/

void DevoluciónLibro(Préstamo**pPréstamo, Libro * pHead);

/*Publicar libros, indexar y pedir prestado información de la lista enlazada*/

void delete booklist(Book * * pHead);

void DeleteIndexList(Index * * pIndex);

void DeleteBorrowList(Borrow * * p Borrow);

int main()

{

/*Puntero del título de la lista de libros* /

Libro * pBookHead = NULL

/*Puntero del encabezado del índice del libro*/

Índice * pIndexHead = NULL

/*Préstamos puntero de encabezado de información*/

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

Interrupción

>}

Caso 1 :/*Almacenamiento de libros*/

{

PutBookInLib(& amp;pBookHead & amp;pIndexHead);

Pausa;

}

Caso 2:/*Consultar inventario*/

{

QueryBookLib(pBookHead);

Printf("Presione Enter Continuar...");

fflush(stdin);

getchar();

system(" cls");

Pausa;

}

Caso 3:/*Préstamo de libros*/

{

QueryBookLib(pBookHead);

Préstamo de 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 (&pBookHead);

DeleteIndexList(&pIndexHead) ;

DeleteBorrowList(& amp;pBorrowHead);

fflush(stdin);

getchar();

Devuelve 0;< / p>

}

/*Obtener la cadena de entrada*/

void GetInput(char *pInOutStr, int StrLen, bool OnlyGetNumber)

{

memset(pInOutStr, 0x0, StrLen);

fflush(stdin);

int Count = 0

mientras (verdadero)

{

char TmpC = 0

fred(& ampTmpC, 1, 1, stdin

if ( 10 =); = TmpC)

{

break;

}

if(solo obtiene el número &&TmpC> = ' 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 "); " * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");

Printf("*Sistema de gestión de biblioteca* \ n ");

printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");

>

printf(" \ n ");

Printf("Seleccione: \ n ");

Printf("\t1. Almacenamiento de libros\ n ");

Printf("\t2. Comprobar inventario\ n ");

Printf("\t3. Pedir prestado libros\ n"); \t4. Consulta de préstamo\n ");

Printf("\t5. Devolver libro\n");

Printf("\t0.

Salir \n ");

printf(" \n ");

printf(" \t entrada:");

GetInput(InPutStr, 1024 , verdadero);

if(strlen(input str)<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

Sin firmar largo BookID = 1;

char InPutStr[1024];

/*Primero calcule el número de identificación del libro almacenado actualmente*/

if ( NULL == pWork)

{

BookID = 1;

}

Otro

{

while(pWork-& gt;pNext!=null)

{

p trabajo = p trabajo-& gt;pNext

}

BookID = pWork-& gt;BookID+1;

}

Libro * pTmpNewBook ​​​​=(Libro *)(malloc(sizeof(Book)));

memset(pTmpNewBook, 0x0, sizeof(Book));

Índice * Índice PTM = (Índice *)(malloc(sizeof(Index))); p>memset(Índice PTM, 0x0, tamaño de(Índice));

pTmpNewBook-& gt; BookID = BookID

Índice PTM-& gt;

System("cls");

Printf("Ingrese el nombre del libro:");

GetInput(InPutStr, 1024);

strcpy( pTmpNewBook->BookName, input str);

System("cls");

printf("<<% s>>\n",pTmpNewBook ​​-& gt;Título del libro );

Printf("Autor del libro:");

GetInput(InPutStr, 1024);

strcpy(pTmpNewBook-& gt;Escritor, cadena de entrada );

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:");

p>

GetInput(InPutStr, 1024, true);

pTmpNewBook-& gt; número actual = atoi(input str);

if(pTmpNewBook-& gt; número actual & lt1 )

{

Sistema("cls"

);

Printf("¡Cantidad de compra incorrecta! (Presione Enter para continuar...) ");

fflush(stdin);

getchar() ;

Sistema("cls");

Retorno;

}

if ( NULL == *pHead)

{

* pHead = pTmpNewBook

* pIndex = pTmpIndex

}

Otros

{

Libro * pWork = * pHead

mientras (pWork!=null)

{

if(strcmp(p trabajo - >NombreLibro, pTmpNewBook ​​​​->NombreLibro)== 0&&strcmp(p work->Writer,pTmpNewBook->Writer)==0)

{

Trabajo-& gt;número actual+= pTmpNewBook->Número actual;

Retorno;

}

p trabajo = p trabajo-& gt;pSiguiente

}

pWork = * pHead

while(pWork-& gt;pNext!=null)

{

p trabajo = p trabajo-& gt;pNext

}

Trabajo-& gt;pNext = pTmpNewBook

Índice * pWork2 = * pIndex

mientras(pwork 2-& gt;pNext!=null)

{

pwork 2 = pwork 2-& gt;pNext

}

pwork 2-& gt; pNext = pTmpIndex

}

System("cls");

Printf("Libro :

fflush(stdin);

getchar();

Sistema("cls");

}

/*Publicar lista enlazada de libros e índice de lista enlazada*/

void DeleteBookList(Book **pHead)

{

Libro * pWork = * pHead

Libro * pNext = pWork

mientras ( NULL! = pWork)

{

pNext = p trabajo-& gt;pNext

Gratis(pWork);

pWork = pNext

}

}

anular eliminar lista de índice(Índice * * pIndex)

{

Índice * pWork = * pIndex

Índice * pNext = pWork

mientras ( NULL!= pWork)

{

pNext = p work-& gt;pNext

Gratis(pWork);

pWork = pNext

}

}

void DeleteBorrowList (Préstamo* *p Préstamo)

{

Préstamo*pWor

k = * pPréstamo

Préstamo * pNext = pWork

mientras ( NULL! = pWork)

{

pNext = p trabajo- & gt;pNext

Gratis(pWork);

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)

{

Libro * pWork = pHead

int recuento total = 0;

mientras (NULL!= pWork)

{

recuento total++;

p trabajo = p trabajo-& gt;pNext

}

System("cls");

Printf("Actualmente en stock* **%d este libro, de la siguiente manera:\ n = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

pWork = pHead

mientras (NULL!= pWork)

{

Printf("Número:[%d]Título:

p trabajo = p trabajo-& gt; pSiguiente

}

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(Préstamo));

Printf("Ingrese el número de libros que desea pedir prestados:" );

GetInput(InPutStr, 1024, true);

pTmpBorrow-& gt; BookID = atoi(input str);

Libro * pWorkBook = pHead

mientras (pWorkBook! = vacío)

{

if(pWorkBook-& gt;BookID == pTmpBorrow->BookID)

{

HadTheBook = true

Pausa;

}

p libro de trabajo = p libro de trabajo-& gt;pSiguiente

}

If(HadTheBook)

{

if(pWorkBook-& gt; número actual & lt1 )

{

System( " cls");

<

p>Printf("Libros

fflush(stdin);

getchar();

System("cls");

Gratis(pTmpBorrow);

Devolución;

}

}

Otros

{

System("cls");

Printf("¡El número de libro %d no existe!\n(Presione Enter para continuar...)", pTmpBorrow->BookID);

fflush(stdin);

getchar();

system("cls");

gratis(pTmpBorrow);

Return;

}

strcpy(pTmpBorrow-& gt;BookName, pWorkBook->BookName);

Printf("Por favor, introduzca la biblioteca número de tarjeta: ");

GetInput(InPutStr, 1024, true);

pTmpBorrow-& gt; StuID = atoi(input str);

if (0 == pTmpBorrow->StuID)

{

System("cls");

Printf("El número de tarjeta de biblioteca no existe ( Enter un número entero para el número de tarjeta de la biblioteca)!\n(Presione Enter para continuar...) ");

fflush(stdin);

getchar();

Sistema("cls");

Gratis(pTmpBorrow);

Devolución;

}

time_t time;

struct tm * hoy

Hora (ltime);

ltime+= 60 * 60 * 24 * 30

hoy = hora local; (<ime);

sprintf(pTmpBorrow->ReturnTime, "%d año %d mes %d día", hoy->tm_year+1900,

Hoy- >tm_mon+1,

Hoy->tm_mday);

if (*pBorrow == NULL)

{

* pPréstamo = pTmpPréstamo

}

Otro

{

Préstamo * pWork = * pPréstamo

p>

mientras (¡NULO! = p trabajo-& gt;pNext)

{

p trabajo = p trabajo-& gt;pNext

}

trabajo ->pNext = pTmpBorrow

}

pWorkBook->Número actual-;

Sistema("cls");

Printf("Número de tarjeta de biblioteca: % d \libros prestados:

fflush(stdin);

getchar();

System ("cls");

}

/*Consulta y préstamo*/

void QueryBorrow(Préstamo *pPréstamo)

{

Préstamo * pWork = pPréstamo

int recuento total = 0;

mientras (NULL!= pWork)

{

>recuento total++;

p trabajo = p trabajo-& gt;pNext

}

System("cls");

Printf("Hay ***%d elementos de información actual sobre préstamos, enumerados a continuación:\ n = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = pWork = pPréstamo

mientras (NULL! = pWork)

{

Printf("Número de préstamo: [%d] Nombre del préstamo:

p trabajo = p trabajo-& gt; pSiguiente

}

printf(" = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \n ", recuento total);

}

/*Devolver libros*/

void ReturnBook(pedir prestado* *pedir prestado, libro* pHead)

{

char InPutStr[1024];

Préstamo TmpBorrow

bool HasFindBorrwo = false

memset(& TmpBorrow, 0x0, sizeof(tmp lend));

Printf("Ingrese el número de su tarjeta de biblioteca:");

GetInput(InPutStr, 1024, true);

TmpBorrow. StuID = atoi(input str);

Printf("Ingrese el número del libro devuelto:");

GetInput(InPutStr, 1024, true);

TmpBorrow. BookID = atoi(input str);

Préstamo * pWorkBorrow = * pBorrow

Préstamo * pDeletePre = NULL

mientras ( NULL!= pWorkBorrow)

{

if(pWorkBorrow-& gt;BookID == TmpBorrow. BookID&&pWorkBorrow->StuID == TmpBorrow.

StuID)

{

HasFindBorrwo = true

Break;

}

pDeletePre = pWorkBorrow

pWorkBorrow = pWorkBorrow->pNext

}

if (!HasFindBorrwo)

{

System(" cls ");

Printf("¡La información de préstamo que ingresó no existe!\n(Presione Enter para continuar...) ");

fflush(stdin); p>

getchar();

Sistema("cls");

Retorno;

}

si ( NULL == pDeletePre)

{

* p préstamo = pWorkBorrow-& gt;pNext

}

Otro

{

pDeletePre-& gt;pNext = pWorkBorrow-& gt;pNext

}

Libro * pWorkBook = pHead

while ( NULL! = pWorkBook)

{

if(pWorkBook-& gt;BookID == pWorkBorrow->BookID)

{

pLibro de trabajo-& gt;número actual++;

}

p libro de trabajo = p libro de trabajo-& gt;pSiguiente

}

System("cls");

Printf("Número de tarjeta de biblioteca.:% d\Devolver el libro:

fflush(stdin);

getchar ();

System("cls");

Free(pWorkBorrow);

}

Alguien le dio esto a yo Respuesta. // Debes agregar algunos comentarios en chino antes y todavía hay errores en el entorno VC

time_t time;

struct tm * today

<. p> Hora(ltime);

ltime+= 60 * 60 * 24 * 30;

hoy = hora local(<time);

sprintf( pTmpBorrow ->ReturnTime, "%d año %d mes %d día", hoy->tm_year+1900,

Hoy->tm_mon+1,

Hoy - >TM_mday)

Este es el principal problema. Originalmente quería publicar mi versión modificada, pero no puedo, si quieres. Deja un correo electrónico.