Fecha y hora actual: Domingo 25 Ago 2019 04:40
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Programando desde 0: 41- Operaciones de un TAD.

Responder al Tema

Índice del Foro > Programación en general > Programando desde 0: 41- Operaciones de un TAD.

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Lunes 19 Dic 2011 20:17

Título del mensaje: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Introducción a las operaciones de un TAD:

Constructoras

Un constructor es una operación que nos permite crear (construir) un objeto del tipo que hemos implementado. Para nuestro ejemplo, un constructor será alguna operación que nos permita obtener un objeto de tipo Persona con un Nombre, una Edad, un SueldoPorHora y una cantidad de HorasTrabajadas.

Nuestro constructor será una función llamada CrearPersona que recibirá los datos ya mencionados y retornará un objeto de tipo Persona inicializado con esos datos. De esta forma su firma será así:

Código:
PROCEDURE CrearPersona(nombre: TipoNombre; edad: INTEGER; sueldo, horas: REAL): Persona;


Esa firma será agregada a nuestro módulo de definición y luego también a nuestro módulo de implementación, en el cual comenzaremos a darle código.

¿Cómo haremos esto? Pues, recibimos datos de tipos primitivos, así que eso no complica para nada. Además todos los parámetros son pasados por valor porque la idea no es modificar nada sino usarlos para asignar valores. La cuestión es que debemos retornar algo de tipo Persona. Como dicho tipo es un puntero a algo, y eso es justamente lo que debemos retornar, necesitamos tener una variable de ese tipo para poder devolverla. Entonces me declararé una variable auxiliar del tipo persona:

Código:
PROCEDURE CrearPersona(nombre: TipoNombre; edad: INTEGER; sueldo, horas: REAL): Persona;
VAR
    auxPersona: Persona;


Comenzaremos entonces con las instrucciones para crear una nueva persona con los datos que nos dan. Esto no debería ser problema para ustedes porque ya deben saber trabajar bien con punteros, sin embargo lo explicaré paso a paso:

Lo primero que hago es inicializar a la variable auxPersona pidiendo lugar de memoria:

Código:
NEW(auxPersona);


Luego simplemente asigno los valores que me dan a los campos del nuevo registro creado:

Código:
auxPersona^.Nombre:= nombre;
auxPersona^.Edad:= edad;
auxPersona^.SueldoPorHora:= sueldo;
auxPersona^.HorasTrabajadas:= horas;


Ahora que tenemos un puntero de tipo Persona inicializado con valores válidos, lo retornamos:

Código:
RETURN auxPersona;


De este modo tendremos estos dos archivos formando al módulo Persona:

Código:
DEFINITION MODULE Persona;
CONST
    MAX_LARGO_NOMBRE= 50;
TYPE
    Persona; (*Es un tipo opaco.*)
    TipoNombre= ARRAY[1..MAX_LARGO_NOMBRE] OF CHAR;

PROCEDURE CalcularSueldoGanado(p: Persona): REAL;
PROCEDURE CrearPersona(nombre: TipoNombre; edad: INTEGER; sueldo, horas: REAL): Persona;

END Persona.


Código:
IMPLEMENTATION MODULE Persona;
FROM Storage IMPORT ALLOCATE;
TYPE
    Persona= POINTER TO DatosPersona;
    DatosPersona= RECORD
        Nombre: TipoNombre;
        Edad: CARDINAL;
        SueldoPorHora: REAL;
        HorasTrabajadas: REAL;
    END;

PROCEDURE CalcularSueldoGanado(p: Persona): REAL;
BEGIN
    RETURN p^.SueldoPorHora*p^.HorasTrabajadas;
END CalcularSueldoGanado;

PROCEDURE CrearPersona(nombre: TipoNombre; edad: INTEGER; sueldo, horas: REAL): Persona;
VAR
    auxPersona: Persona;
BEGIN
    NEW(auxPersona);
    auxPersona^.Nombre:= nombre;
    auxPersona^.Edad:= edad;
    auxPersona^.SueldoPorHora:= sueldo;
    auxPersona^.HorasTrabajadas:= horas;
    RETURN auxPersona;
END CrearPersona;
END Persona.


Lo único que destacaré de los cambios hechos al módulo de implementación es que he importado la operación ALLOCATE desde Storage para simplemente poder utilizar NEW.

Ahora debemos aprender a utilizar el nuevo módulo que hemos creado. En este caso, como nuestro programa solo consta del módulo principal y del módulo Persona, utilizaremos este último desde el principal. Para eso basta simplemente con hacer lo mismo que ustedes hacen para utilizar cualquier librería de Modula, es decir, importar.
Bien, en nuestro módulo principal incluimos entonces esta línea:

Código:
FROM Persona IMPORT Persona, CalcularSueldoGanado, CrearPersona;


Como pueden observar, importamos desde el módulo Persona el tipo Persona, la operación CalcularSueldoGanado y la operación CrearPersona. Entonces ahora podemos usar todo eso en nuestro módulo principal.

Lo que haré entonces ahora es crear una nueva persona desde el módulo principal pasando como nombre Kyshuo, como edad 22, como valor de su sueldo 100.0 y como cantidad de horas 20.0 Luego mostraré en pantalla el resultado de la operación CalcularSueldoGanado.

Código:
MODULE Aplicacion;
FROM SRealIO IMPORT WriteReal;
FROM Persona IMPORT Persona, CalcularSueldoGanado, CrearPersona;
VAR
   p: Persona;
BEGIN
   p:= CrearPersona("Kyshuo",22,100.0,20.0);
   WriteReal(CalcularSueldoGanado(p),1);
END Aplicacion.


He importado WriteReal desde SRealIO para poder el resultado de la función CalcularSueldoGanado en pantalla.
Lo importante aquí es que observen como usamos el constructor de nuestro módulo para asignarle un valor válido a nuestra variable p del tipo Persona. Si ustedes no usan el constructor tendrán un error en tiempo de ejecución. Además no pueden hacer desde el módulo principal NEWL(p) ni nada que implique acceder a la representación del tipo Persona, es decir, no pueden hacer:

Código:
p^.Nombre= “Kyshuo”;
p^.Edad= 85;
. . .


porque el módulo principal no sabe como está implementado el tipo Persona. Por eso es que debemos proveer en nuestra librería todas las operaciones necesarias para poder trabajar con el tipo Persona desde fuera. Es por esto que cuando usamos una librería no nos importa como está implementada, solo usamos las operaciones que nos dan y listo, con eso debemos arreglarnos.

Por ahora, con las operaciones que le hemos dado a nuestra librería, solo podemos crear una nueva persona y obtener el valor del sueldo que ha ganado. Seguiremos trabajando entonces para completar la librería poco a poco hasta que esté lista.

-------------------------------------------------------------------------------------

Operaciones que completan un TAD:

La idea entonces es crear un TAD provisto de todas las operaciones necesarias para trabajar con él. ¿Cuáles son estas? Pues:

  • Constructoras: Permiten crear un nuevo objeto del TAD especificado.
  • Selectoras: Permiten obtener datos del objeto, por ejemplo, de un objeto Persona nos podría interesar conocer su Nombre.
  • Modificadoras: Permiten modificar los datos del objeto, por ejemplo, de un objeto Persona nos podría interesar modificar su Edad o su Nombre.
  • Predicados: Permiten conocer si se cumplen ciertas condiciones para el objeto del TAD especificado. En nuestro ejemplo no tenemos nada que requiera de predicados, pero los iremos viendo más adelante.
  • Informativas o de Salida: Por lo general implementan alguna forma de mostrar un objeto en pantalla.
  • Destructoras: Permiten destruir el objeto, es decir, liberar la memoria. Por ejemplo, dado que en el módulo principal no podemos hacer DISPOSE(p) si p fuera de tipo Persona, debemos incluir nosotros una operación que permita liberar la memoria que ocupa un objeto persona.


Nuestro TAD tiene una sola operación constructora y no requiere de más. Luego le hemos dado una operación selectora para obtener el sueldo ganado. Sin embargo necesitamos más. Pensemos entonces en las operaciones selectoras que podrían ser útiles para un tipo Persona:

  • Obtener su nombre.
  • Obtener su edad.
  • Obtener su sueldo por hora.
  • Obtener su cantidad de horas trabajadas.


Esas cuatro, más la que ya tenemos completarían todo lo que podríamos necesitar acerca de una persona según nuestro TAD. De este modo, tendremos cuatro nuevas operaciones para definir, y lo haremos de esta manera:

Código:
PROCEDURE ObtenerNombrePersona(p: Persona): TipoNombre;
PROCEDURE ObtenerEdadPersona(p: Persona): CARDINAL;
PROCEDURE ObtenerSueldoPorHora(p: Persona): REAL;
PROCEDURE ObtenerHorasTrabajadas(p: Persona): REAL;


Así que pondremos en nuestro módulo de definición esas cuatro nuevas operaciones, y luego iremos a nuestro módulo de implementación a darles código. Debería ser fácil para ustedes implementar esas operaciones, pero lo haré yo para que vayan aprendiendo bien cuál es la idea:

Código:
PROCEDURE ObtenerNombrePersona(p: Persona): TipoNombre;
BEGIN
   RETURN p^.Nombre;
END ObtenerNombrePersona;

PROCEDRUE ObtenerEdadPersona(p: Persona): CARDINAL;
BEGIN
   RETURN p^.Edad;
END ObtenerEdadPersona;

PROCEDURE ObtenerSueldoPorHora(p: Persona): REAL;
BEGIN
   RETURN p^.SueldoPorHora;
END ObtenerSueldoPorHora;

PROCEDURE ObtenerHorasTrabajadas(p: Persona): REAL;
BEGIN
   RETURN p^.HorasTrabajadas;
END ObtenerHorasTrabajadas;


Ustedes copien esos códigos en su archivo de implementación y verán que todo funciona. Como pueden observar, cada una de estas operaciones recibe un objeto de tipo Persona y devuelve algo de otro tipo, lo cual se corresponde con algún atributo del objeto persona. Esto es porque desde fuera del módulo Persona no podemos acceder a su representación. Si otro programador fuera a usar su librería en sus códigos simplemente debe leer el archivo .def que ustedes proveen y utilizar lo que este muestra, no se preocupa por nada más. ¿Comprenden?
Usaremos entonces todas estas operaciones para mostrar todos estos datos en pantalla. El módulo principal quedará entonces así:

Código:
MODULE Aplicacion;
FROM SRealIO IMPORT WriteReal;
FROM STextIO IMPORT WriteString, WriteLn;
FROM SWholeIO IMPORT WriteCard;
FROM Persona IMPORT Persona, CalcularSueldoGanado, CrearPersona,             ObtenerNombrePersona, ObtenerEdadPersona,             ObtenerHorasTrabajadas, ObtenerSueldoPorHora;
VAR
   p: Persona;
BEGIN
   p:= CrearPersona("Kyshuo",22,100.0,20.0);
   WriteString(ObtenerNombrePersona(p)); WriteLn;
   WriteCard(ObtenerEdadPersona(p),1); WriteLn;
   WriteReal(ObtenerHorasTrabajadas(p),1); WriteLn;
   WriteReal(ObtenerSueldoPorHora(p),1);
   WriteReal(CalcularSueldoGanado(p),1);
END Aplicacion.


Lo único a destacar de ese código es que obviamente debemos importar del módulo Persona absolutamente todo lo que queremos utilizar. De este modo ustedes ven aquí que en el módulo principal jamás accedemos a la representación del tipo Persona, solo usamos lo que nos proveen y listo.

Algo importante y que olvidé destacar es que si nosotros no utilizamos primero el constructor sobre nuestra variable p, cuando utilicemos cualquiera de las otras operaciones tendremos un error en tiempo de ejecución porque p no está inicializada y dichas operaciones intentan acceder al puntero pero este no apunta a nada y ni siquiera tiene el valor NIL.

Siempre debemos utilizar algún constructor para luego trabajar con nuestro objeto.

Todas las operaciones que hemos definido hasta ahora acceden directamente a la representación del tipo Persona. Esto hace que si yo modifico algo en ese tipo deba luego modificar algo en las seis operaciones que tengo definidas. Obviamente yo no puedo retornar el nombre de un objeto Persona si no escribo p^.Nombre, o sea, si no accedo directamente a su representación. Sin embargo yo les dije que minimizaríamos esto en la medida de lo posible, y pues, podemos hacer que una de todas nuestras operaciones deje de depender de la representación, CalcularSueldoGanado.

Dicha función multiplicaba dos valores, el sueldo y la cantidad de horas trabajadas, y lo hacía accediendo directamente a la representación. Sin embargo ahora ya tengo dos operaciones que me devuelven estos mismos valores, ObtenerSueldoPorHora y ObtenerHorasTrabajadas, entonces puedo implementar ahora CalcularSueldoGanado así:

Código:
PROCEDURE CalcularSueldoGanado(p: Persona): REAL;
BEGIN
    RETURN ObtenerSueldoPorHora(p)*ObtenerHorasTrabajadas(p);
END CalcularSueldoGanado;


De este modo, utilizo dos operaciones que ya acceden a la representación porque no tienen otra opción y hago que CalcularSueldoGanado ya no dependa de dicha representación. Ahora si yo cambio algo en cómo implemento al tipo Persona debo modificar una operación menos.
Algo a destacar es que si ustedes hacen este cambio en su código, todo el resto del programa seguirá funcionando tranquilamente. Por eso está buenísimo dividir el programa en módulos, porque si hago las cosas bien puedo tener un programa super complejo, y cuando quiera modificar algo de un módulo solo lo hago allí y no me preocupo por nada más, tal como sucede ahora.

Entonces, como ya tenemos todas nuestras operaciones SELECTORAS, es hora de pensar en las MODIFICADORAS. Así, debemos pensar en qué datos podría interesarnos cambiar o modificar. Para este caso podría interesar modificar todo menos el nombre porque es raro que una persona cambie de nombre, pero como es posible que eso pase y además es posible que alguien se equivoque al teclear el nombre, proveeremos de operaciones para modificar cualquier dato:

Código:
PROCEDRUE ModificarNombrePersona(nombre: TipoNombre; VAR p: Persona);
PROCEDRUE ModificarEdadPersona(edad: INTEGER; VAR p: Persona);
PROCEDURE ModificarSueldoPorHora(sueldo: REAL; VAR p: Persona);
PROCEDRUE ModificarHorasTrabajadas(horas: REAL; VAR p: Persona);


En esas firmas recibimos siempre el dato nuevo y un objeto del tipo Persona. Vean que el objeto es pasado por referencia, ya que aquí sí queremos modificar algo que ya existe.

Código:
PROCEDURE ModificarNombrePersona(nombre: TipoNombre; VAR p: Persona);
BEGIN
   p^.Nombre:= nombre;
END ModificarNombrePersona;


Como ven, trabajo sobre el parámetro p porque es pasado por referencia. No hace falta crear nada nuevo ni mucho menos. Simplemente modificamos lo que nos interesa y ya. Hagan ustedes el resto de las operaciones modificadoras que les muestro arriba.

Crearemos ahora una operación de INFORMACIÓN que imprima en pantalla a un objeto Persona con el siguiente formato:

Nombre: NombreDeLaPersona
Edad: EdadDeLaPersona
Sueldo por hora: ValorDelSueldo
Cantidad de horas trabajadas: HorasTrabajadas

Su firma será esta:

Código:
PROCEDURE ImprimirPersona(p: Persona);


Y su código este:

Código:
PROCEDURE ImprimirPersona(p: Persona);
BEGIN
   WriteString(“Nombre: “);
   WriteString(ObtenerNombrePersona(p));
   WriteLn;
   
   WriteString(“Edad: “);
   WriteCard(ObtenerEdadPersona(p),1);
   WriteLn;
   WriteString(“Sueldo por hora: “);
   WriteReal(ObtenerSueldoPorHora(p),1);
   WriteLn;
   WriteString(“Horas trabajadas: “);
   WriteReal(ObtenerHorasTrabajadas(p),1);
END ImprimirPersona;


Como pueden ver, esta operación no es dependiente de la representación del tipo Persona ya que utiliza todas las otras operaciones que ya nos definimos anteriormente. De este modo si cambiamos algo en este tipo no debemos modificar esta operación. Claro está que basarse en las operaciones ya definidas hace que si quisiéramos eliminarlas debiéramos modificar todos los lugares del código fuente en donde han sido utilizadas, pero a eso no podemos escapar.
No está mal si hacen todas sus operaciones dependientes de la implementación del tipo, pero no es lo más recomendable.

Lo único que nos queda por ver en este ejemplo es la operación destructora, a la cual la llamaremos DestruirPersona y su firma será así:

Código:
PROCEDURE DestruirPersona(VAR p: Persona);


Su código será:

Código:
PROCEDURE DestruirPersona(VAR p: Persona);
BEGIN
   DISPOSE(p);
END DestruirPersona;


Su razón de ser radica en que no podemos hacer DISPOSE(p) de un p del tipo Persona declarado fuera del módulo Persona porque justamente la idea es que desde fuera no se acceda a la representación del tipo ni de nada. Entonces, si desde fuera, por ejemplo desde el módulo principal, queremos liberar la memoria ocupada por nuestro objeto Persona debemos hacer:

Código:
DestruirPersona(p);


De este modo siempre se ocupa de todo el módulo indicado, individualizando las tareas, delegando responsabilidades y administrando todo mucho mejor.

Ejercicio: Modifiquen el módulo Persona para que además se incluya el documento de la misma como un número CARDINAL. Para esto deberán modificar el constructor, agregar una operación de modificación y otra de selección, y además deberán modificar la operación ImprimirPersona.

Por esta es más que suficiente. Ya tienen nociones básicas de lo que es un TAD y de cómo se piensa para definir uno. Pueden practicar a crear sus propios TADs, aunque luego profundizaré en eso y les daré ejercicios explícitos para que creen Tipos Abstractos de Datos.

En la próxima lección comenzaremos a hablar de la teoría de objetos, es decir, de la programación orientada a objetos.

Saludos.[/b]

Volver arriba
Ver perfil del usuario Enviar mensaje privado
pirdy
Usuario Inquieto


Registrado: 11 Feb 2010
Mensajes: 137

Mensaje Publicado: Lunes 19 Dic 2011 21:36

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Realmente tu labor es asombrosa profe. Tienes un sentido pedagogico muy buen.

Gracias por seguir poniendo lecciones.

Profe una pregunta sobre la estructura del curso¿ quedan mas lecciones de Modula o al empezar la siguiente leccion a explicar los objetos pasamos a JAVA?.

Todavia me queda bastante para llegar aqui, pero es que me pica la curiosidad de saber cuanto Modula queda ya que necesito bien aprender bien el lenguaje por la facultad.

Saludos y no nos abandone nunca Aplauso .

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Martes 20 Dic 2011 00:59

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Falta bastante aún para llegar a Java. A estas alturas lo que es el lenguaje Modula está dado, al menos lo Standard y pues no daremos más que eso. Ahora lo utilizaremos para aprender a programar bien de forma modular, obtener conocimientos básicos de diseño, aprender a utilizar estructuras poderosas, entre muchas otras cosas. Aún falta para Java, y bastante...

Seguro que todo esto te servirá muchísimo.

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
juan alejandro
Usuario Iniciado


Registrado: 07 Ene 2011
Mensajes: 43
Ubicación: Bogotá - Colombia

Mensaje Publicado: Martes 20 Dic 2011 14:32

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Muchas Gracias por la lección kyshuo, gracias por el tiempo que le dedicas a esto.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
JamTe
Usuario Inquieto


Registrado: 30 Jun 2011
Mensajes: 73
Ubicación: En todas partes menos en la cama

Mensaje Publicado: Martes 20 Dic 2011 16:00

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Como siempe, fantastico Super Super Super Super

Volver arriba
Ver perfil del usuario Enviar mensaje privado
socrates



Registrado: 04 Dic 2011
Mensajes: 3

Mensaje Publicado: Jueves 29 Dic 2011 01:44

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Hola kyshuo, vengo estudiando tu curso desde hace poco (un mes) y me parece FASCINANTE y muy pedagogico, voy por la leccion 12 y espero ponerme pronto a vuestro ritmo para poder consultarte. Un saludo y gracias por tu tiempo.
Ordenador

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Lunes 08 Oct 2012 12:10

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

2a. lectura a esta Excelente Lección! todo muy claro, gracias Kyshuo.

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Emirona07
Usuario Iniciado


Registrado: 10 Mar 2013
Mensajes: 11

Mensaje Publicado: Sábado 23 Mar 2013 17:42

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Tengo un TAD Selector que es Dientes (l:Persona):CARDINAL, donde mostraría la cantidad de dientes de mi persona l: (RETURN l^.CantDientes).

Luego quiero hacer un TAD Modificador que le agregue un diente a la persona (es todo un ejemplo, en realidad no trabajo con esos procedimientos), por lo que tengo un AumentarDientes(VAR l:Persona); y dentro del procedimiento intento hacer:

BEGIN
Dientes(c) := Dientes(c) + 1;
END AumentarDientes;

¿Estoy haciendo algo mal? Porque el procedimiento Dientes me solicita una salida, y quizás deba hacer una variable auxiliar "sucia" (como explicaste vos) para asignarle a lo que retornaría el procedimiento. Actualmente con esas definiciones me da error.

¿En este caso es posible hacerlo utilizando mi procedimiento Dientes o me tengo que resignar a hacerlo con l^.CantDientes := l^.CantDientes + 1;?

Gracias.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Sábado 23 Mar 2013 21:52

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Bien, un par de aclaraciones:

Un TAD define un "tipo de objetos", una entidad, por ejemplo Persona. Un TAD tiene operaciones que definen su comportamiento, por ejemplo:

  • Obtener la edad
  • Obtener el nombre
  • Obtener la cantidad de dientes (como es tu caso)


Por tanto, el TAD Persona tiene operaciones Selectoras, Predicado, Modificadoas, Constructoras y Eliminadoras. De este modo las operaciones no son TAD sino que son parte de él.

Ahora veamos tu duda. En efecto sí lo estás haciendo mal. La función Dientes recibe como argumento un objeto Persona pasado por copia (lo cual está bien) y retorna un CARDINAL que indica la cantidad de dientes.

La función AumentarDientes recibe como argumento un objeto Persona pasado por referencia lo cual está bien. Por lo que entendí esta función aumenta en 1 dicha cantidad.

Lo que está mal, muuuy mal, es esto:

Código:
  1. Dientes(c):= Dientes(c) +1;


Dientes es una función, no una variable, no puede ser inicializada ¿me explico? Dientes recibe una variable y retorna un valor. E la operación AumentarDientes es del TAD Persona, entonces esta operación tiene que acceder a la representación del tipo Persona y aumentar el valor allí. Por ejemplo, imagina que el tipo Persona está definido así:

Código:
  1. TYPE Persona= POINTER TO ElementoPersona;
  2. ElementoPersona= RECORD
  3. nombre: ARRAY[1..10] OF CHAR;
  4. dientes: CARDINAL;
  5. END;


Entonces la operación AumentarDientes debería ser algo así:

Código:
  1. PROCEDURE AumentarDientes(VAR p: Persona)
  2. BEGIN
  3. p^.dientes:= p^.dientes+1;
  4. END AumentarDientes;


O también:

Código:
  1. PROCEDURE AumentarDientes(VAR p: Persona)
  2. BEGIN
  3. p^.dientes:= Dientes(p)+1;
  4. END AumentarDientes;


¿Se entiende? Repasa esta lección y léela con más atención, hay cosas que ya están explicadas.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Emirona07
Usuario Iniciado


Registrado: 10 Mar 2013
Mensajes: 11

Mensaje Publicado: Domingo 24 Mar 2013 05:41

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

Sí, sí. Entendí mi error. Mi problema fue que ya tenía implementada esa función y al leer tu lección decidí utilizar las funciones ya implementadas para ahorrarme editar algunas funciones en caso de tener que realizar alguna modificación en mis estructuras.

Me ensalcé intentando cambiar los p^.ALGO por las funciones e intenté hacerlo en todas. Lo mejor es dejarlo como el último ejemplo que vos pusiste.

Muchas gracias, de verdad.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
xRoki
Usuario Inquieto


Registrado: 22 Ago 2013
Mensajes: 71

Mensaje Publicado: Jueves 10 Oct 2013 00:44

Título del mensaje: Re: Programando desde 0: 41- Operaciones de un TAD.

Responder citando

EXCELENTE :DDD ,COMO SIEMPRE TODO LO QUE EXPLICAS SON CLARAS Y NO DEJAN NI UNA DUDA. XD GRACIAS ARIGATO

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Buenas desde el sur del sur =)

Maugarni Preséntate a la comunidad 1 Jueves 22 Ago 2019 14:09 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Hola desde bcn

Dav2k6 Preséntate a la comunidad 2 Miércoles 26 Jun 2019 19:22 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Existen problemas al descargar musica desde you...

SusanaP Tu PC 2 Martes 26 Mar 2019 19:22 Ver último mensaje
El foro no contiene ningún mensaje nuevo

hola!! los saludo desde argentina

mery Preséntate a la comunidad 2 Jueves 13 Dic 2018 17:28 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Llamada a web service desde form

mrrobot2 Programación Web en general 1 Martes 14 Nov 2017 00:50 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,