如何跨单元、跨类地访问Delphi类的私有域(网上收集)

如何跨单元、跨类地访问Delphi类的私有域

如何跨单元、跨类地访问Delphi类的私有域

如何跨单元、跨类地访问Delphi类的私有域



Delphi约定，一个私有方法不能被其它模块中调用，同时，一个私有属性不能在其它模块中读写。但Delphi也在同一单元中放宽了上述限制，也就是说，你可以在同一单元的一个类中访问其它类的私有域和私有方法。

但是，有没有办法不在同一单元访问它们呢？

似乎Delphi不提供这样的机制，但是，我们的确可以做到！



一、    问题是怎样被提出的？

OOP方法总是试图安全、快速地构造一个类，并在此基础上继承出子类。为了保证子类对父类操作，以及类实例操作的安全性，OOP中引入了类的私有域的概念。也就是通常说的private域。

如前所述，你可以改写一个类的单元，在该单元中实现对类的私有域的访问。但是，没有人是愿意为每一个Delphi单元来改写代码以实现上述要求，更多人总是希望如同访问一个公开域一样直接地访问私有域，而不受限于任何单元。

——这是不安全、不允许的！OOP方法的基础理论会这样告诉你。

我们应当承认这样做的“不安全”，但Funs们不会接受“不允许”。

问题的提出总是在解决另一个问题的过程之中。——编程历来如此！下面，我将结合一个实现快速删除TList的一批连续结点时的实例，来描述问题提出和实现的全部过程。它将提出一种全新而有效地跨单元、跨类地访问Delphi类的私有域的方法。

按照目前Delphi对类的实现机制和方法，这样的一个“后门”还将永远地开下去，Funs们就好好的利用吧。哈哈。

*注：下面的实现过程最早被我发布在Delphi大富翁论坛([url]www.delphibbs.com)[/url]上，但在一个长篇累牍的贴子 里，它并没有引起大家的重视，于是我重新整理了本文。至于原文，大家不妨到下面的贴子里去看看(建议你仔细而小心地阅览该贴，否则你会被淹没的……)：

[url]http://www.delphibbs.com/delphibbs/dispq.asp?lid=650664[/url]



二、    从TList开始分析……

为了写一个更好的性能ISAPI Filter，我需要更快速地从TList中删除部分连续的Item。比如这样的一段代码：

var p : pChar = 'abcdefgh';
procedure TestDelFromTList;
var t1 : TList;
    i  : integer;
    maxI : integer;
begin
  t1 := tlist.create;
  t1.count := 100000;
  for i:=0 to t1.count-1 do t1[i] := p;
  maxI := t1.count-10-1; //最后一个结点
  for i:= maxI downto 10 do t1.delete(i);
  //正向删除
  //for i:=10 to t2.count-10-1 do t2.delete(10);
end;
这段代码是初始化一个100000个结点的List，然后删除其中的第10个到倒数第10个。这段代码是逆向的，这样的删除速度比较快。如果换成正向删除(已经注释掉)，则速度就慢得非常多了。

这样的删除是正常的算法。用测效率的程序测试：逆向删除算法的耗时是21.66个毫秒，则正向删除的耗时却能达到58099.02个毫秒。速度慢了2680倍！！！

但这样就很快了么？不是！我认为就算是逆向删除的速度也并不是快的。

分析TList这个类的源码，我们可以看到，它是这样写的(我加入了注释)：

procedure TList.Delete(Index: Integer);
var
  Temp: Pointer;
begin
if (Index < 0) or (Index >= FCount) then //判定Index值是否超界
Error(@SListIndexError, Index);
  Temp := Items[Index];                        //取待删除结点
  Dec(FCount);                                   //Count减一
if Index < FCount then                       //将待删除结点后的Buffer提前
System.Move(FList^[Index + 1], FList^[Index],(FCount - Index) *
SizeOf(Pointer));
if Temp <> nil then                           //发通告
Notify(Temp, lnDeleted);
end;
由于在TList类是将全部的结点指针存放在FList这个动态数组的指针中，所以只需要将Index+1之后的内存块向前移4个字节，即SizeOf(Pointer)，即可实现Index结点的删除。

但是，如果使用这样来删除成批连续的(N个)结点，则要实现N次system.move()操作，操作的内存块的大小决定了system.move()操 作的耗时，而Index值越小的的结点在FList中越靠前，则system.move()要操作的内存块也就越大。这就是我认为上述成批删除效率不高的 原因，也是正向删除比逆向删除的耗时慢了慢了2680倍的原因。

对于成批删除，理想的算法是从index+len结点开始位置，向前移动count-index-len个结点，这样，就能够一次完成全部的结点移动，实现删除操作。这个思路非常好，至少我认为是这样。为此，我实现了下面的代码：

procedure CutList(aList:TList; left,len:integer);
begin
  with aList do begin
System.Move(List^[left+len], List^[left], (Count-left-len) *
SizeOf(Pointer));
    count := count-len;
  end;
end;
这段代码的功能是在TList.List这个Buffer中，将删除后的剩余结点直接移动到Left这个位置上，从而完成全部的移动操作。

然后，我们再设count := count-len;来使用个数减少，从而完成了成批量的删除。

好的，如果一切正常，算法的速度将大幅度提升！OHHH，美妙的想法！

但是，真的是这样么？我再用效率测试程序来测试了一轮，结果是这样的：

1.    测试数据为10万个结点，则逆向删除算法耗时为20.56毫秒，CutList()函数耗时9.69毫秒；

2.    测试数据为100万个结点，则逆向删除算法耗时为209.13毫秒，CutList()函数耗时98.01毫秒。

速度比逆向算法提高了一倍，而且应该注意到，CutList()的耗时仍然随数据量的增大而等比例的增大！！！而从CutList()函数的实现来看，数据量增大，算法耗时应该只增加极少才对。

要知道，只加快一倍速度的CutList()，并不是我所想要的！！！但为什么CutList()函数得不到更高的性能呢？？？



三、    面对私有域FCount，我咬牙切齿！！！

再次分析TList类的实现代码，发现count接口实现时，是用SetCount来写值，即CutList()函数中，

count := count-len;

一行的调用，实际上将调用

TList.setCount(count-len);

而TList.setCount()的实现代码如下：

procedure TList.SetCount(NewCount: Integer);
var
  I: Integer;
begin
  if (NewCount < 0) or (NewCount > MaxListSize) then  Error(@SListCountError, NewCount);
  if NewCount > FCapacity then  SetCapacity(NewCount);
  if NewCount > FCount //如果要增加Count的值，则调用Fillchar()来填充FList这个Buffer
                       //如果是要减少Count的值，则用for循环调用Delete()来删除结点
    then FillChar(FList^[FCount], (NewCount - FCount) * SizeOf(Pointer), 0)
    else for I := FCount - 1 downto NewCount do Delete(I);
  FCount := NewCount;
end;
请注意看我在上面注释！OH！事实上，SetCount这个操作仍然将调用Delete()来删除各个结点(注意，Borland为了提高这个删除速度，也使用了逆向删除的算法来实现对Delete()的调用)。

所以，我们并不能在CutList()中得到更好的算法效率！——尽管，我们已经只要，仅仅只需要将FCount设成指定值即可，而并不需要再来一次成批的Delete()！

然而，FCount是一个私有域！！！从Delphi对OOP的实现机制来看，我只能通过SetCound()来实现写访问！！！在Classes.pas单元中的这段代码清楚地表明了这一切：

TList = class(TObject)
private
  FList: PPointerList;
  FCount: Integer;
  ...
protected
  ...
  procedure SetCount(NewCount: Integer);
  ...
public
  ...
  property Count: Integer read FCount write SetCount;
  ...
  property List: PPointerList read FList;
end;
——看到这里，我咬牙切齿！！！



四、    跨域私有域保护！

但是接下来，我注意到一点，我们看到，Count读是直接读FCount的值，而写操作是调用SetCount()函数。仔细思考一下这个问题：

既然“Count读是直接读FCount的值”，那么，Count的地址是不是也直接指向FCount呢？？？

OK，且让我们用一段代码来证明它：

program testFixCount;
uses classes, Dialogs, sysUtils;
var t : TList;
    pCount : ^Integer;
begin
t := TList.create;
pCount := @t.Count;  //取得地址？
ShowMessage(IntToStr(pCount^));
t.Count := 10000;
ShowMessage(IntToStr(pCount^));
end.

很明显，pCount成功地得到了FCount的地址。哈哈，我们既然已经取得了一个变量在内存中的地址，那么，还有什么是不能做的呢？？？

我们可以很快完成这样的一段代码来测试对FCount私有域的直接写访问：

program testFixCount;
uses classes, Dialogs, sysUtils;
var t : TList;
    pCount : ^Integer;
begin
  t := TList.create;
  pCount := @t.Count;
  pCount^ := 10;
  showMessage(IntToStr(t.Count));
end.
接下来，我们可以将curList()函数修改一下下了：

procedure CutList(aList:TList; left,len:integer);
var pCount : ^Integer;
begin
  with aList do begin
System.Move(List^[left+len], List^[left], (Count-left-len) *
SizeOf(Pointer));
    //count := count-len;
    pCount := @Count;
    pCount^ := count-len;
  end;
end;
OK! 我再次用那个可爱的效率测试工具测试了一下下，结果，哈哈，漂亮！——

1.    测试数据为10万个结点，则逆向删除算法耗时仍为20.56毫秒，准确地说是20333.25个微秒，而新CutList()函数耗时仅为1.08个微秒；

2.    测试数据为100万个结点，则逆向删除算法耗时为212.67毫秒(212668.22微秒)，而这种情况下，CutList()函数耗时仅为1.26个微秒，比10万个结点略略多了一点儿！:)

快了NNNNNNN倍！！！

这才是我要的结果！一个不会随数据量增加而变慢的CutList()!



五、    突破更多的私有域……

存在的问题是，如果域不提供公用访问接口，那么，也就无法取到它的地址。这种情况下，我们是不是什么也得不到了呢？

仍然参考上述代码上TList的类定义，我们发现，在private域的定义中，FList和FCount被连续定义，从数据结构的角度来看，通常它们在 内存中占用连续的空间。事实上，在Delphi中也正是如此处理的。因此，我们只需要得到FList的地址，并用 “@List+SizeOf(PPointerList)”，就可以得到FCount的地址了。

我们用下面这段代码来测试不使用TList.Count而直接访问FCount的方法。这意味着，只要我们可以突破一个私有域，我们就可以通过地址计算的方法来突破全部的私有域！

program myTest;
{$APPTYPE CONSOLE}
uses classes, Dialogs, sysUtils;
var
  t : TList;
  pPrivateStrart : pointer;
  pCount,pCapacity : ^Integer;
begin
  t := TList.create;
  pPrivateStrart := pointer(@t.List);
  pCount := pointer(integer(pPrivateStrart) + sizeof(pointer));
  pCapacity := pointer(integer(pCount) + sizeof(integer));
  t.Count := 10000;
  writeln('FCount:',t.Count);
  writeln('FCapacity:',t.Capacity);
  pCount^ := 10;
  pCapacity^ := 1000;
  writeln('FCount:',t.Count);
  writeln('FCapacity:',t.Capacity);
end.


六、    其它

1.    由于直接访问私有域的方法超越了Delphi的对象保护，所以，访问私有域可能导致一些负面影响。比如，直接修改FCount的方法并不会使FList占 用的Buffer的空间增大或者减小，也不会使Capacity的值发生任何变化。而在Delphi对于TList的类封装中，这三者之间是有联系的。我 们有必要进一步地修改CutList()函数，再加一些代码来维护这种关系，以保证TList类操作的正常。完整的Cutlist()的实现可以在