Foros Club Delphi - Clases que dependen de un tipo de datos

Foros Club Delphi (https://www.clubdelphi.com/foros/index.php)

- OOP (https://www.clubdelphi.com/foros/forumdisplay.php?f=5)

- - Clases que dependen de un tipo de datos (https://www.clubdelphi.com/foros/showthread.php?t=4592)

Clases que dependen de un tipo de datos

La idea es hacer una lista doblemente enlazada en memoria en la que se puede guardar cualquier cosa, y poder enlazar cada registro en memoria, con cualquier cosa (Tag de un Twincontrol, o con cada elemento de un Tstring)

Es para evitar el uso del Tstring.AddObject, ya que al usar ese método, tenemos que encargarnos de crear / liberar cada objeto y hacer un casting cada vez que queremos acceder a dicho elemento.

Estoy creando una clase que al tiempo de crearla, se debe decir el tipo de dato que va a contener, por ejemplo:

Código:



type pTMemory = record

   anterior, siguiente : Pointer;

   datos : TRecordFile;

end;



TListaEnlazada = class

private



  FFile : File of TRecordFile ;

  Fdatos: TRecordFile ;



  FnumReg: Integer;

  FLista : ptMemory;

  FLast   : ptMemory;

  FnActual : Integer;

  Factual  : pTMemory;

  FBeforeAdd:TBeforeAdd;

  FAfterAdd:TAfterAdd;

    FBeforeDelete: TBeforeDelete;

    FAfterDelete:TAfterDelete;

public

    procedure LoadFromFile(const FileName :string);

    procedure SaveToFile (const FileName:string);

    constructor Create;

    destructor  Free;



    procedure Anade(Value:TrecordFile);

    function AlPrimero: TRecordFile;

    function AlSiguiente: TRecordFile;

    function AlAnterior: TRecordFile;

    function AlUltimo: TRecordFile;

    function Borra(indice:Integer):Boolean;

    function Mover(desde, Al :Integer):Integer;



end;

Como veis Creo un descriptor de ficheros del tipo File of TRecordFile.

Lo que quiero es que al crear la clase se pudiera hacer esto:

Código:

L := TLIstaEnlazada.Create(TRecordFile);

Haciendo independiente la clase del tipo de registro usado.

¿Se puede hacer?

Gracias infinitas por vuestra ayuda

Sin ahondar demasiado en tu pregunta... ¿Es esto lo que buscas?:

Código:

type

  TRecordFileClass = class of TRecordFile;



  TListaEnlazada = class

  private

    ... 

  public

    constructor Create(RecordClass: TRecordFileClass);

  end;

Saludos!

po si, po si, tiene muy buena pinta la respuesta delphi.com.ar

Lo pruebo y comento el resultado.

Muchas gracias

Con mucho acongojo tengo que informar que no compila :(

type
TRecordFileClass = class of TRecordFile;

el portero de discoteca (en este caso el compilador) dice:
Type Class Required :confused:

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

Intentaré plantear la pregunta de otra forma.

El usuario final de la clase haría algo así como esto:

Crea 2 tipos de datos (registros), Templeado y TFactura

Código:

{private declaration en su forma correspondiente }

      Eclass : TlistaEnlazada;

      Fclass : TlistaEnlazada;

end;



implementation



procedure TFrmMain.FrmMainCreate(Sender: Tobject);

var E : TEmpleado;

      F : TFactura;

begin

  Eclass := TlistaEnlazada.Create(E);

  Fclass := TlistaEnlazada.Create(F);

end;

A partir de aquí ya podria usar su Eclass para añadir empleados
y Fclass para añadir las facturas por ejemplo.

Mi pregunta es: ¿Como debería de estar declarada la clase ListaEnlazada?

He estado mirando la ayuda de Delphi sobre el tema, pero parte
de las Clases Tobject o Tedit, así que el bosque no me deja ver
el árbol.

Creo que se complica la cosa, gracias a dios no sé hasta que punto :p

Saludos y Gracias por adelantado.

No puedes hacer esto:

Código:

type

  TRecordFileClass = class of TRecordFile;

pues, tal como te lo dijo el compilador, TRecordFile tiene que ser una clase.

¿Para qué usar records si puedes usar clases?

Por otra parte no entiendo bien cómo quieres lograr la genericidad. Una vez que usas clases puedes agregar cualquier objeto como se hace con un TObjectList y posteriormente hacer el "casting" cuando tengas que acceder a cada objeto.

Si deseas a toda costa evitar el "casting" puedes definir una clase base para tu lista enlazada que se encargue de todo el manejo (las listas enlazadas sólo requieren un apuntador al objeto que guardan así que pedes hacerla independiente del tipo de objeto):

Código:

type

  TListaEnlazada = class

  protected

    function GetObject(Index: Integer):TObject;



  public

    property Objects[Index: Integer]: TObject read GetObject;

  end;

Después, si necesitas específicamente una lista de facturas crearías un descendiente de TListaEnlazada en donde redefinirías la propiedad Objects:

Código:

type

  TListaFacturas = class

  private

    function GetFactura(Index: Integer):TFactura;



  public

    property Objects[Index: Integer]: TFactura read GetFactura;

  end;

GetFactura simplemente devuelve el Objects[Index] de la clase base pero haciendo el "casting":

Código:

Result := TFactura(inherited Objects[Index]);

El punto aquí es que una vez que la lista base está hecha, los descendientes son muy sencillos de hacer (mera rutina).

Desde luego que lo mejor sería oder declarar algo así como

Código:

property Objects[Index]: TVariantObject;

donde VariantObject puediera cambiarse durante la ejecución. Pero me temo que con Delphi no podrás hacerlo.

// Saludos

Ups... no me había dado cuenta que se trataba de un record....

Si quieres puedes tener un dato del tipo Pointer o un parámetro no tipado, para recibir cualquier puntero a un record.. pero creo que solo complicarías las cosas.

Saludos!

Cita:

Posteado originalmente por roman
¿Para qué usar records si puedes usar clases?

¿Porque soy novato y no se me ocurría otra forma de hacerlo ? :D
La verdad, queria empezar desde cero para despues ir subiendo de nivel, pero ya veo que no me queda más remedio que meterme de lleno en el asunto con los Tobjects para comprender como funciona. :o

Cita:

Posteado originalmente por roman
Por otra parte no entiendo bien cómo quieres lograr la genericidad. Una vez que usas clases puedes agregar cualquier objeto como se hace con un TObjectList y posteriormente hacer el "casting" cuando tengas que acceder a cada objeto.

TObjectList mmm a este señor no lo conozco, tendré que hacerle una visita desde el F1 de delphi antes de continuar con mi listaEnlazada .... parece que es lo mismo que yo estoy haciendo, pero ya está hecho, ¡¡ cachis, se me han adelantado los de Borland !! ya no me llevo el premio nobel :p. En serio, lo miraré detenidamente porque es el siguiente nivel que deseo aprender.

Cita:

Posteado originalmente por roman
GetFactura simplemente devuelve el Objects[Index] de la clase base pero haciendo el "casting":

Código:

Result := TFactura(inherited Objects[Index]);

De lo que se deduce, que el casting no lo puedo eliminar, es más, resulta indispensable.

Parece que he partido de un planteamiento incorrecto :(
Desde luego me habeis enseñado donde está el camino, ahora me toca recorrerlo ;)

¡¡ Muchas gracias por vuestras indicaciones !!