virtualword
Te invitamos a registrarte para poder acceder a todo el contenido gratuito que esta comunidad provee.

Saludos Wink

Soluciones lección 038

Ir abajo

Soluciones lección 038

Mensaje  Kyshuo Ayame el Vie Nov 29, 2013 5:10 pm

Solución del ejercicio 2 de los propuestos para la lección 38:

Archivo de definición del módulo Hora:

Código:
DEFINITION MODULE Hora;

CONST
 MAX_S= 59; (*El máximo valor para segundos*)
 MAX_M= 59; (*El máximo valor para minutos*)
 MAX_H= 23; (*El máximo valor para horas*)

TYPE
 Hora;

(*==========================================================================*)
(*CONSTRUCTORAS *)
(*==========================================================================*)
(*Crea una hora con 0 horas, 0 minutos y 0 segundos*)
PROCEDURE CrearHora(): Hora;

(*Crea una hora con los valores pasados como argumento. Si alguno de estos valores
excede el máximo establecido se establecerá como si se hubiese pasado el valor
máximo.*)
PROCEDURE CrearHoraCompleta(hh, mm, ss: CARDINAL): Hora;

(*Esta operación no estaba solicitada en el ejercicio.
Crea una hora tomando los valores de la hora actual del sistema operativo.
Si no es posible obtener la hora del sistema se retorna la hora 00:00:00*)
PROCEDURE CrearHoraSistema(): Hora;

(*==========================================================================*)
(*SELECTORAS *)
(*==========================================================================*)
(*Retorna los segundos*)
PROCEDURE GetSegundos(h: Hora): CARDINAL;

(*Retorna los minutos.*)
PROCEDURE GetMinutos(h: Hora): CARDINAL;

(*Retorna las horas*)
PROCEDURE GetHoras(h: Hora): CARDINAL;

(*==========================================================================*)
(*MUTADORAS *)
(*==========================================================================*)
(*Asigna los segundos. Si este valor es mayor al máximo establecido se asignará el máximo.*)
PROCEDURE SetSegundos(ss: CARDINAL; VAR h: Hora);

(*Asigna los minutos. Si este valor es mayor al máximo establecido se asignará el máximo.*)
PROCEDURE SetMinutos(mm: CARDINAL; VAR h: Hora);

(*Asigna las horas. Si este valor es mayor al máximo establecido se asignará el máximo.*)
PROCEDURE SetHoras(hh: CARDINAL; VAR h: Hora);

(*Aumenta el valor de la hora según la cantidad de segundos pasados como argumento
teniendo en cuenta que el aumento es rotativo, por ejemplo, para la hora
23:59:59 el aumento de 5 segundos implica quedar en 00:00:04*)
PROCEDURE AumentarPorSegundos(segundos: CARDINAL; VAR h: Hora);

(*Aumenta el valor de la hora según la cantidad de minutos pasados como argumento
teniendo en cuenta que el aumento es rotativo, tal como se explica para la
operación AumentarPorSegundos.*)
PROCEDURE AumentarPorMinutos(minutos: CARDINAL; VAR h: Hora);

(*Aumenta el valor de la hora según la cantidad de horas pasadas como argumento
teniendo en cuenta que el aumento es rotativo, tal como se explica para la
operación AumentarPorSegundos.*)
PROCEDURE AumentarPorHoras(horas: CARDINAL; VAR h: Hora);

(*==========================================================================*)
(*PREDICADOS *)
(*==========================================================================*)
(*Retorna TRUE si ambas horas son iguales (indican la misma hora), FALSE en
caso contrario.*)
PROCEDURE IgualHora(h1, h2: Hora): BOOLEAN;

(*Retorna TRUE si h1 es mayor que h2, FALSE en caso contrario.*)
PROCEDURE EsMayorHora(h1, h2: Hora): BOOLEAN;

(*==========================================================================*)
(*INFORMACIÓN *)
(*==========================================================================*)
(*Imprime la hora en formato hh:mm:ss. Tener en cuenta que si alguno de los
valores es menor que 10, por ejemplo 3 horas, 32 minutos y 4 segundos, debe
igualmente imprimirse cada valor con dos caracteres, es decir que, imprimir
3:32:4 está mal ya que debe ser 03:32:04*)
PROCEDURE ImprimirHora(h: Hora);

(*==========================================================================*)
(*DESTRUCTORAS *)
(*==========================================================================*)
(*Libera la memoria ocupada por h*)
PROCEDURE EliminarHora(VAR h: Hora);

END Hora.
Archivo de implementación del módulo Hora:

Código:
IMPLEMENTATION MODULE Hora;

FROM Storage IMPORT ALLOCATE, DEALLOCATE;
FROM STextIO IMPORT WriteString;
FROM SWholeIO IMPORT WriteCard;
FROM SysClock IMPORT DateTime, CanGetClock, GetClock;

TYPE
 Hora= POINTER TO ElementoHora;
 ElementoHora= RECORD
 ss, mm, hh: CARDINAL;
 END;

(*==========================================================================*)
(*CONSTRUCTORAS *)
(*==========================================================================*)
PROCEDURE CrearHora(): Hora;
VAR h: Hora;
BEGIN
 NEW(h);
 WITH h^ DO
 ss:= 0;
 mm:= 0;
 hh:= 0;
 END;
 RETURN h;
END CrearHora;

PROCEDURE CrearHoraCompleta(hh, mm, ss: CARDINAL): Hora;
VAR h: Hora;
BEGIN
 IF hh>MAX_H THEN
 hh:= MAX_H;
 END;

 IF mm>MAX_M THEN
 mm:= MAX_M;
 END;

 IF ss>MAX_S THEN
 ss:= MAX_S;
 END;

NEW(h);
 h^.ss:= ss;
 h^.mm:= mm;
 h^.hh:= hh;
 RETURN h;
END CrearHoraCompleta;

(*Para implementar esta operación se utiliza la librería SysClock de las librerías
ISO importando el tipo DateTime y las operaciones CanGetClock y GetClock.*)
PROCEDURE CrearHoraSistema(): Hora;
VAR d: DateTime;
BEGIN
 (*Si es posible obtener la hora del sistema entonces se obtiene en la
 variable d mediante la operación GetClock y luego se retorna una nueva
 hora usando el constructor completo pasándole como argumento los valores
 obtenidos en d.*)
 IF CanGetClock() THEN
 GetClock(d);
 RETURN CrearHoraCompleta(d.hour,d.minute,d.second);
 ELSE
 (*Si no es posible, por algún motivo, obtener la hora del sistema entonces
 se devuelve la hora inicializada por el constructor que retorna 00:00:00*)
 RETURN CrearHora();
END;
END CrearHoraSistema;

(*==========================================================================*)
(*SELECTORAS *)
(*==========================================================================*)
PROCEDURE GetSegundos(h: Hora): CARDINAL;
BEGIN
 RETURN h^.ss;
END GetSegundos;

PROCEDURE GetMinutos(h: Hora): CARDINAL;
BEGIN
 RETURN h^.mm;
END GetMinutos;

PROCEDURE GetHoras(h: Hora): CARDINAL;
BEGIN
 RETURN h^.hh;
END GetHoras;

(*==========================================================================*)
(*MUTADORAS *)
(*==========================================================================*)

PROCEDURE SetSegundos(ss: CARDINAL; VAR h: Hora);
BEGIN
 IF ss>MAX_S THEN
 ss:= MAX_S;
 END;

 h^.ss:= ss;
END SetSegundos;

PROCEDURE SetMinutos(mm: CARDINAL; VAR h: Hora);
BEGIN
 IF mm>MAX_M THEN
 mm:= MAX_M;
 END;

 h^.mm:= mm;
END SetMinutos;

PROCEDURE SetHoras(hh: CARDINAL; VAR h: Hora);
BEGIN
 IF hh>MAX_H THEN
 hh:= MAX_H;
 END;

 h^.hh:= hh;
END SetHoras;

(*Privada*)
PROCEDURE UpSecond(VAR h: Hora);
BEGIN
 WITH h^ DO
 IF ss<MAX_S THEN
 ss:= ss+1;
 ELSIF ss=MAX_S THEN
 ss:= 0;
 IF mm<MAX_M THEN
 mm:= mm+1;
 ELSE
 mm:= 0;
 IF hh<MAX_H THEN
 hh:= hh+1;
 ELSE
 hh:= 0;
 END;
 END;
 END;
 END;
END UpSecond;

PROCEDURE AumentarPorSegundos(segundos: CARDINAL; VAR h: Hora);
VAR i: CARDINAL;
BEGIN
 FOR i:= 1 TO segundos DO
 UpSecond(h);
 END;
END AumentarPorSegundos;

PROCEDURE AumentarPorMinutos(minutos: CARDINAL; VAR h: Hora);
VAR i: CARDINAL;
BEGIN
 FOR i:= 1 TO minutos DO
 AumentarPorSegundos(60,h);
 END;
END AumentarPorMinutos;

PROCEDURE AumentarPorHoras(horas: CARDINAL; VAR h: Hora);
VAR i: CARDINAL;
BEGIN
 FOR i:= 1 TO horas DO
 AumentarPorMinutos(60,h);
 END;
END AumentarPorHoras;

(*==========================================================================*)
(*PREDICADOS *)
(*==========================================================================*)

PROCEDURE IgualHora(h1, h2: Hora): BOOLEAN;
BEGIN
 RETURN (h1^.hh=h2^.hh) AND (h1^.mm=h2^.mm) AND (h1^.ss=h2^.ss);
END IgualHora;

PROCEDURE EsMayorHora(h1, h2: Hora): BOOLEAN;
BEGIN
 IF h1^.hh>h2^.hh THEN
 RETURN TRUE;
 ELSIF h1^.hh<h2^.hh THEN
 RETURN FALSE;
 ELSIF h1^.mm>h2^.mm THEN
 RETURN TRUE;
 ELSIF h1^.mm<h2^.mm THEN
 RETURN FALSE;
 ELSIF h1^.ss>h2^.ss THEN
 RETURN TRUE;
 ELSE
 RETURN FALSE;
 END;
END EsMayorHora;

(*==========================================================================*)
(*INFORMACIÓN *)
(*==========================================================================*)

PROCEDURE ImprimirHora(h: Hora);
BEGIN
 IF h^.hh<10 THEN
 WriteString("0"); WriteCard(h^.hh,1);
 ELSE
 WriteCard(h^.hh,1);
 END;
 WriteString(":");
 IF h^.mm<10 THEN
 WriteString("0"); WriteCard(h^.mm,1);
 ELSE
 WriteCard(h^.mm,1);
 END;
 WriteString(":");
 IF h^.ss<10 THEN
 WriteString("0"); WriteCard(h^.ss,1);
 ELSE
 WriteCard(h^.ss,1);
 END;
END ImprimirHora;

(*==========================================================================*)
(*DESTRUCTORAS *)
(*==========================================================================*)

PROCEDURE EliminarHora(VAR h: Hora);
BEGIN
 DISPOSE(h);
END EliminarHora;

END Hora.
avatar
Kyshuo Ayame
Admin

Mensajes : 105
Fecha de inscripción : 14/11/2012
Edad : 29

Ver perfil de usuario http://virtualworld.forouruguay.net

Volver arriba Ir abajo

Volver arriba

- Temas similares

 
Permisos de este foro:
No puedes responder a temas en este foro.