Diseño de sistema de reserva de aviones en lenguaje c

(Modificado, utilice el código más reciente) Descripción del código:

Menú de nivel 1: seleccione el número de vuelo comprado y muestre el estado del asiento correspondiente.

(Solo hago pruebas, por lo que solo inicialicé 2 vuelos en la función initFlight y necesito agregarlos de acuerdo con mi código)

(Nota: software de desarrollo real, vinculado list data Se lee de la base de datos y requiere sincronización en tiempo real. Si desea llamar a la función initFlight varias veces, recuerde escribir una función para liberar la memoria usted mismo y liberar todos los nodos "SINFO y FLINFO" de la lista vinculada. ¡¡No escribí la función de lanzamiento. ¡Te necesito! ¡Escríbelo tú mismo!)

Menú de nivel 2: selecciona el número de asiento correspondiente para completar la compra y los resultados de la compra se mostrarán en formato real. tiempo.

Parámetros como el número de posición, el número máximo de filas de asientos, el tipo de cabina, el descuento, etc. son todos parámetros constantes con valores nulos y deben modificarse para cambiar las constantes usted mismo.

Nota: El tipo de cabina (por defecto uso 3 tipos: primera clase, clase ejecutiva y clase económica) corresponde al parámetro de descuento: matriz bidimensional tDiscount. Si desea agregar un nuevo tipo de cabina, debe modificar las cuatro constantes de parámetros TYPESIZE, typeName, tipos y tDiscount al mismo tiempo. Consulte las notas del código para obtener más detalles. !

Tarifa asiento = tarifa básica * descuento tipo * descuento período horario.

Como no está permitido fumar en el avión, no creé una zona para fumadores (risas). ¡Si es necesario, puedes agregarla como tipo! #includelt;stdio.hgt;

#includelt;stdlib.hgt;

#includelt;conio.hgt;

#includelt;string.hgt;

#includelt; malloc.hgt;

#includelt; ---------Parámetros relevantes, si desea cambiarlos, ¡modifíquelos aquí! ! ! ! ! ! ! --------------------------

const?float?timeDiscount=1; //Descuento por periodo de tiempo, impacto en el precio final de todos los vuelos, predeterminado 1

const?char?cID[5]="ABCD"; //Número de ubicación

const?int?maxRow=20 //Numeración máxima de ubicación;

//Nota: Si modifica el número de tipos, ¡los tipos y tDiscount deben modificarse al mismo tiempo! ! !

#define?TYPESIZE?3//Escriba cantidad

const?char?typeName[TYPESIZE][10]={"Primera clase", "Clase ejecutiva", "Clase económica " "};

const?int?types[TYPESIZE][2]={{1, 2}, {3, 4}, {5, 20}} //El tipo correspondiente de número. Primera clase en las filas 1~2, clase ejecutiva en las filas 3~4, clase económica en las filas 5~20

const?float?tDiscount[TYPESIZE]={1.5, 1.3, 1} //Tipo; descuento. 1,5 veces en primera clase, 1,3 veces en clase ejecutiva, 1 vez en clase económica

//------------------------ -------------------------------------------------- -- --

typedef?struct?seatInfo//Información del asiento, una lista vinculada corresponde a la información de un vuelo, el orden de la lista vinculada comienza desde el primero a la izquierda en la primera fila hasta A1 ~D1, A2~D2. . .

{

char?cloID; //Número de posición A, B, C, D

int?row; //Número de posición

int?type; //Tipo de asiento: 0: Primera clase, 1: Clase ejecutiva, 2: Clase económica, diferentes tipos corresponden a diferentes tipos de descuentos tDiscount

int?sell; , 0: No vendido; 1: Vendido

struct?seatInfo?*next;

}SINFO;

typedef?struct?flightInfo//Información de vuelo

{

char?fid[10]; //Número de vuelo

time_t?tfTime; //Hora de salida

time_t ?ldTime; ; //Hora de aterrizaje

char?toCity[20]; //Ciudad de llegada

float?tPrice; //Tarifa básica, diferentes ubicaciones tienen diferentes descuentos, boletos de asiento Precio = básico tarifa * tipo descuento * descuento período

struct?flightInfo?*next;

struct?seatInfo?*sHead //correspondiente al nodo principal de la lista de asientos

}FLINFO;

void?meError(void?*p);

SINFO?*getSINFO();//Obtener la lista de asientos

//addFLINFO: agrega el nodo de la lista vinculada de información de vuelo flinfoHead: el nodo principal (se generará automáticamente cuando se pasa NULL por primera vez), flinfoTail: el nodo de cola, fNew: la información de la estructura que se agregará (miembro no es necesario asignar punteros)

FLINFO?*addFLINFO(FLINFO?**ffHead, FLINFO?*flinfoTail, FLINFO?fNew); //Devuelve el nodo de cola

time_t ?getTime_tfromStr(char?*sTime); //Cambiar AAAA-MM- DD?hh: mm: la cadena de tiempo en formato ss se convierte en valor de tipo time_t

FLINFO?*initFlight() //Inicializar vuelo información y devolver el nodo principal de la lista de vuelos. Si desea ingresarlo manualmente, ingréselo en ¡Agréguelo aquí! ! ! En el desarrollo normal de software, este paso debería ser leer de la base de datos.

char?*getTString(struct?tm?*tm0);//Obtener la cadena de tiempo a través de tm

void?showSinfo(FLINFO?*flinfo);//Mostrar correspondencia de vuelo Información del asiento

void?printfFlinfo(FLINFO?*?flinfoHead);

FLINFO?*selectFlinfo(FLINFO?*flinfoHead, char?*fid); //Seleccione el número de vuelo y regrese. Node

void?showSinfo(FLINFO?*flinfo); //Mostrar información del asiento correspondiente al vuelo

SINFO?*selectSinfo(FLINFO?*flinfo, char?*sid); // Selecciona un asiento y regresa al nodo

int?main()

{

FLINFO?*flifoHead=initFlight(), *ffSelect=NULL ;

SINFO?*sfSelect=NULL;

char?fid[10]={0}, sid[10]={10};

mientras

(1)

{

ffSelect=NULL

sfSelect=NULL

memset(fid, 0, 10); /p>

memset(sid, 0, 10);

printfFlinfo(flinfoHead);

printf("Ingrese el número de vuelo que desea comprar: "); /p>

p>

scanf("s", fid);

ffSelect=selectFlinfo(flinfoHead, fid);

if(!ffSelect)

{

printf("No se encontró el vuelo correspondiente, presione cualquier tecla para continuar-----\n");

getch(); /p>

sistema("cls");

continuar;

}

sistema("cls"); >printf("Número de vuelo: s? La información del asiento es la siguiente:\n", ffSelect-gt; fid);

showSinfo(ffSelect);

printf("Por favor ingrese el número de asiento a comprar (ingrese 0 para regresar al menú principal): ");

scanf("s", sid);

if(!strcmp(sid , "0"))

{

sistema("cls");

continuar;

}

else

{

sfSelect=selectSinfo(ffSelect, sid);

if(!sfSelect||sfSelect-gt; vender)

{

printf("No se encontró el asiento correspondiente o el asiento se vendió, ¡vuelva a ingresar! Presione cualquier tecla para continuar-----\n");

getch();

system("cls") ;

continuar;

}

printf("Compra exitosa ! Presione cualquier tecla para continuar-----");

sfSelect-gt; sell=1;

getch();

system(" cls");

}

}

return?0;

}

SINFO?*selectSinfo (FLINFO?*flinfo, char?*sid)//Selecciona un asiento y devuelve el nodo

{

SINFO?*sinfoHead=flinfo-gt;sHead;

mientras(sinfoHead-gt;siguiente)

{

if(sinfoHead-gt;siguiente-gt;cloID==sid[0]?amp;amp;?sinfoHead -gt;siguiente-gt;row==atoi(sid 1))

return?sinfoHead-gt;siguiente;

sinfoHead=sinfoHead-gt;siguiente;

}

return?NULL;

}

void?showSinfo(FLINFO?*flinfo)//Mostrar información del asiento correspondiente al vuelo

{

SINFO?*sinfoHead=flinfo-gt, * sfp=NULL;

int?i,j,k,row=maxRow,clo=strlen(cID);

char?typeStr[10]={0};

for(i=0;ilt;row;i)

{

//---------Leer la cabina a la que pertenece el asiento--- --- ------

memset(typeStr, 0, 10);

for(k=0;klt;TYPESIZE;k)

if( i 1gt;=tipos[k][0]?amp;amp;?i 1lt;=tipos[k][1])

strcpy(typeStr, typeName[k]);

//-------------------------------------

printf("\n");

for(j=0;jlt;clo;j)

printf("----------- -- ?");

printf("\n");

sfp=sinfoHead;

for(j=0;jlt;clo;j )

{

printf("|c02d|?",sfp-gt;next-gt;cloID,sfp-gt;next-gt;row);

sfp=sfp-gt;siguiente;

}

printf("\n");

sfp=sinfoHead;

for(j=0;jlt;clo;j)

{

printf("|?c?|?",sfp-gt;next-gt;vender? 2: 1);

sfp=sfp-gt;siguiente;

}

printf("\n");

sfp= sinfoHead;

for(j=0;jlt;clo;j)

{

printf("|6s：4.0f|?", typeStr, flinfo-gt;tPrice*tDiscount[sfp-gt;next-gt;type]*timeDiscount);

sfp=sfp-gt;next;

}

printf("\n");

sinfoHead=sfp;

}

for(j=0;ilt;clo;j)

printf("-------?");

printf("\n");

}

FLINFO ?*selectFlinfo(FLINFO?*flinfoHead, char?*fid)//Selecciona número de vuelo y nodo de retorno

{

while(flinfoHead-gt; next)

{

if(!strcmp(flinfoHead-gt; next-gt; fid, fid))

return?flinfoHead-gt; siguiente;

flinfoHead=flinfoHead-gt;siguiente;

}

return?NULL;

}

void?printfFlinfo(FLINFO? *? flinfoCabeza)

{

while(flinfoHead-gt; next)

{

printf("Destino: s, número de vuelo: s \ n----Hora de salida: s, hora de llegada: s\n\n", flinfoHead-gt; next-gt; toCity, flinfoHead-gt; next-gt; fid, getTString(localtime(amp; flinfoHead-gt; next-gt;tfTime)), getTString(localtime(amp;flinfoHead-gt;next-gt;ldTime)));

flinfoHead=flinfoHead-gt;next;

}

}

char?*getTString(struct?tm?*tm0)//Obtener la cadena de tiempo a través de tm

{

char?*str=(char?*)malloc(sizeof(char)*20),num[5]={0};

meError(str);

memset ( str, 0, 20);

sprintf (núm, "4d", tm0-gt; tm_year 1900);

strcat (núm,

memset(num, 0, 5);

sprintf(num, "02d", tm0-gt; tm_mon); p>

strcat(cadena, número);

strcat(cadena, "-");

memset(número, 0, 5); >sprintf(num, "02d", tm0-gt; tm_mday);

strcat(str, num);

strcat(str, "?"

memset(num, 0, 5);

sprintf(num, "02d", tm0-gt; tm_hour);

strcat(str, num); p>

strcat(str, ":");

memset(núm, 0, 5

sprintf(núm, "02d", tm0-gt; tm_min);

strcat(cadena, num);

strcat(cadena, ":"); p>

sprintf(num, "02d", tm0-gt; tm_sec);

strcat(str, num);

return?

}

time_t?getTime_tfromStr(char?*sTime)//Convierte la cadena de tiempo en formato AAAA-MM-DD?hh: mm:ss en un valor time_t

{

time_t?rt;

struct?tm?*tm1=NULL;

rt=time(NULL);

tm1= hora local(amp;rt);

sscanf(sTime, ("4d-2d-2d?2d:2d:2d"),amp;tm1-gt;tm_year,amp;tm1-gt; tm_mon, amplificador;tm1-g

t;tm_mday,amp;tm1-gt;tm_hour,amp;tm1-gt;tm_min,amp;tm1-gt;tm_sec);

tm1-gt;tm_year-=1900;

tm1-gt;tm_mon--;

rt=mktime(tm1);

return?rt;

}

FLINFO?*initFlight()//Inicializa la información del vuelo y devuelve el nodo principal de la lista de vuelos. Si desea ingresarla manualmente, agréguela aquí. ! ! En el desarrollo normal de software, este paso debería ser leer de la base de datos.

{

FLINFO?*ffHead=NULL, *flifoTail=NULL, fNew;

//--------Agregar información de vuelo ----Necesito agregar y escribir de acuerdo con mi método de llamada a continuación--------------------------------

strcpy(fNew.fid, "CI502");

fNew.tfTime=getTime_tfromStr("2019-02-20?03:30:30");

fNew.ldTime =getTime_tfromStr("2019-02-20?05:20:30");

strcpy(fNew.toCity, "Taipei");

fNew.tPrice= 1000;

fNew.next=NULL;

flinfoTail=addFLINFO(amp;ffHead,flinfoTail,fNew);

//------ --- ----------------------------------------------- --- ----------------------------------

strcpy(fNew.fid, "9C8921") ;

fNew.tfTime=getTime_tfromStr("2019-02-20?14:30:30");

fNew.ldTime=getTime_tfromStr("2019-02 -20?16 :40:30");

strcpy(fNew.toCity, "Hong Kong");

fNew.tPrice=500;

fNew.next=NULL ;

flinfoTail=addFLINFO(amp;ffHead,flinfoTail,fNew);

return?ffHead;

}

FLINFO?* addFLINFO(FLINFO?**ffHead, FLINFO?*flinfoTail, FLINFO?fNew)//Devuelve el nodo de cola

//Agrega el nodo de la lista vinculada de información de vuelo flinfoHead: Nodo principal (la primera vez que se pasa NULL, se generará automáticamente), flinfoTail: nodo de cola, fNew: información estructural que se agregará (no es necesario asignar punteros de miembro)

{

FLINFO?*flinfoHead=*ffHead;

if(flinfoHead==NULL)

{

*ffHead=(FLINFO?*)malloc(tamañode (FLINFO));

flinfoHead=*ffCabeza

meError(flinfoHead);

flinfoHead-gt; next=NULL;

}

FLINFO?*flinfoNew=(FLINFO?*)malloc( sizeof(FLINFO));

meError(flinfoNew);

flinfoNew-gt; next=NULL;

flinfoNew-gt; ;

strcpy(flinfoNew-gt;fid,fNew.fid);

flinfoNew-gt;ldTime=fNew.ldTime;

flinfoNew-gt;tfTime =fNew.tfTime;

fliinfoNew-gt;toCity[0]=0;

strcpy(fliinfoNew-gt;toCity,fNew.toCity);

flinfoNew-gt; tPrice=fNew.tPrice;

flinfoNew-gt; sHead=getSINFO();

if(flinfoHead-gt; next==NULL)

flinfoHead-gt; next=flinfoNew;

else

flinfoTail-gt; next=flinfoNew;

flinfoTail=flinfoNew;

return?flifoTail;

}

SINFO?*getSINFO()//Obtener la lista de asientos

{

int?maxClo = strlen(cID), cnt=maxClo*maxRow, clo=0, fila=1, i;

SINFO?*sinfoHead=(SINFO?*)malloc(sizeof(SINFO)), *sinfoTail= NULL ;

meError(sinfoHead);

sinfoHead-gt; next=NULL;

SINFO?*sinfoNew=NULL;

while (cnt--)// Genera el número correspondiente de listas vinculadas de asientos en orden

{

if(clo==maxClo)

clo=0 , fila;

if(row==maxRow 1)

fila=1;

sinfoNew=(SINFO?*)malloc(sizeof(SINFO)) ;

p>

meError(sinfoNew);

sinfoNew-gt; cloID=cID[clo];

sinfoNew-gt; ;

for(i=0; ilt; TYPESIZE; i )

if(rowgt;=tipos[i][0]?amp;amp;?rowlt;=tipos[ i][1])

{

sinfoNew-gt; tipo=i

romper

}

sinfoNew-gt; vender =0;

sinfoNew-gt; siguiente=NULL;

if(sinfoHead-gt; siguiente==NUL

L)

sinfoHead-gt; next=sinfoNuevo;

else

sinfoTail-gt; siguiente=sinfoNuevo;

sinfoTail=sinfoNuevo ;

clo ;

}

return?sinfoHead;

}

void?meError(void? *p)//Error en la aplicación de memoria

{

if(p==NULL)

{

printf("\n Excepción: ¡Error en la aplicación de memoria! Presione Entrar para finalizar el programa.

while(getch()!='\r');

exit(0);

p>

}

}