procedimiento de asignación genérico

[gushynet]

buenas de nuevo. Veamos, lo del contenedor generico lo he hecho mas que nada para entender mejor los conceptos relacionados con la poo.

Lo que explica Roman es basicamente lo que he hecho y funciona bien siempre y cuando los objetos que quiera almacenar en el contenedor sean de tipo TElemento o desendiente ya que este objeto tiene las operaciones de asignar y comparar abstractas. Estos metodos los uso dentro del contenedor, concretamente en el metodo que se encarga de añadir un elemento a la lista.


La lista dinamica que implemento usa new y dispose de manera correcta. Ese no es el problema. La lista y en concreto el metodo para añadir un elemento lo que hace es duplicar el elemento pasado por paramero y la funcion asignar es la que realmente asigna los valores al nuevo elemento creado de ahi la necesidad de que los elementos que se quieran guardar en el contenedor deban tener el metodo implementado sino no sabria como asignar el valor de las propiedades de un objeto a otro ya que en principio el contenedor solo se limita a almacenarlos.

Este TElemento es encapsulado en el Nodo que como mencione en el mensaje anterior tiene tres campos, uno de ellos de tipo TElemento. Este campo apunta al objeto duplicado, por lo que el nodo lo que guarda es la ubicacion del objeto en memoria, no el objeto en si.

El metodo para eliminar un nodo de la lista es:

1. busco el elemento en la lista con ayuda de la funcion comparar.
2. una vez encontrado uso el destroy para el elemento al que esta apuntando el campo del Nodo de tipo TElemento.
3. por ultimo libero el nodo de memoria con dispose atualizando tambien los enlaces de la lista que se hayan visto afectados.

En definitiva, el contenedor funciona con objetos de tipo TElemento y desendientes. Y lo que yo quiero es no obligar al usuario a que su jerarquia de clases cuelgue de TElemento para poder usar el contenedor pero si no lo hago asi no podria usar los metodos antes descritos. Y creo que de la forma que lo he hecho aunque funcione ni es eficiente ni elegante.

Con respeto al comentario de Delphius, tienes razon, delphi proporciona clases para lo que busco, pero como se suele decir si quieres lapas hay que mojarse el culo, y pense que la mejor manera de entender la poo en delphi es haciendome yo mismo un contenedor generico y viendo todas las dificultades que se me pueden presentar. En mi caso me quedo mejor con las cosas si le doy vueltas y vueltas hasta encontrar la solucion o al menos el camino para la solucion que si me lo dan todo hecho y mastiado. Soy un masoquista de la programacion que le vamos a hacer.


Con respecto al supuesto despiste cometido por AI Gonzales nada mas agradecerte tu confucion ya que gracias a ello he encontrado un uso a las referencias de clase aunque sigo pensando que tu respuesta me sigue pareciendo mas logica aunque no funcionace



Gracias de antemano por las respuestas. Y bueno, siguo en mi linea de pedir disculpas por lo extenso de las respuestas.


Un saludo.

[roman]

Yo tengo una opinión. Realmente, eso de querer trabajar indistintamente con cualquier objeto, sin depender de qué clase sea, a final de cuentas, ya se aleja de lo que es la POO. En ésta hay clases y jerarquías de clases, y uno espera tal o cual comportamiento de acuerdo a la jerarquía. Hacer clonaciones genéricas (si bien puede tener su uso), y, en general, intentar trabajar de manera arbitraría con cualquier objeto, está ya muy lejos del polimorfismo, no hay ningún comportamiento que puedas esperar o predecir porque en realidad no tienes objetos sino meros contenedores de datos.

Pero como digo, es sólo una opinión

// Saludos

[[Al González]]

Empezado por gushynet

...despiste cometido por AI Gonzales...

¿Y ese quién es?

[[egostar]]

Empezado por Al González

¿Y ese quién es?

Es una nueva clase generada desde la ghClone

Salud OS

[[Delphius]]

Empezado por roman

Yo tengo una opinión. Realmente, eso de querer trabajar indistintamente con cualquier objeto, sin depender de qué clase sea, a final de cuentas, ya se aleja de lo que es la POO. En ésta hay clases y jerarquías de clases, y uno espera tal o cual comportamiento de acuerdo a la jerarquía. Hacer clonaciones genéricas (si bien puede tener su uso), y, en general, intentar trabajar de manera arbitraría con cualquier objeto, está ya muy lejos del polimorfismo, no hay ningún comportamiento que puedas esperar o predecir porque en realidad no tienes objetos sino meros contenedores de datos.

Pero como digo, es sólo una opinión

// Saludos

Pues yo comparto tu visión roman.

Me parece que hay algo en el modelo del dominio que está analizando y diseñando gushynet que niebla o entorpece la comprensión real y el propósito de cada clase.

Si pudieramos conocer con más detalles, ya no con una comprensión micro sobre este problema en particular, sino como algo macro (la clase) tal vez podríamos llegar a formular alternativas.

Saludos,

[[egostar]]

Empezado por Delphius

Pues yo comparto tu visión roman.

Me parece que hay algo en el modelo del dominio que está analizando y diseñando gushynet que niebla o entorpece la comprensión real y el propósito de cada clase.

Si pudieramos conocer con más detalles, ya no con una comprensión micro sobre este problema en particular, sino como algo macro (la clase) tal vez podríamos llegar a formular alternativas.

Saludos,

Yo tal vez estoy confundiendome acerca de lo que se habla en este hilo, pero el nuevo Delphi trae algo que se llama generics and anonymous methods.

Salud OS

[gushynet]

El mensaje es el siguiente ya que aqui tuve problemas con el formateo del codigo

[gushynet]

buenas de nuevo. Antes que nada pedir discupas por no haber presentado al nuevo usuario AI Gonzalez


Creo que lo mejor llegados a este punto, como sugiere un compañero que ha participado en este hilo(el nombre lo dejamos, que no quiero cambiarselo a mas nadie ) es poner parte del codigo.

Primero pondre parte de la jerarquia de clases cuya clase base es TElemento.

A continuacion pondre la clase TContenedor que es la clase base de la jerarquia de contenedores que quiero implementar.

Vamos pues:

Clase TElemento

Código Delphi [-]
unit Clase_TElemento;

interface

  type TElemento = class(TObject)

    protected
      ResultOp : boolean;
      
    public
      function Comparar(E:TElemento):boolean;virtual;abstract;
      procedure Asignar(E:TElemento);virtual;abstract;
      function Resultado():boolean;
  end;
  type TElementoClass = class of TElemento;
implementation

  //----------------------------------------------------------------------------
  function TElemento.Resultado():boolean;
  begin
    Result := ResultOp;
  end;
  //----------------------------------------------------------------------------
  
end.

Clase TParrafo

Código Delphi [-]
unit Clase_TParrafo;

interface
  uses Clase_TElemento;

  type TParrafo = class(TElemento)

    protected
      parrafo:AnsiString;
      ResultOp:boolean;
    private
      procedure SetContenido(p:AnsiString);
    public
      property contenido:AnsiString read parrafo write SetContenido;
      constructor create();virtual;
      function Comparar(E:TElemento):boolean;override;
      procedure Asignar(E:TElemento);override;
      
  end;

implementation

  //----------------------------------------------------------------------------
  constructor TParrafo.Create();
  begin
    inherited create();
    parrafo := '';
    ResultOp := false;
  end;
  //----------------------------------------------------------------------------
  function TParrafo.Comparar(E:TElemento):boolean;
  begin
    ResultOp := false;
    if parrafo = TParrafo(E).parrafo then
      ResultOp := true;
    Result := ResultOp;
  end;
  //----------------------------------------------------------------------------
  procedure TParrafo.Asignar(E:TElemento);
  begin
    ResultOp := false;
    if parrafo <> TParrafo(E).parrafo then
    begin
      parrafo := TParrafo(E).parrafo;
      ResultOp := true;
    end;
  end;
  //----------------------------------------------------------------------------
  procedure TParrafo.SetContenido(p: string);
  begin
    parrafo := p;
  end;
  //----------------------------------------------------------------------------
end.

Clase TPregunta

Código Delphi [-]
unit Clase_TPregunta;

interface
  uses Clase_TParrafo;
  type TPregunta = class(TParrafo)
  
  end;
implementation

end.

Clase TRespuesta

Código Delphi [-]
unit Clase_TRespuesta;

interface

  uses Clase_TParrafo;

  type TRespuesta = class(TParrafo)

  end;
  
implementation

end.

Clase TTematica

Código Delphi [-]
unit Clase_TTematica;

interface

  uses Clase_TElemento,Clase_TParrafo;

  type TTematica = class(TParrafo)

    private
      descr:AnsiString;
      procedure SetDescripcion(d:AnsiString);
    public
      property descripcion:AnsiString read descr write SetDescripcion;
      constructor create();overload;override;
      constructor create(p:AnsiString;d:AnsiString);overload;
      function Comparar(E:TElemento):boolean;override;
      procedure Asignar(E:TElemento);override;
  end;
implementation

  //----------------------------------------------------------------------------
  constructor TTematica.create();
  begin
    inherited create();
    descr := '';
  end;
  //----------------------------------------------------------------------------
  constructor TTematica.create(p: string; d: string);
  begin
    parrafo := p;
    descr := d;
  end;
  //----------------------------------------------------------------------------
  function TTematica.Comparar(E: TElemento):boolean;
  begin
    ResultOp := false;
    if (parrafo = TTematica(E).parrafo)and(descr = TTematica(E).descr) then
      ResultOp := true;
    Result := ResultOp;
  end;
  //----------------------------------------------------------------------------
  procedure TTematica.Asignar(E: TElemento);
  begin
    ResultOp := false;
    if (parrafo <> TTematica(E).parrafo)or(descr<>TTematica(E).descr) then
    begin
      parrafo := TTematica(E).parrafo;
      descr := TTematica(E).descr;
      ResultOp := true;
    end;
  end;
  //----------------------------------------------------------------------------
  procedure TTematica.SetDescripcion(d: string);
  begin
    descr := d;
  end;
  //----------------------------------------------------------------------------
end.

Ahora la clase TContenedor

Código Delphi [-]
unit Clase_TContenedor;

interface

  uses Clase_TElemento;

  type TContenedor = class(TObject)

    protected
      PrimerE : Pointer;
      ActualE : Pointer;
      ResultOp : boolean;
      NumElementos : cardinal;
      function ObtenerID():cardinal;virtual;abstract;

    public
      constructor create();
   
      procedure Add(E:TElemento);virtual;abstract;
      procedure Modificar(E1:TElemento;E2:TElemento);virtual;abstract;
      procedure Eliminar(E:TElemento);virtual;abstract;

      function Esta(E:TElemento):boolean;virtual;abstract;

      procedure Actual(E:TElemento);virtual;abstract;
      procedure Primero();
      procedure Ultimo();virtual;abstract;
      procedure Siguiente();virtual;abstract;
      procedure Anterior();virtual;abstract;

      function NElementos():cardinal;

      procedure Iniciar();virtual;abstract;

      function Resultado():boolean;


  end;

  type TObjectClass = class of TObject;
implementation

  //----------------------------------------------------------------------------
  constructor TContenedor.create();
  begin     PrimerE := nil;
    ActualE := nil;
    ResultOp := false;
    NumElementos := 0;
  end;  
  //----------------------------------------------------------------------------
  procedure TContenedor.Primero();
  begin     
        ResultOp := false;     
        if PrimerE<>nil then     
        begin       
           ActualE := PrimerE;      
           ResultOp := true;     
       end;
  end;
  //----------------------------------------------------------------------------
  function TContenedor.NElementos:cardinal;
  begin     result := NumElementos;   end;
  //----------------------------------------------------------------------------
  function TContenedor.Resultado():boolean;
  begin     result := ResultOp;   end;
  //----------------------------------------------------------------------------
end.

Y ahora la clase TListaSimple que desciende de TContenedor y dos métodos ya que esto se ha hecho demasiado largo

Código Delphi [-]
uses Clase_TElemento,Clase_TContenedor,Clase_TParrafo;

  type PTNodo = ^TNodo;
    TNodo = record
      Id : cardinal;
      Elemento : TElemento;
      siguiente : PTNodo;
    end;

  type TListaSimple = class(TContenedor)

    protected
      function ObtenerID():cardinal;override;

    public

      destructor destroy();override;//
      
      procedure Add(E:TElemento);override;
      procedure Modificar(EAnt:TElemento;ENuevo:TElemento);override;
      procedure Eliminar(E:TElemento);override;

      function Esta(E:TElemento):boolean;override;

      procedure  Actual(E:TElemento);override;

      procedure Ultimo();override;
      procedure Siguiente();override;
      procedure Anterior();override;

      procedure Iniciar();override;

  end;

Y ahora los dos proedimientos: Add y Actual

Procedimiento Add

Código Delphi [-]
procedure TListaSimple.Add(E: TElemento);
  var
    nuevo,actual,anterior:PTNodo;
    Elemento : TElemento;
    s:string;
  begin
    if Esta(E) = false then
    begin
      s := E.ClassName;
      Elemento := TElementoClass(E.ClassType).Create(); 
      TElementoClass en lugar de poner directamente
      //la clase base TElemento
      Elemento.Asignar(E);
      new(nuevo);
      nuevo.Id := ObtenerID();
      nuevo.Elemento := Elemento;
      nuevo.siguiente := nil;

      nuevo.Elemento := Elemento;
      if PrimerE = nil then
        PrimerE := nuevo
      else
      begin
        actual := PrimerE;
        anterior := nil;
        while  (actual<>nil) and (actual.Id < nuevo.Id) do
        begin
          anterior := actual;
          actual := actual.Siguiente;
        end;
        if anterior = nil then // va el primero
        begin
          nuevo.Siguiente := PrimerE;
          PrimerE := nuevo;
        end
        else
        begin
          if actual = nil then //va al final
            anterior.Siguiente := nuevo
          else //va entre dos nodos
          begin
            nuevo.Siguiente := actual;
            anterior.Siguiente := nuevo;
          end;
        end;
      end;
      NumElementos := NElementos + 1;
      ResultOp := true;
    end
    else
      ResultOp := false;
  end;

Procedimiento Actual

Código Delphi [-]
procedure TListaSimple.Actual(E:TElemento);
  begin
    ResultOp := true;
    if PrimerE <> nil then
    begin
      if ActualE <> nil then
        E.Asignar(PTNodo(PrimerE).Elemento);
    end
    else
    begin
      ResultOp := false;
    end;
  end;

Espero que ahora se entienda mejor la historia que tengo entre manos aunque entendere que despues de los largo que se ha hecho espereis a la pelicula para ver como se resuelve el problema

Un saludo y gracias por las respuestas, las anteriores a este mensaje y las posibles despues de ese mensaje

[[Al González]]

Empezado por egostar

Es una nueva clase generada desde la ghClone

Salud OS

Ah, siendo así, más bien sería una nueva instancia.

[[egostar]]

Empezado por Al González

Ah, siendo así, más bien sería una nueva instancia.

Ah si, perdón, no se que estaba pensando

Salud OS