Cómo modificar una instancia dentro de un procedimiento asociado a esta.

[TecnoBestia]

Hola, entiendo que self es una referencia a un objeto, pero no entiendo por que no puede cambiarse, en otros lugares he usado la instrucción

  VecinoParticula:=VecinoAux9.Clon;

y también

VecinoAux9:=Self.Clon;

y no he tenido ningún problema siendo VecinoParticula y VecinoAux9 instancias de la misma clases, la función Clon lo que hace es crear una compia del objeto para que no sea una referencia.

El procedimiento correspondiente es:

function clsParticula.Clon():clsParticula;
var
i:Integer;                             {Esta función realiza un clon independiete, elimina el uso de punteros en las instancias}
begin
  Result:=clsParticula.Create;
  Result.VClasificacion:=Copy(Self.VClasificacion);
  Result.VCoordenadasActual:=Copy(Self.VCoordenadasActual);
  Result.VCoordenasPosicionAnterior:=Copy(Self.VCoordenasPosicionAnterior);
  Result.VCoordenadasMejorPosicion:=Copy(Self.VCoordenadasMejorPosicion);
  Result.VDistancias:=Copy(Self.VDistancias);
  Result.ValorDeLaInerciaActual:=Self.ValorDeLaInerciaActual;
  Result.ValorInerciaEnMejorPosicion:=Self.ValorInerciaEnMejorPosicion;
  Result.VCardinalidades:=Copy(Self.VCardinalidades);
  Result.VVelocidad:=Copy(Self.VVelocidad);
  //Tabu
  Result.OperaRealizadaVecino:=Self.OperaRealizadaVecino;
  Result.PosicionModificadaParaVecino:=Self.PosicionModificadaParaVecino;
  Result.PosicionAActualizarEnLT:=Self.PosicionAActualizarEnLT;

  SetLength(Result.ListaTabu,2,TamaMaxListaTabu);

  Result.ListaTabu[0]:=Copy(Self.ListaTabu[0]);
  Result.ListaTabu[1]:=Copy(Self.ListaTabu[1]);

  Result.TamaActualLT:=Self.TamaActualLT;
  Result.SeGeneroElVecino:=Self.SeGeneroElVecino;
end;

Donde result posee una copia del objeto independiente de la instancia general. Mi duda es ¿por qué no puedo cambiar el self pero si otras referencias de los objetos?, y más aún ¿cómo puedo solucionar el problema?

Saludos...

[Ñuño Martínez]

Porque SELF no es una variable, sino una constante. Siempre es la referencia (puntero) al objeto del método que se está ejecutando en ese momento.

Cuando defines un método de una clase, como por ejemplo:

Código Delphi [-]
  TMiClase = CLASS
  PUBLIC
    PROCEDURE Metodo (aVariable: STRING);
  END;

en realidad el compilador lo interpreta como si fuera así:

Código Delphi [-]
  TMiClase = CLASS
  PUBLIC
    PROCEDURE Metodo (CONST Self: TMiOBjeto; aVariable: STRING);
  END;

Y cuando llamas al método:

Código Delphi [-]
  MiObjeto.Metodo ('Hola');

El compilador lo interpreta como si fuera así:

Código Delphi [-]
  TMiClase.Metodo (MiObjeto, 'Hola');

El caso de RESULT es diferente, ya que sí es una variable cuya posición de memoria se corresponde con la posición de pila donde el llamante tomará el valor devuelto por la función. En cierto modo, una definición como:

Código Delphi [-]
  FUNCTION UnaFuncion (aValor: INTEGER): INTEGER;

Se interpreta como si fuera:

Código Delphi [-]
  PROCEDURE UnaFuncion ( OUT RESULT: INTEGER; aValor: INTEGER);

y si fuera método de una clase...

Código Delphi [-]
  PROCEDURE UnaFuncion (CONST SELF: TMiClase; OUT RESULT: INTEGER; aValor: INTEGER);