ParNing 17/Junio/2015 1 ParNing 17/Junio/2015 2

PROGRAM Parking ;
USES
Crt, SysUtils ;
CONST
NUM_PLAZAS
=
PRECIO_NOCHE =
PRECIO_MINUTO =
NOCHES_MAX
=
MAX
=
TYPE
tsCadena8
tsCadena30
tsCadena10
tsCadena2
trgFecha
=
=
=
=
{ Abrir fichero }
Assign (fFich, sNombreFich) ;
Reset (fFich) ;
100 ;
15 ;
0.011 ;
2 ;
4080 ;
{
{
{
{
{
{ Recorrer el fichero }
WHILE NOT EOF(fFich) DO
BEGIN
iLong
:= iLong + 1 ;
Parking con 100 plazas }
Precio por pasar una noche, en euros }
Precio de cada minute, en euros }
Número máximo de noches permitido }
Para el tamaño del array }
Read (fFich, argParking[iLong]) ;
argParking[iLong].iNumNoches := argParking[iLong].iNumNoches + 1 ;
END;
STRING[8];
STRING[30];
STRING[10];
STRING[2];
Close (fFich) ;
END;
= RECORD
iAnio, iMes, iDia : Integer;
END;
{ Menú }
FUNCTION fncLeerOpcion : Char ;
VAR
cOpcion : Char ;
BEGIN
ClrScr;
Writeln ;
Writeln ;
WriteLn ('************************ MENU ********************************');
WriteLn (' 1. Entrada de un coche.');
WriteLn (' 2. Salida de un coche.');
WriteLn (' 3. Listar información de los coches que están en el parking.');
Writeln ;
WriteLn (' 0. Finalizar');
WriteLn ;
Write
('
Introduce una opción: ');
REPEAT
cOpcion := ReadKey ;
UNTIL ('0' <= cOpcion) AND (cOpcion <= '3') ;
Writeln (cOpcion) ;
Writeln ;
trgInstante = RECORD
iHora, iMinuto, iSegundo : Integer;
END;
trgDatosCoche = RECORD
sMatricula
rgFechaEntrada
rgInstanteEntrada
rgFechaSalida
rgInstanteSalida
iNumNoches
rImporte
END;
:
:
:
:
:
:
:
tsCadena8;
trgFecha ;
trgInstante ;
trgFecha ;
trgInstante ;
Integer;
Real;
targParking = ARRAY [1..MAX] OF trgDatosCoche;
tfParking
= FILE OF trgDatosCoche;
{ Comprueba si un fichero existe. Si no existe, lo crea }
PROCEDURE prCrearFichero (nombreFich : tsCadena30);
VAR
fFich : tfParking;
BEGIN
IF NOT FileExists(nombreFich) THEN
BEGIN
Assign (fFich, nombreFich);
ReWrite(fFich);
Close (fFich);
WriteLn ('Fichero "', nombreFich, '" creado');
END;
END;
fncLeerOpcion := cOpcion ;
END;
{ Busca la posición en el array de un coche (identificado por su matrícula)
que ha entrado al parking, pero aún no ha salido.
Si no lo encuentra o lo encuentra pero ya ha salido, devuelve menos -1.
En caso contrario, devuelve la posición del elemento en el array }
FUNCTION fniBuscarMatriculaDentro (
sMatriculaBuscada : tsCadena8;
CONST argParking : targParking ;
iLong
: Integer) : Integer ;
VAR
boEncontrado : Boolean ;
i : Integer ;
BEGIN
boEncontrado := FALSE ;
i := 1 ;
{ Carga los datos del parking del fichero al array.
Actualiza el número de noches de los coches que no han salido. }
PROCEDURE prCargarDatosParking (
sNombreFich : tsCadena30;
VAR argParking : targParking;
VAR iLong
: Integer);
VAR
: tfParking ;
fFich
BEGIN
{ Al principio, el array está "vacío" }
iLong
:= 0 ;
3DUNLQJ -XQLR
WHILE (NOT boEncontrado) AND (i <= iLong) DO
{ Buscar coche con misma matrícula y que no haya salido (su importe = 0)}
IF (argParking[i].sMatricula = sMatriculaBuscada) AND
(argParking[i].rImporte = 0) THEN
boEncontrado := TRUE
ELSE
i := i + 1 ;
3DUNLQJ -XQLR
IF boEncontrado THEN
fniBuscarMatriculaDentro := i
ELSE
fniBuscarMatriculaDentro := -1
END;
{ Imprime en pantalla la información de todos los coches que en este momento
están dentro del parking. }
PROCEDURE prMostrarCochesDentro (CONST arParking : targParking;
iLong
: Integer);
VAR
i : Integer;
BEGIN
WriteLn;
prMostrarCabecera ;
{ Lee los datos de una fecha y rellena un registro }
PROCEDURE prLeerFecha (VAR rgFecha : trgFecha) ;
BEGIN
END ;
FOR i := 1 TO iLong DO
IF arParking[i].rImporte = 0 THEN
{ Coche que está dentro }
prMostrarDatosCoche(arParking[i]);
END;
{ Lee los datos de un instante y rellena un registro }
PROCEDURE prLeerInstante (VAR rgInstante : trgInstante) ;
BEGIN
END ;
{ Calcula el número de segundos }
FUNCTION fnCalcularSegundos (CONST rgInstante : trgInstante) : Longint;
BEGIN
fnCalcularSegundos := rgInstante.iHora * 3600 + rgInstante.iMinuto * 60 +
rgInstante.iSegundo ;
END;
{ Leer los datos de entrada de un nuevo coche y rellenar un registro }
PROCEDURE prLeerDatosEntradaCoche (VAR rgCoche : trgDatosCoche) ;
BEGIN
END ;
{ Convierte un registro de tipo fecha en una cadena en la que los años,
Meses y días tienen dos dígitos, separados por un guión. }
FUNCTION fnsFecha2Cadena (CONST rgFecha : trgFecha) : tsCadena10 ;
BEGIN
END;
{ Calcula el importe de la estancia en el parking de un coche }
PROCEDURE prCalcularImporte(VAR rgCoche : trgDatosCoche);
VAR
rImporte
: Real;
iNumMinutos : Longint;
BEGIN
IF rgCoche.iNumNoches > 0 THEN
{ En caso de que haya pasado alguna noche, Importe = numNoches x 15 }
rImporte := rgCoche.iNumNoches * PRECIO_NOCHE
ELSE
BEGIN
iNumMinutos := fnCalcularSegundos(rgCoche.rgInstanteSalida) fnCalcularSegundos(rgCoche.rgInstanteEntrada) ;
iNumMinutos := iNumMinutos DIV 60 ;
rImporte
:= iNumMinutos * PRECIO_MINUTO ;
END;
{ Convierte un registro de tipo Instante en una cadena en la que las horas,
minutos y segundos tienen dos dígitos, separados por dos puntos. }
FUNCTION fnsInstante2Cadena (CONST rgInstante : trgInstante) : tsCadena10 ;
BEGIN
END;
{ Imprime en pantalla la matrícula, fecha/hora de entrada y número de noches
que ha pasado un coche.
Si además ha salido, se indicará la fecha/hora de salida y el importe. }
PROCEDURE prMostrarDatosCoche (CONST rgCoche : trgDatosCoche);
VAR
sFecha, sInstante : tsCadena10;
BEGIN
WITH rgCoche DO
BEGIN
sFecha
:= fnsFecha2Cadena(rgFechaEntrada);
sInstante := fnsInstante2Cadena (rgInstanteEntrada);
Write (sMatricula:9, ' ':3, sFecha, ' ', sInstante, ' ':3, iNumNoches:6);
WriteLn; { Cambio de línea }
END;
END;
rgCoche.rImporte := rImporte;
END;
{ Guarda datos del array a los diferentes ficheros }
PROCEDURE prGuardarDatosEnFicheros (CONST argParking : targParking;
iLong : Integer;
sNombreFichP,
sNombreFichV,
sNombreFichG : tsCadena30);
VAR
i
: Integer;
fFichP, fFichV, fFichG : tfParking;
BEGIN
{ Abrir fichero de histórico del Parking para añadir nuevos datos }
Assign (fFichP, sNombreFichP);
Reset (fFichP);
Seek
(fFichP, FileSize (fFichP)) ;
{ Imprime en pantalla la cabecera para los listados de los coches }
PROCEDURE prMostrarCabecera ;
VAR
i : Integer ;
BEGIN
WriteLn('MATRICULA', ' ':3, 'ENTRADA':19, ' ':3, 'NOCHES');
FOR i := 1 TO 42 DO
Write('-');
WriteLn;
END ;
3DUNLQJ -XQLR
{ Crear ficheros de Actividad Víspera y de Grua}
Assign (fFichV, sNombreFichV);
Rewrite(fFichV);
Assign (fFichG, sNombreFichG);
Rewrite(fFichG);
3DUNLQJ -XQLR
FOR i:=1 TO iLong DO
BEGIN
WITH argParking[i] DO
{ El coche ha salido}
IF rImporte <> 0 THEN
Write(fFichP, argParking[i])
REPEAT
cOpcion := fncLeerOpcion ;
{ Al fichero de la históricos }
{ El coche no ha salido pero ha llegado al límite de noches }
ELSE IF iNumNoches = NOCHES_MAX THEN
Write(fFichG, argParking[i])
{ Al fichero de la grúa }
ELSE
Write(fFichV, argParking[i]) ; { Al fichero del Actividad Víspera}
END;
CASE cOpcion OF
'1' : { Nueva entrada }
IF iPlazasLibres = 0 THEN
{ No hay plazas libres. }
WriteLn ('Parking completo.')
ELSE
BEGIN
{ Hay plazas libres. Pedir la matrícula y la hora de entrada }
prLeerDatosEntradaCoche (rgCoche) ;
{ Añadir al final del array }
iLongArray := iLongArray + 1;
argDatosParking[iLongArray] := rgCoche;
{ Cerrar ficheros }
Close (fFichP);
Close (fFichV);
Close (fFichG);
END;
{ Una plaza libre menos }
iPlazasLibres := iPlazasLibres - 1 ;
WriteLn;
WriteLn ('Ahora quedan ', iPlazasLibres, ' plazas libres.');
END ;
VAR {----------------------- Variables del programa principal ---------------}
sNombreFichParking, sNombreFichVispera, sNombreFichGrua : tsCadena30 ;
cOpcion, cEspera
: Char ;
argDatosParking
: targParking ;
iPlazasLibres, iLongArray,
iPos,
: Integer ;
rgFechaActual
: trgFecha ;
rgInstanteSalida
: trgInstante ;
sMatricula
: tsCadena8;
rgCoche
: trgDatosCoche ;
'2' : BEGIN { Nueva salida }
{ Pedir la hora de salida y la matrícula }
Write ('Introduce la matrícula del vehículo: ');
ReadLn (sMatricula) ;
sMatricula := UPCASE(sMatricula);
{ Comprobar que el coche está dentro del parking }
iPos := fniBuscarMatriculaDentro (sMatricula,
argDatosParking, iLongArray);
IF iPos = -1 THEN
BEGIN
{ Si no se encuentra o ya ha salido, mensaje de error }
WriteLn ('Ese coche no se encuentra dentro del parking.');
END
ELSE
BEGIN
Writeln ;
prLeerFecha (rgFechaActual) ;
BEGIN {-------------------------- programa principal ----------------------}
WriteLn ('Programa para la gestión de un parking.');
WriteLn;
{ Pedir nombre de ficheros }
Write ('Introduce el nombre del fichero del
ReadLn (sNombreFichParking);
Write ('
ReadLn (sNombreFichVispera);
histórico
del
Parking: ');
fichero de la Actividad de la Víspera: ');
prLeerInstante (rgInstanteSalida) ;
Write ('
ReadLn (sNombreFichGrua);
fichero para la gestión de la Grúa: ');
{ Actualizar la posición del array con la fecha/hora de salida
y el importe. }
argDatosParking[iPos].rgFechaSalida
:= rgFechaActual ;
argDatosParking[iPos].rgInstanteSalida := rgInstanteSalida ;
prCalcularImporte(argDatosParking[iPos]) ;
{ Comprobar que el fichero del parking existe, y sino crearlo }
prCrearFichero (sNombreFichParking);
{ Comprobar que el fichero de Actividad de la Víspera existe, y sino crearlo }
prCrearFichero (sNombreFichVispera);
Writeln ;
{ Mostrar por pantalla el importe. }
WriteLn ('El precio por la estancia es de ',
argDatosParking[iPos].rImporte:0:2, ' euros.');
{ Cargar fichero con datos del parking}
prCargarDatosParking (sNombreFichVispera, argDatosParking, iLongArray) ;
{ Actualizar el número de plazas libres }
iPlazasLibres := iPlazasLibres + 1 ;
WriteLn;
WriteLn ('Ahora quedan ', iPlazasLibres, ' plazas libres.');
END;
END;
iPlazasLibres := NUM_PLAZAS - iLongArray ;
WriteLn ('Numero de plazas libres en el Parking: ', iPlazasLibres);
cEspera := ReadKey ;
3DUNLQJ -XQLR
3DUNLQJ -XQLR
'3' : { Mostrar toda la lista de coches que todavía están en el parking.}
IF iPlazasLibres = NUM_PLAZAS THEN
WriteLn ('El parking está vacío.')
ELSE
prMostrarCochesDentro (argDatosParking, iLongArray);
END ; { CASE }
IF cOpcion <> '0' THEN
cEspera := ReadKey ;
UNTIL cOpcion = '0' ;
{ Guardar datos en ficheros }
prGuardarDatosEnFicheros (argDatosParking, iLongArray,
sNombreFichParking, sNombreFichVispera,
sNombreFichGrua);
WriteLn ;
WriteLn ('====================================================') ;
WriteLn ('RETURN sakatu amaitzeko / Pulsa RETURN para terminar') ;
Write
('___________________________________________________') ;
cEspera := ReadKey ;
END. { PROGRAMAREN BUKAERA - FIN del PROGRAMA }
3DUNLQJ -XQLR