Delphi - 维护对象的自引用

Question

我已经查看了许多与“自我”相关的问题和资源。对象中的变量，但每个人都说不同的东西。

例如，在这个问题中：Delphi Self-Pointer usage

该问题得分最高的答案似乎是错误的。指针（Self）不指向包含它的对象，也不能用于从对象内部传递引用。

我试过这样做：

Type
  myobject = class
    PSelf: Pointer;
  End;

Var
  Obj: myobject;

Procedure RunProgram;
Begin
  Obj := myobject.create;
  Obj.PSelf := @Obj;

  //Run the rest of the program
  .
  .
  .

并且在大多数情况下，这已经很好了。

我的问题是：这是一个很好的编码实践吗？可以＆＃34; PSelf＆＃34;期望变量在程序执行期间指向对象吗？

我最近遇到了一个错误，其中＆＃34; PSelf＆＃34;我已经停止指向包含对象的对象了，我想知道对象是否在堆中乱窜，或者内存是否已损坏。

编辑：

有一些使用＆＃34; Self＆＃34;变量对我不起作用，现在我无法复制它。因此，整个问题毫无意义，因为我使用“自我”的技巧也是如此。变量。对不起。

正如Ken所指出的，上面的链接有一个正确答案：）

Answer 1

我认为你误解了Self是什么，以及对象引用如何在Delphi中工作。

包含类实例的变量已经是指向该对象实例的指针。为方便起见，Delphi编译器只允许您省略解引用运算符（^）。

var
  MyObject: TMyObject;  
begin
  MyObject := TMyObject.Create;  // MyObject is now a pointer to an instance of TMyObject
  ...

Delphi还允许在访问对象实例的成员或属性时不使用解引用运算符的简写。同样，以下代码实际上是等效的：

MyObj.SomeProperty := SomeValue;
MyObj^.SomeProperty := SomeValue;

来自Delphi documentation：

  

类类型的变量实际上是引用对象的指针。因此，多个变量可以引用同一个对象。与其他指针一样，类类型变量可以保持值为nil。但是，您不必显式取消引用类型变量来访问它指向的对象。例如，SomeObject.Size：= 100将值100赋给SomeObject引用的对象的Size属性;你不会把它写成SomeObject ^ .Size：= 100.

Self是一个自动声明的属性，指向对象的当前实例。换句话说，它在代码中自动可用，该代码实现该类以引用对象的当前实例。这允许您拥有同一对象的多个实例：

type
  TMyObject=class(TObject)
  private
    FMyInteger: Integer;
    function GetMyInteger: Integer;
    procedure SetMyInteger(Value: Integer);
  published
    property MyInteger: Integer read GetMyInteger write SetMyInteger;
  end;

...
function TMyObject.GetMyInteger: Integer;
begin
  Result := Self.FMyInteger; 

  // Self is implied, so the above line can more simply be written as
  // Result := FMyInteger;
end;

procedure TMyObject.SetMyInteger(Value: Integer);
begin
  if (Value <> Self.FMyInteger) then  // Self is again implied here
    Self.FMyInteger := Value;
end;

var
 MyObjOne, MyObjTwo: TMyObject;
 i, j: Integer;
begin
  MyObjOne := TMyObject;
  // Here, the code inside TMyObject.SetInteger that
  // uses `Self` would refer to `MyObjOne`
  MyObjOne.MyInteger := 1; 

  MyObjTwo := TMyObject;
  // Here, the code in TMyObject.SetInteger would be
  // using the memory in `MyObjTwo` when using `Self`
  MyObjTwo.MyInteger := 2; 
end;        

请注意，Self仅在实现类的代码中有效。它在上面的TMyObject.GetMyInteger和TMyObject.SetMyInteger（我的示例中唯一实现的代码）中可用且有效，并始终引用当前实例。

没有必要跟踪Self的地址，因为在该对象实例的方法内引用该对象实例的变量是 Self。它仅在该对象的实例内有效，始终指的是该对象实例。因此，在您的代码示例中，PSelf只是浪费空间 - myobject已经包含指向自身的指针，并且该指针在myobject的方法中自动可用：

type
  myobject = class;   // Now automatically contains a `Self` pointer
                      // available in methods of the class once an
                      // instance is created

var
  myobj: myobject;
begin
  myobj := myobject.Create;  // myobj.Self now is valid in methods of
                             // `myobject`

Answer 2

这是我对问题的解决方法。我仍然想知道为什么第二个例子不起作用。

这有效（但这是错误的方法）：

Type
  myobject1 = class(TObject)
    PSelf: Pointer;
    Number: Integer;
    Function GiveReference: Pointer;
  End;
  pmyobject1: ^myobject1;

  myobject2 = class(TObject)
    p: pmyobject1;
  End;

Var
  Obj1: myobject1;
  Obj2: myobject2;

Function  myobject1.GiveReference: Pointer;
Begin
  Result := PSelf;
End;

Procedure RunProgram;
Var
  i: Integer;
Begin
  Obj1 := myobject1.create;
  Obj1.PSelf := @Obj1;

  Obj2 := myobject2.create;
  Obj2.P := Obj.GiveReference;

  //to access 'number', this works
  i := Obj2.P^.Number;

  //Run the rest of the program
  .
  .
  .

这不起作用，但在我看来完全一样。这就是导致我不信任'self'变量的原因（尽管是的，我正在指向一个指针）。

Type
  myobject1 = class(TObject)
    Number: Integer;
    Function GiveReference: Pointer;
  End;
  pmyobject1: ^myobject1;

  myobject2 = class(TObject)
    p: pmyobject1;
  End;

Var
  Obj1: myobject1;
  Obj2: myobject2;

Function  myobject1.GiveReference: Pointer;
Begin
  Result := @Self;
End;

Procedure RunProgram;
Var
  i: Integer;
Begin
  Obj1 := myobject1.create;

  Obj2 := myobject2.create;
  Obj2.P := Obj.GiveReference;

  //This will fail, some of the time, but not all of the time.
  //The pointer was valid while 'GiveReference' was being called, but
  //afterwards, it is not valid.
  i := Obj2.P^.Number;

  //Run the rest of the program
  .
  .
  .

最后，这是我应该一直在做的事情：

Type
  myobject1 = class(TObject)
    Number: Integer;
    Function GiveReference: Pointer;
  End;

  myobject2 = class(TObject)
    p: myobject1;
  End;

Var
  Obj1: myobject1;
  Obj2: myobject2;

Function  myobject1.GiveReference: Pointer;
Begin
  Result := Self;
End;

Procedure RunProgram;
Var
  i: Integer;
Begin
  Obj1 := myobject1.create;

  Obj2 := myobject2.create;
  Obj2.P := Obj.GiveReference;

  //No problems with this, although I would generally check if P was assigned prior to
  //reading from it.
  i := Obj2.P.Number;

  //Run the rest of the program
  Obj1.Free;
  Obj2.P := nil;

我首先没有这样做，因为我担心不使用指针，我实际上可能会复制整个对象。