¿Qué diferencia hay entre copiar y clonar objetos?

[noob]

Hola,

Nunca uso estas características de la OOP en Delphi, ¿me podríais asesorar un poco?

Muchas gracias.

[roman]

¿En delphi se pueden clonar objetos? Será en las nuevas versiones porque antes no era posible.

En todo caso, aunque no sé si responda a tu duda, has de saber que en delphi las variables de tipo objeto son, en realidad, apuntadores al objeto, de manera que, cuando copias uno a otro:

Código Delphi [-]
ObjetoB := ObjetoA;

en realidad sólo estás copiando los apuntadores, de forma que ObjetoA y ObjetoB son dos apuntadores que apuntan al mismo objeto. Si haces un cambio en las propiedades de ObjetoA, dicho cambio se reflejará en ObjetoB.

Una clonación de objetos -que, repito, no sabía que se puede hacer en delphi- es crear un objeto aparte pero exactamente igual al primero. En ese caso, los cambios a un objeto ya no se reflejarían en el otro.

En el caso de delphi 7, que es el que conozco, no existe tal cosa como la clonación de objetos, aunque hay algo similar en los objetos de la clase TPersistent (y derivadas) con los métodos Assign y AssignTo, con los cuales se pretende hacer una copia de un objeto, aunque no es tanto como una clonacón y muchas veces tiene uno que implementar dichos métodos explícitamente.

// Saludos

[Neftali [Germán.Estévez]]

A mi me gustaría ver noob, un pequeño ejemplo de copiar un objeto y clonar un objeto, para saber de qué estamos hablando.

[noob]

Hola,

Lo he resuelto.

roman, he visto una forma de clonar objetos en Delphi. Neftali, pongo un ejemplo de todo lo que he hecho.

Por ejemplo, tengo un objeto 'myObject' que quiero mantener en el atributo 'FObject' de otro objeto, pero quiero que mantenga su valor original aunque el objeto 'myObject' cambie en un futuro. Para ello, no me queda otra que clonar el objeto. Pongo el código que he utilizado:

Código Delphi [-]
function cMyClass.Clone: cMyClass;
begin
  Result := cMyClass.Create;
end;

Luego, quiero que ese objeto clonado tenga los mismos valores que el objeto 'myObject', por ello, hago una copia:

Código Delphi [-]
procedure cMyClass.Copy(obj: cMyClass);
begin
 obj.Attribute_1 := FAttribute_1;
 obj.Attribute_2 := FAttribute_2;
 ...
 obj.Attribute_n := FAttribute_n; // Se copian los atributos del 1 hasta el n
end;

El uso desde una clase externa a 'cMyClass' sería así:

Código Delphi [-]
...
if Assigned(FObject) then
  FObject.Destroy; // Si el atributo 'FObject' apunta a algo distinto de nil 
// entonces liberamos memoria. Es por si llamamos más de una vez a todo este código.
FObject := myObject.Clone; // 'myObject' tiene información que queremos 
// mantener en el atributo 'FObject' de la clase en la que nos encontramos. 
// Aunque 'myObject' cambie en un futuro no queremos que los cambios se reflejen en 'FObject'
myObject.Copy(FObject); // Se copia toda la información de 'myObject' en 'FObject'
...

Funciona como esperaba, espero que se entienda y le sirva a alguien.

Saludos.

[roman]

Bueno, lo que estás haciendo es similar a lo que te comenté del AssignTo del objeto TPersitent. Realmente el método Clone sale sobrando:

Código Delphi [-]
FObject := cMyClass.Create;
myObject.Copy(FObject);

// Saludos

[ecfisa]

Hola noob.

También podrías hacer la creación y copia de los atributos en un paso:

Código Delphi [-]
function cMyClass.Clone: cMyClass;
begin
  Result := cMyClass.Create;
  Move(Self, Result, SizeOf(Self));
end;

Saludos.

[Neftali [Germán.Estévez]]

Empezado por noob

Funciona como esperaba, espero que se entienda y le sirva a alguien.

Ahora ya sí te he entendido.

Gracias por la explicación.

[roman]

Empezado por ecfisa

Código Delphi [-]
function cMyClass.Clone: cMyClass;
begin
  Result := cMyClass.Create;
  Move(Self, Result, SizeOf(Self));
end;

¡Ah, caramba! Esto no funcionaría ecfisa. Copiaría tan sólo campos, variables declaradas dento de la clase, pero no las propiedades.

// Saludos

[ecfisa]

Empezado por roman

¡Ah, caramba! Esto no funcionaría ecfisa. Copiaría tan sólo campos, variables declaradas dento de la clase, pero no las propiedades.

// Saludos

Si, es cierto. Creo que tenes razón, se me escaparon las propiedades...

Saludos.

[Neftali [Germán.Estévez]]

A ver si este artículo de Zarko Gajic titulado "How to clone a Delphi form" aclara o ayuda algo.

[roman]

Es interesante, y supongo que puede hacerse con cualquier objeto de la clase TPersistent. Para objetos en general, el problema no está tanto con las propiedades, como dije arriba, puesto que si se copia toda la imagen del objeto en memoria, tal como hace ecfisa, supongo que también se copiarán los campos privados y, en general, el estado del objeto desde el cual se leen las propiedades. Pero el problema son las referencias; subobjetos, cadenas, etc.

Este tema lo tiene dominado Al González, según entiendo. En este hilo menciona que algun vez resolvió ese problema y menciona cuáles son los puntos a tomar en cuenta.

No es trabajo fácil.

// Saludos

[ecfisa]

Empezado por roman

tal como hace ecfisa, supongo que también se copiarán los campos privados y, en general, el estado del objeto desde el cual se leen las propiedades.

La verdad, sigo en la duda si con Move se copia la la totalidad, por lo que hice una pequeña prueba:

Código Delphi [-]
...
type
  TCadenaChange = procedure of object;
  TMiClase = class
  private
    F_PI : Double;
    FCadena : string;
    FCadenaChange : TCadenaChange;
    function GetCadena: string;
    procedure SetCadena(Cadena: string);
    procedure AvisoCambioCadena;
  public
    constructor Create;
    property Cadena: string read GetCadena write SetCadena;
    property CadenaOnChange: TCadenaChange read FCadenaChange
      write FCadenaChange;
    function Clone: TMiClase;
    ...
  end;

constructor TMiClase.Create;
begin
  F_PI := 3.141592654;
  FCadenaChange:= AvisoCambioCadena;
end;

procedure TMiClase.AvisoCambioCadena;
begin
  ShowMessage(Format('Cambio Cadena: %s %0.9f',[Cadena, F_PI]) );
end;

function TMiClase.GetCadena: string;
begin
  Result := FCadena;
end;

procedure TMiClase.SetCadena(Cadena: string);
begin
  if Cadena <> FCadena then
  begin
    FCadena:= Cadena;
    if Assigned(FCadenaChange) then
      FCadenaChange;
  end;
end;

function TMiClase.Clone: TMiClase;
begin
  Result:= TMiClase.Create;
  Move(Self,Result,SizeOf(Self));
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  c1,c2: TMiClase;
begin
  c1 := TMiClase.Create;
  c1.Cadena:= 'XXXX'; // dispara evento (lógicamente)

  c2 := c1.Clone;
  ShowMessage(c2.Cadena); // XXXX
  c2.Cadena := 'YYYY';   // también dispara evento
  ...
end;
...

Y en ella pareciera que campos, propiedades y eventos son conservados mediante la llamada a Clone. Sin embargo no sé por qué, pienso que se me está escapando algo...

Saludos.

[roman]

Pero, por ejemplo, si haces:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
  c1,c2: TMiClase;

begin
  c1 := TMiClase.Create;
  c1.Cadena:= 'XXXX';

  c2 := c1.Clone;
  c2.Cadena := 'YYYY';

  ShowMessage(c1.Cadena); // Muestra 'YYYY' en lugar de 'XXXX'
end;

Es decir, c2.Cadena y c1.Cadena hacen referencia a la misma cadena. En un clonación, el objeto clonado debería ser inicialmente igual al original en todo aspecto pero cambios posteriores no deberían afectar al otro.

Lo mismo sucedería si tu objeto tuviera otros objetos como propiedades.

Por otra parte, un string lleva un conteo de referencia que, me parece, se alteraría con una asignación usando Move. Es decir, habría dos variables apuntando a la misma cadea pero con un conteo de referencia igual a 1.

Haz la prueba:

Código Delphi [-]
var
  c1,c2: TMiClase;

begin
  c1 := TMiClase.Create;
  c1.Cadena:= 'XX';

  c2 := c1.Clone;
  c1.Free;

  c2.Cadena := 'Hola'; // Genera una violación de acceso porque la cadena origanl ya murió.
  c2.Free;
end;

Y ni qué decir de interfaces, que también llevan un conteo de referencias.

// Saludos

[ecfisa]

Hola roman.

Quedó aclarado lo que se me estaba escapando

Saludos.

[roman]

Por ahí vi que nuestro amigo Al estaba respondiendo a este hilo Con seguridad tiene algo interesante que decir .

// Saludos

[[Al González]]

Empezado por ecfisa

Código Delphi [-]
...
function TMiClase.Clone: TMiClase;
begin
  Result:= TMiClase.Create;
  Move(Self,Result,SizeOf(Self));
end;
...

Y en ella pareciera que campos, propiedades y eventos son conservados mediante la llamada a Clone. Sin embargo no sé por qué, pienso que se me está escapando algo...

Hola ecfisa . Seguramente recordarás que los dos primeros parámetros de Move no son punteros a los buffers origen y destino, sino los buffers en sí (parámetros sin tipo). Es decir, de esa forma está copiando el puntero Self sobre el puntero Result (igual que una sentencia "Result := Self") y "SizeOf(Self)" devuelve el tamaño de un puntero: 4 bytes (u 8 en ejecutables de 64 bits).

Ambas direcciones de memoria pueden ser "desreferidas" (¿está bien escrito, Ñuño? ) y usar el método InstanceSize en lugar de la función SizeOf, a fin de conseguir con Move la copia que se quiere. Pero, se atraviesan algunos problemas:

• Campos (directos o indirectos) que llevan conteo de referencias, como cadenas String, interfaces, arreglos dinámicos (lo mencionado por Román).
• Sub-objetos internos que también deban ser clonados.
• Campos THandle que guardan identificadores únicos provenientes de APIs (como es el caso de los controles de la VCL).
• Campos puntero hacia estructuras particulares del objeto.

El primer punto se resuelve mediante las funciones _CopyRecord y _CopyObject (aunque ésta última parece estar incompleta y sólo llamar a _CopyRecord). Pero el resto de los puntos son quizá la razón de por qué la clonación de bajo nivel es un tema relegado a la alquimia.

De ahí que hoy, cuando deseo realizar alguna clonación de objetos, me limito a crear un objeto de la misma clase al cual copio sólo las propiedades publicadas, disponibles mediante reflexión (RTTI), y evitando aquellas que pudieran causar algún conflicto.

Saludos.

[roman]

Empezado por Al González

Hola ecfisa . Seguramente recordarás que los dos primeros parámetros de Move no son punteros a los buffers origen y destino, sino los buffers en sí (parámetros sin tipo). Es decir, de esa forma está copiando el puntero Self sobre el puntero Result (igual que una sentencia "Result := Self") y "SizeOf(Self)" devuelve el tamaño de un puntero: 4 bytes (u 8 en ejecutables de 64 bits).

¡Ah! Ni siquiera me había fijado en eso. ¿Cómo sería la desreferencia? ¿Algo así:

Código Delphi [-]
Pointer(c1)^

// Saludos

[[Al González]]

Empezado por roman

Por ahí vi que nuestro amigo Al estaba respondiendo a este hilo Con seguridad tiene algo interesante que decir .

En buena estima me tienes, amigo.

Esa referencia de 2004 me hizo recordar que tardé muchos años en salir de la adolescencia . Aunque ya desde entonces planteaba cosas raras .

Empezado por roman

¡Ah! Ni siquiera me había fijado en eso. ¿Cómo sería la desreferencia? ¿Algo así:

Código Delphi [-]
Pointer(c1)^

En efecto, un molde de tipo puntero sobre la variable objeto para luego acceder al lugar que apunta usando el operador "^":

Código Delphi [-]
Move (Pointer (Self)^, Pointer (ObjDestino)^, InstanceSize);

Claro está que algo así debe tratarse con sumo cuidado, por las razones antes mencionadas.

[ecfisa]

Hola Al.

Te estoy muy agradecido (al igual que a roman) por ampliar la explicación del motivo y documentarlo claramente paso a paso.

Un tema interesante y que nunca se me cruzó para abordarlo. (Y para que la idea no acumule polvo encima, me pondré a investigar y probar sobre ella)

Saludos