Concepto de LISTA. Una lista es una estructura de datos homogénea y dinámica, que va a estar formada por una secuencia de elementos, donde cada uno de ellos va seguido de otro o de ninguno.
Homogénea: Todos los elementos que la forman tienen el mismo tipo base.
Dinámica: Puede crecer o decrecer en tiempo de ejecución según nuestras necesidades.
dos listas pueden ser diferentes si:
No tienen el mismo número de elementos:
L1: gato, perro.
L2: gato, canario, cerdo.
Cuando, aun teniendo el mismo número de elementos, estos son distintos:
L1: gato, perro.
L2: gato, cerdo.
Cuando, aun teniendo el mismo número de elementos y siendo estos los mismos, no están dispuestos en el mismo orden.
L1: gato, perro.
L2: perro, gato.
Hay varios criterios para clasificar las listas: según su modo de acceso o según su información de acceso.
Modo De Acceso.
Atendiendo a este, se dividen en densas y enlazadas. El modo de acceso es independiente de la implementación realizada.
Listas densas
Se caracterizan porque los elementos siguen una secuencia física. Sabemos cuales es el siguiente elemento porque para acceder a él hemos tenido que pasar por todos los anteriores.
La localización de un elemento cualquiera será:
El primero si es el primer elemento de la lista.
N-esimo si para llegar a el hemos pasado por N-1 elementos.
Siguen una estructura física secuencial luego se pueden implementar utilizando ficheros, ARRAYS y punteros.
Listas enlazadas
Son aquellas en las que cada elemento que los compone contiene la información necesaria para acceder al elemento siguiente. La localización de un elemento cualquiera será:
Un elemento de la lista tendrá la dirección K si K es el primero y K es conocido (dirección de inicio).
Estará en la dir. J si J está contenida en el elemento anterior.
Informacion de acceso.
Listas ordinales
Los elementos se van colocando en la lista a medida que llegan y se identifican por el orden de llegada.El acceso a un elemento es por su orden o posición relativa dentro de la lista.
Listas calificadas
Los elementos se clasifican por una clave y pueden estar ordenados o no estarlo. A un elemento se accede por la información contenida en un campo clave.
Diferencias: En la primera clase importa en orden de llegada, mientras que en la segunda depende de la clave.
Pilas.
Una pila es una lista ordinal en la que el modo de acceso a sus elementos es del tipo LIFO. Los añadidos y extracciones de elementos de una estructura se realizan solo por un extremo, luego el único elemento accesible de la pila es el que se encuentre en la cima. Esto exigirá que la manipulación sobre un elemento, necesite que el mismo ocupe la posición de cima.
Sobre una estructura de tipo pila, surgen de forma natural las operaciones que permiten añadir elementos y quitar elementos.
Implementación utilizando tablas
Esta realización consiste en ir guardando consecutivamente los elementos de la pila en un vector de tamaño fijo. Un índice marcará la posición del último elemento que se ha añadido a la pila. Por tanto, las inserciones en la estructura se realizarán en la posición inmediatamente siguiente a la posición marcada como cima, pasando a ser esta nueva posición ocupada la nueva cima de la pila.
El hecho de utilizar un vector para almacenar los elementos, puede conducir a la situación en que la pila esté llena, es decir, que no quepa ningún elemento más. Esto se producirá cuando el índice que señala la cima de la pila sea igual al tamaño del vector.
Otros Tipos De Listas
Listas reorganizables.- Son aquellas listas en las que el último elemento consultado se sitúa al principio.
Listas circulares.- En ellas el último elemento apunta al primero.
Listas doblemente enlazadas.- Cada elemento tiene dos punteros, uno de los cuales apunta al elemento siguiente y otro al anterior.
Listas circulares doblemente enlazadas
PROGRAMAS Y ANALISIS LISTA SIMPLEMENTE ENLAZADA
Cuando utilizamos listas enlazadas podemos realizar la siguientes operaciones:
●
Podemos añadir información a la lista insertando un nuevo nodo en un determinado
lugar dentro de la lista.
●
Podemos eliminar un nodo especifico dentro de la lista que contenga información.
●
Podemos recuperar la información almacenada en un nodo especifico o encontrar
la posición de un determinado nodo que contenga alguna información especifica.
A continuación implementaremos un ejercicio en donde almacenaremos en cada nodo de
la lista información referente a una persona. Para esto declararemos la clase
TPersona y
en los elementos de la lista almacenaremos objetos de la clase persona.
Para la implementación del ejercicio crearemos un nuevo proyecto y crearemos además
de la clase TForm que se crea por defecto, dos unidades para implementar el código de
las clases
TPersona y TListaPersona. La unidad en donde esta la clase TForm se
guardara con el nombre
UVentanaLista.
Datos
Información Enlace
Nodo de una lista
Pedro enlace Juan enlace Luis enlace Carlos nulo
Unidad UPersona en donde se implementa el código de la clase TPersona:
unit UPersona;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
//Definición de la clase para la información de un nodo dentro de la lista enlazada simple.
{ TPersona }
TPersona = class
private
cedula:integer;
apellido:string;
nombre:string;
sexo:char;
edad:byte;
//Este atributo corresponde al apuntador que permite enlazar el nodo con el siguiente nodo de la lista.
siguiente:TPersona;
public
//método constructor de la clase.
constructor Create;
//Declaración de los métodos modificadores de los atributos declarados en la clase.
procedure setCedula(ced:integer);
procedure setApellido(ape:string);
procedure setNombre(nom:string);
procedure setSexo(sex:char);
procedure setEdad (ed:byte);
procedure setSiguiente(sig:TPersona);
//Declaración de los métodos selectores de los atributos declarados en la clase.
function getCedula:integer;
function getApellido:string;
function getNombre:string;
function getSexo:char;
function getEdad:byte;
function getSiguiente:TPersona;
end;
implementation
{ TPersona }
constructor TPersona.Create;
begin
cedula:=0;
apellido:='';
nombre:='';
sexo:=#0;
//El símbolo # permite hacer referencia a un carácter por su código ASCII.
siguiente:=nil;
//se asigna el valor de nulo inicialmente al apuntador de primer nodo de la lista.
end;
procedure TPersona.setCedula(ced: integer);
begin
cedula:=ced;
end;
procedure TPersona.setApellido(ape: string);
begin
apellido:=ape;
end;
procedure TPersona.setNombre(nom: string);
begin
nombre:=nom;
end;
procedure TPersona.setSexo(sex: char);
begin
sexo:=sex;
end;
procedure TPersona.setEdad(ed: byte);
begin
edad:=ed;
end;
procedure TPersona.setSiguiente(sig: TPersona);
begin
siguiente:=sig;
end;
function TPersona.getCedula: integer;
begin
Result:=cedula;
end;
function TPersona.getApellido: string;
begin
Result:=apellido;
end;
function TPersona.getNombre: string;
begin
Result:=nombre;
end;
function TPersona.getSexo: char;
begin
Result:=sexo;
end;
function TPersona.getEdad: byte;
begin
Result:=edad;
end;
function TPersona.getSiguiente: TPersona;
begin
Result:=siguiente;
end;
end.
Unidad UDeclararLista en donde se implementa el código de la clase TListaPersona:
unit UDeclararLista;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, UPersona, Dialogs;
type
{ TListaPersona }
TListaPersona = class
private
//Declaramos el atributo correspondiente al primer nodo de la lista (cabecera), el cual tendrá un objeto de la
//clase TPersona.
cabeza:TPersona;
public
constructor Create;
//método constructor de la clase.
//Declaración de los métodos selectores y modificadores para asignar al nodo de cabecera un elemento de
//la clase TPersona o para obtener un elemento de la clase TPersona del nodo cabecera.
procedure setCabeza(cab:TPersona);
function getCabeza:TPersona;
//Este método recorre la lista y devuelve el apuntador del ultimo nodo de la lista.
function ultimo:Tpersona;
//Declaración de los métodos, correspondientes a las diferentes operaciones que se pueden realizar sobre la
//lista.
procedure agregar(per:TPersona);
//Declaración del método que permite buscar un elemento en la lista pasando como parámetro la cedula de
//la persona.
function buscar(ced:integer):TPersona;
//Declaración del método que me permite eliminar un nodo con al información de una persona especifica.
procedure eliminar(per:TPersona);
//Declaración del método que borra el nodo recibiendo como parámetro la cedula de una persona especifica.
procedure eliminarNodo(ced:integer);
//Declaración del método que borra todos los nodos de la lista.
procedure limpiar;
//Declaración del método que recoge la basura de la memoria, debe ser sobre escrito (override) para que
//haga lo de su clase padre.
destructor Destroy;override;
end;
implementation
{ TListaPersona }
//inicial izamos la lista en blanco o en vacío, asignando al primer nodo que se crea (cabeza) el valor de nulo.
constructor TListaPersona.Create;
begin
cabeza:=nil;
end;
procedure TListaPersona.setCabeza(cab: TPersona);
begin
cabeza:=cab;
end;
function TListaPersona.getCabeza: TPersona;
begin
Result:=cabeza;
end;
//Implementación del método que permite recorrer la lista hasta su ultimo elemento (nodo)
//y devuelve el apuntador del ultimo nodo de la lista junto con su información.
function TListaPersona.ultimo: Tpersona;
var
//Declaramos una variable temporal para que apunte al primer nodo de la lista.
temp:TPersona;
begin
temp:=cabeza;
//a la variable temporal le asigno el primer nodo de la lista (cabeza).
//mientras que la cabeza sea diferente de nulo, es decir que la lista no este vacía y no se haya llegado a su
//ultimo elemento entonces temporal apunta al primer nodo de la lista, luego preguntamos si el siguiente del
//primer nodo (cabeza), es nulo, esto quiere decir que ese primer nodo es el único nodo de la lista y se
//rompe el ciclo, porque el ultimo nodo siempre tiene como nulo a su siguiente.
while temp <> nil do
begin
if temp.getSiguiente = nil then
break
else
//si no se da la primera condición hacemos que el apuntador del nodo temporal, apunte al siguiente nodo de
//la lista.
temp:=temp.getSiguiente;
end;
Result:=temp;
end;
//Implementación del método que permite agregar la información de una persona (per) en un nuevo nodo al
//final de la lista. Este método recibe como parámetro un objeto de la clase TPersona.
procedure TListaPersona.agregar(per: TPersona);
begin
//si no existe ningún nodo en la lista, es decir que la lista este vacía, entonces inserto un primer nodo y le
//asigno la información de la persona.
if cabeza = nil then
begin
cabeza:=per;
end
else
begin
//si no es el primer nodo que se agrega, entonces al ultimo nodo que ya existe en la lista, le decimos que
//apunte su siguiente, que es el nuevo nodo que se agregara con al información de la persona.
ultimo.setSiguiente(per);
end;
end;
//Implementación del método que busca la información de una persona en la lista, pasando la cedula de una
//persona como parámetro.
function TListaPersona.buscar(ced: integer): TPersona;
var
temp:TPersona;
begin
temp:=cabeza;
//Mientras no este vacía la lista y no se haya llegado al final de la lista.
while temp <> nil do
begin
//si el nodo temporal tiene la información que se busca, quiere decir que se ha encontrado el nodo con la
//información y se rompe el ciclo.
if temp.getCedula = ced then
break
else
//Pero si no, pasamos al siguiente nodo de la lista, asignando a la variable temporal el nuevo nodo.
temp:=temp.getSiguiente;
end;
Result:=temp;
end;
//Este método permite eliminar un nodo de la lista con la información referente a una persona. Para la
//Implementación de este método se pueden dar dos posibilidades, una que el nodo que se busca para
//eliminar este en la primera posición de la lista o que el nodo a eliminar este en los próximos elementos de
//la lista, incluso en el ultimo.
procedure TListaPersona.eliminar(per: TPersona);
var
temp:TPersona;
//la variable temporal apuntara al nodo anterior al que se esta buscando.
begin
//Si el nodo a eliminar es el primero de la lista, entonces movemos el apuntador (cabeza) a su siguiente.
if cabeza = per then
begin
cabeza:=cabeza.getSiguiente;
//movemos el apuntador (cabeza) a su su siguiente nodo inmediato.
end
else
//Si el primero no es el nodo que quiero eliminar de la lista entonces quiere decir que puede ser el ultimo o
//un nodo intermedio, entonces necesitamos recorrer la lista y conocer cual es el nodo anterior al que quiero
//borrar, para pasar el apuntador del anterior al siguiente nodo del que quiero borrar.
begin
temp:=cabeza;
//mientras que el siguiente nodo del nodo en el que estoy no tenga como siguiente al nodo que se esta
//buscando (per) entonces asigno a la variable temporal el siguiente nodo de la lista.
while temp.getSiguiente <> per do
begin
temp:= temp.getSiguiente;
end;
//pero si el apuntador del nodo actual (temp) apunta al nodo que estoy buscando, entonces quiere decir que
//me encuentro en el nodo anterior al nodo que se busca. El apuntador siguiente del nodo (temp), lo coloco
//como igual al apuntador siguiente del nodo buscado (per). Es decir el apuntador del nodo anterior al
//buscado pasa a apuntar al nodo que sigue después de nodo que se busca.
temp.setSiguiente(per.getSiguiente);
end;
per.setSiguiente(nil);
//Cortamos el enlace del nodo que vamos a borrar, hacia su nodo siguiente.
per.Free;
//Destruimos el nodo que estamos borrando.
end;
//Implementación de otro método para eliminar un nodo.
procedure TListaPersona.eliminarNodo(ced: integer);
var
temp:TPersona;
begin
//Buscamos el nodo con la información de la cedula igual al numero de cedula pasado como parámetro.
temp:=buscar(ced);
//si el nodo buscado es diferentes de nil quiere decir que se encontró el nodo el la lista y lo elimino.
if temp <> nil then
begin
eliminar(temp);
end
else
begin
ShowMessage('La persona con cedula '+IntToStr(ced)+' NO se encuentra en la lista');
end;
end;
procedure TListaPersona.limpiar;
begin
//Borramos siempre el primer nodo de la lista, o borramos uno a uno los elementos de la lista hasta que este
//vacía.
while cabeza <> nil do
begin
eliminar(cabeza);
//Eliminamos el primer nodo y así sucesivamente si existen varios nodos en la lista.
end;
end;
destructor TListaPersona.Destroy;
begin
limpiar;
//Destruimos todos los nodos que pueda tener la lista.
inherited Destroy;
//Llamamos al destructor de la clase padre (implícita en la clase TObject).
end;
end.
Además de los métodos implementados anteriormente con las operaciones básicas que
se puede hacer sobre las listan, también podemos declarar de métodos que permiten
recorrer la lista y realizar operaciones de búsquedas especificas sobre la lista.
Para complementar el ejercicio anterior podemos agregar los siguientes métodos en la
declaración de clase
TListaPersona, para implementarlos:
//Declaración del método que permite saber el número de personas registradas en la lista, es decir el
//número de nodos de la lista.
function totalPersona:integer;
//Declaración del método que calcula el número de personas aptas para votar.
function totalVotantes:integer;
//Declaración del método que calcula el promedio de edad de las personas de la lista.
function promedioEdad:real;
//-------------> Implementación de los métodos declarados en la parte publica de la clase TListaPersona.
//Implementación del método que recorre la lista y cuenta el número de nodos (personas) agregados a esta.
function TListaPersona.totalPersona: integer;
var
temp:TPersona;
contPer:integer;
begin
contPer:=0;
temp:=cabeza;
//Siempre que no haya llegado al final de la lista, se cuenta el nodo con al información de la persona y se
//pasa al próximo nodo, si este existe, sino se sale del siclo while.
while temp <> nil do
begin
contPer:=contPer+1;
temp:=temp.getSiguiente;
end;
Result:=contPer;
end;
//Implementación del método que recorre la lista y cuenta el número de personas aptas para votar, osea las
//mayores de 18 años.
function TListaPersona.totalVotantes: integer;
var
votantes:integer;
temp:TPersona;
begin
votantes:=0;
temp:=cabeza;
//Siempre que no haya llegado al final de la lista, se pregunta que la persona sea mayor de 18 años, si esto
//se cumple la persona es apta para botar y se cuenta.
while temp <> nil do
begin
if temp.getEdad>=18 then
begin
votantes:= votantes + 1;
end;
temp:=temp.getSiguiente;
end;
Result:=votantes;
end;
//Implementación del método que calcula el promedio de edad de las personas de la lista.
function TListaPersona.promedioEdad: real;
var
//Declaramos dos variables, una para contar el numero de personas (cp) y otra para sumar la edades(se).
se, cp: integer;
temp:TPersona;
begin
cp:=0;
se:=0;
temp:=cabeza;
while temp <> nil do
//Siempre que no haya llegado al final de la lista.
begin
cp:=cp+1;
//Contador para el número de personas.
se:=se+temp.getEdad;
//Sumador de las edades.
temp:=temp.getSiguiente;
//pasamos al próximo nodo de la lista.
end;
if cp > 0 then
Result:=se/cp
else
Result:=0;
end;
Cuando creamos el nuevo proyecto para implementar el ejercicio, automáticamente se
crea una unidad con la clase TForm1. Se procedió a guardar esta unidad con el nombre
Unidad UVentanaLista en donde se implementa el código de la clase TListaPersona:
unit UVentanaLista;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, UDeclararLista, UPersona, StdCtrls;
type
{ TForm1 }
TForm1 = class(TForm)
bAgregar: TButton;
bBuscar: TButton;
bEliminar: TButton;
bMostar: TButton;
bLimpiar: TButton;
bSalir: TButton;
bEliminardos: TButton;
bCalcular: TButton;
ced: TEdit;
ape: TEdit;
op: TComboBox;
eda: TEdit;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
verdatos: TListBox;
sex: TComboBox;
Label4: TLabel;
nom: TEdit;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure bAgregarClick(Sender: TObject);
procedure bBuscarClick(Sender: TObject);
procedure bCalcularClick(Sender: TObject);
procedure bEliminarClick(Sender: TObject);
procedure bEliminardosClick(Sender: TObject);
procedure bLimpiarClick(Sender: TObject);
procedure bMostarClick(Sender: TObject);
procedure bSalirClick(Sender: TObject);
private
//Declaramos un atributo (instancia) global para la clase TListaPersona; para toda la ventana.
lis:TListaPersona;
//Declaración del Método para llenar una instancia de persona con datos desde la ventana.
procedure llenar(per:TPersona);
//Declaración del Método para mostrar los atributos de una instancia de persona hasta la ventana
procedure mostrar(per:TPersona);
//Declaración del Método para limpiar los controles (TEdit) de la ventana.
procedure Limpiar;
public
{ public declarations }
end;
var
Form1: TForm1;
implementation
{ TForm1 }
procedure TForm1.FormShow(Sender: TObject);
begin
ced.SetFocus;
end;
//Programar el evento del botón que agrega la información a cada nodo de la lista.
procedure TForm1.bAgregarClick(Sender: TObject);
var
per:TPersona;
//se declara la Instancia (per) para la nueva persona que se va a crear.
begin
//Buscamos la cedula para ver si no esta en alguno de los nodos, si es así agregamos la información a un
//nuevo nodo.
if lis.buscar(StrToInt(ced.Text)) = nil then
begin
per:=TPersona.Create;
//Creamos una nueva instancia de la clase TPersona.
llenar(per);
//Llenamos esta nueva persona con los datos de la ventana.
lis.agregar(per);
//Agregamos a la lista la información de una nueva persona.
ShowMessage('La información se agrego correctamente');
Limpiar;
//Limpiamos los controles de la ventana.
end;
end;
//Programar el evento del botón que busca la información de la persona en uno de los nodos de la lista,
//pasando como parámetro el número de la cedula de la persona.
procedure TForm1.bBuscarClick(Sender: TObject);
var
per:TPersona;
begin
//Buscamos el nodo con la información de persona con la cedula digitada en el TEdit de nombre ced.
per:=lis.buscar(StrToInt(ced.Text));
if per <> nil then
//Si la variable per es distinta de nil, entonces encontramos la información en un nodo.
begin
mostrar(per);
//Llenamos los controles de la ventana con los datos de la persona.
end
//Si per es igual a nil quiere decir que no se encontró el nodo buscado y mandamos un mensaje.
else
begin
ShowMessage('La persona con cedula '+ced.Text+' No existe');
Limpiar;
//Limpiamos los controles de la ventana.
end;
end;
//Programar el evento del botón que llama a los métodos que recorren la lista y realizan operaciones de
//búsquedas especificas sobre la información de la persona en cada uno de los nodos de ls lista.
//Teniendo en cuenta la opción ItemIndex del TComboBox de nombre op, se llama al método requerido para
//realizar la operación y se muestran los resultados en el TListBox de nombre verdatos.
procedure TForm1.bCalcularClick(Sender: TObject);
begin
if op.ItemIndex = 0 then
begin
verdatos.Clear;
verdatos.Items.Add('El numero de personas en la lista es: '+IntToStr(lis.totalPersona));
end
else
if op.ItemIndex = 1 then
begin
verdatos.Clear;
verdatos.Items.Add('El numero de personas aptas para votar es: '+IntToStr(lis.totalVotantes));
end
else
begin
verdatos.Clear;
verdatos.Items.Add('El promedio de edad de las personas es: '+FloatToStr(lis.promedioEdad));
end;
end;
//Programar el evento del botón para eliminar la información de una persona.
procedure TForm1.bEliminarClick(Sender: TObject);
var
per:TPersona;
begin
//Buscamos la persona que vamos a eliminar y como parámetro se pasa la cedula digitada en el TEdit de
//nombre ced.
per:=lis.buscar(StrToInt(ced.Text));
if per <> nil then
//Si per es distinto de nil, entonces encontramos el nodo a eliminar con la información.
begin
lis.eliminar(per); /
/Borramos la instancia de la persona encontrada.
ShowMessage('Persona eleiminada exitosamente');
end
else
begin
ShowMessage('Esta cedula no existe');
end;
Limpiar;
//Limpiamos los controles de la ventana.
end;
//Programar el evento del otro botón para eliminar la información de una persona. Recuerden que en la
//clase TListaPersona declaramos dos métodos que realizaban esta función. Entonces podemos utilizar
//cualquiera de los dos metodos para eliminar.
procedure TForm1.bEliminardosClick(Sender: TObject);
begin
lis.eliminarNodo(StrToInt(ced.Text));
Limpiar;
end;
//Implementación del evento para el botón que borra todos los nodos de la lista y limpia los controles de la
//ventana.
procedure TForm1.bLimpiarClick(Sender: TObject);
begin
lis.limpiar;
Limpiar;
end;
//Implementación del evento para el botón que muestra al información de todos los nodos de la lista
//(información de las personas), en el TListBox de nombre verdatos.
procedure TForm1.bMostarClick(Sender: TObject);
var
per:TPersona;
begin
verdatos.Clear;
//Limpiamos los datos actuales de la lista o cualquier información del TListBox.
Per:=Lis.getCabeza;
//Empezamos a recorrer desde la cabeza, es decir el primer nodo de la lista.
while(per<>nil) do
//Mientras que no lleguemos al final de la lista.
begin
//Vamos mostrando los datos de cada persona de la lista en el TListBox de nombre verdatos.
verdatos.Items.Add(IntToStr(per.getCedula) + #32 + per.getApellido + #32 + per.getNombre + #32 +
IntToStr(per.getedad) + #32 + per.getsexo);
per:=per.getSiguiente;
//Y pasamos al siguiente nodo de la lista.
end;
end;
procedure TForm1.bSalirClick(Sender: TObject);
begin
Close;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
//Inicializamos las instancias para las clases TListaPersona.
lis:=TListaPersona.Create;
end;
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
lis.Free;
end;
//Implementación del método que llena una instancia de la persona, con los datos digitados en la ventana.
procedure TForm1.llenar(per: TPersona);
begin
per.setCedula(StrToInt(ced.Text));
per.setApellido(ape.Text);
per.setNombre(nom.Text);
per.setSexo(sex.Text[1]);
//Del texto del sexo tomamos solo el primer carácter (1).
per.setEdad(StrToInt(eda.Text));
end;
//Implementación del método que muestra en los controles de la ventana la información correspondiente a
//una persona especifica.
procedure TForm1.mostrar(per: TPersona);
begin
ced.Text:=IntToStr(per.getCedula);
ape.Text:=per.getApellido;
nom.Text:=per.getNombre;
sex.Text:=per.getSexo;
eda.Text:=IntToStr(per.getEdad);
end;
//Implementación del método que limpia los controles de la ventana.
procedure TForm1.Limpiar;
begin
ced.Clear;
ape.Clear;
nom.Clear;
sex.Text:='';
eda.Clear;
verdatos.Clear;
ced.SetFocus;
end;
initialization
{$I uventanalista.lrs}
end.
No hay comentarios:
Publicar un comentario