0

我正在尝试解决这个问题（以及其他一些问题。）

问题 

//None of these compile
type
  PAType<T> = ^AType<T>;  
  P<T> = ^T;                
  PAType = ^AType<T>

所以我正在尝试使用记录和运算符重载自己。

我正在编写以下代码：

  TCell<T> = record
  private
    FData: T;
    procedure SetData(Value: T); inline;
    function GetData: T; inline;
  public
    property data: T read GetData write SetData;
  end;

  //Type safe pointer to T, because it knows SizeOf(T).
  P<T> = record  //wrapper around pointer: ^TCell<T>;^H^H^H^H any <T> actually 
  private
    FPointerToT: pointer;
  public
    class operator Implicit(a: pointer): P<T>; inline;
    class operator Implicit(a: P<T>): pointer; inline;
    class operator Implicit(Cell: TCell<T>): P<T>; inline;
    class operator Implicit(p: P<T>): TCell<T>; inline;
    class operator Add(a: P<T>; b: NativeUInt): P<T>; inline;
    class operator NotEqual(a,b : P<T>): Boolean; inline;
    class operator NotEqual(a: P<T>; b: pointer): Boolean; inline;
    class operator Equal(a,b : P<T>): Boolean; inline;
    class operator GreaterThan(a,b : P<T>): Boolean; inline;
    class operator GreaterThanOrEqual(a,b : P<T>): Boolean; inline;
    class operator LessThan(a,b : P<T>): Boolean; inline;
    class operator LessThanOrEqual(a,b : P<T>): Boolean; inline;
    class operator Inc(a: P<T>): P<T>; inline;
    class operator Dec(a: P<T>): P<T>; inline;
    class operator Explicit(a: P<T>): T; inline;
  end;

我正在写一个哈希表。因为我正在尝试不同的哈希选项。
哈希表应该获取一条带有数据的记录，将记录放入动态数组（记录本身，而不是指针）并返回指向该记录的指针。

这将允许应用程序以或多或少的顺序存储数据（有一些间隙）。这对缓存有好处。
我想使用泛型，因为即使哈希表在任何时候只保存一种类型，在不同的哈希表中也有不同的类要进行哈希处理。

通过返回一个指针，我可以防止双重存储。

上面未完成的结构允许我编写如下代码：

//FCells: array of T;
//FArrayEnd: pointer; //points to element FCells[max_elements+1] (i.e. access violation)  

function THashTable<K, T>.NextItem(Item: P<T>): P<T>;
begin
  Result:= Item + SizeOf(T);  //pointer arithmetic 
  if Result >= FArrayEnd then Result:= @FCells[0];  //comparison and assignment
end;

function THashTable<K, T>.Lookup(const key: K): P<T>;
var
  Index: NativeUInt;
  ItemKey: K;
begin
  if IsValid(key) then begin
    // Check regular cells
    Index:= First_Cell(FGetHashFromKey(key));  //FGet.. is a user supplied key generation proc.
    while (true) do begin
      ItemKey:= FGetKey(FCells[Index]);
      if (IsEqual(ItemKey, key)) then exit(@FCells[Index]);
      if (IsEmpty(ItemKey)) then exit(nil);  //nil pointers denote no-hit 
      Index:= NextIndex(Index);
    end;
  end
  else { if IsEmpty(key) then } begin
    // Check zero cell
    Result:= @FZeroCell;
  end;
end;

请注意，我不需要 aNullable<T>来表示错过。我的标准nil指针有效。

我不必进行类型转换，并且指针知道它有多大。
它甚至知道一点点是什么 T。

我知道泛型有很多问题，所以：

在我进入太深之前。
这会奏效（原则上）还是这种方法只是一厢情愿？

4

1 回答 1

3

您可以拥有指向泛型类型的指针。像这样：

type
  THashTable<K, T> = class
  public type
    TCell = TCell<T>;
    PCell = ^TCell;
  public
    function NextItem(Item: PCell): PCell;
  end;

要实现指针算法，您需要以下代码：

function THashTable<K, T>.NextItem(Item: PCell): PCell;
begin
  Result := Item;
  inc(Result);
end;
于 2013-10-08T04:24:43.467 回答