我的一片天

由于DELPHI不允许unit单元的循环引用,而类的成员在定义时，必须要用interface里的类型,因此要实现类成员的互相引用,必须用变通的方法.

unit1
interface
uses
  ,unit2,;

type
  tA=class
  private
    bbb:tB;
  end;

unit2
interface
uses
  ,unit1,;

type
  tB=class
  private
    aaa:tA;
  end;

上面的2个unit不能通过编译,因为循环引用了.如果不循环引用，又出现类型没定义。反正就是不能通过编译。

有人说尽量避免类的这种互相定义，实在要定义时就把这2个类放在一个unit中。但是这样并不符合我们的设想。

在什么情况下需要这种互相定义呢，我们假设一个老师只有1个学生，一个学生只有1个老师，那么一个学生，那他就有老师，因此他有一个成员变量，指向他的老师的。而这个老师也会有1个成员变量指向他的学生。这时就发生了嵌套定义。

由于unit不能循环引用的限制,实现这种嵌套好像只能放到一个unit中了,但是我们有不在一个unit的需要。那要如何实现呢。

我们知道在implementation中uses的unit不会发生循环引用,而类的实现部分(定义部分是在interface)恰好是在implementation,在implementation里uses的类型可以在implementation范围内引用。因此我们是可以在类方法的实现部分使用到另外一个类。但是在类的方法中定义的变量是局部的，一退出过程就消失了，不能随时引用。

我们知道对象实质是一个dword型的指针.只要我们传递另外一个类的指针保存起来，在要调用另外一个类的方法时再强制转换后使用。

具体测试在下面的2个unit中

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TA=class
  private
    { Private declarations }
      //tb:pinteger;
  public
      classB:pdword;
      procedure setTB(p:pinteger);
      procedure doTest;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation
uses
 unit2;

{$R *.dfm}
var
  aa:tA;
  bb:tB;

procedure TForm1.Button1Click(Sender: TObject);
var
 b:tB;
begin
 aa:=tA.Create;
 bb:=tb.Create;
 aa.classB:=@bb;
 bb.classA:=@aa;

 b:=tB(aa.classB);
 b.doTest;
end;

{ TA }

procedure TA.doTest;
begin
 showmessage('AAA');
end;



end.

unit Unit2;

interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
type
  tB=class
  private
    { Private declarations }
     //ta:pinteger;
  public
      classA:pdword;
      procedure doTest;
  end;

implementation
uses
  unit1;


{ tB }

procedure tB.doTest;
begin
  showmessage('BBB');
end;

end.