¿Qué diferencia hay entre copiar y clonar objetos?

[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 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.

[[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

[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