12

我正在实现一个带有记录和内部动态数组的 N x M 矩阵（类），如下所示。

TMat = record
public     
  // contents
  _Elem: array of array of Double;

  //
  procedure SetSize(Row, Col: Integer);

  procedure Add(const M: TMat);
  procedure Subtract(const M: TMat);
  function Multiply(const M: TMat): TMat;
  //..
  class operator Add(A, B: TMat): TMat;
  class operator Subtract(A, B: TMat): TMat;
  //..
  class operator Implicit(A: TMat): TMat; // call assign inside proc.
                                          // <--Self Implicit(which isn't be used in D2007, got compilation error in DelphiXE)

  procedure Assign(const M: TMat); // copy _Elem inside proc.
                                   // <-- I don't want to use it explicitly.
end;

我选择了一条记录，因为我不想创建/释放/分配来使用它。

但是对于动态数组，值不能用 M1 := M2 而不是 M1.Assign(M2) （深度）复制。

我试图声明自隐式转换方法，但它不能用于 M1:=M2。

（隐式（const pA：PMat）：TMat 和 M1:=@M2 有效，但它非常丑陋且不可读..）

有没有办法挂钩记录的分配？

或者有什么建议用记录实现 N x M 矩阵？

提前致谢。

编辑：

我用 Barry 的方法实现了如下所示并确认工作正常。

type
  TDDArray = array of array of Double;

  TMat = record
  private
     procedure CopyElementsIfOthersRefer;
  public
    _Elem: TDDArray;
    _FRefCounter: IInterface;
   ..
  end;

procedure TMat.SetSize(const RowSize, ColSize: Integer);
begin
  SetLength(_Elem, RowSize, ColSize);

  if not Assigned(_FRefCounter) then
    _FRefCounter := TInterfacedObject.Create;
end;

procedure TMat.Assign(const Source: TMat);
var
  I: Integer;
  SrcElem: TDDArray;
begin
  SrcElem := Source._Elem; // Allows self assign

  SetLength(Self._Elem, 0, 0);
  SetLength(Self._Elem, Length(SrcElem));

  for I := 0 to Length(SrcElem) - 1 do
  begin
    SetLength(Self._Elem[I], Length(SrcElem[I]));
    Self._Elem[I] := Copy(SrcElem[I]);
  end;
end;

procedure TMat.CopyElementsIfOthersRefer;
begin
  if (_FRefCounter as TInterfacedObject).RefCount > 1 then
  begin
    Self.Assign(Self); // Self Copy
  end;
end;

我同意它没有效率。仅将 Assign 与纯记录一起使用绝对更快。

但它非常方便且更具可读性。（而且很有趣。:-)

我认为它对于光计算或预生产原型很有用。不是吗？

编辑2：

kibab提供了获取动态数组本身的引用计数的函数。

Barry 的解决方案更独立于内部 impl，并且可能无需任何修改即可在即将推出的 64 位编译器上工作，但在这种情况下，我更喜欢 kibab 的简单和高效。谢谢。

  TMat = record
  private
     procedure CopyElementsIfOthersRefer;
  public
    _Elem: TDDArray;
   ..
  end;

procedure TMat.SetSize(const RowSize, ColSize: Integer);
begin
  SetLength(_Elem, RowSize, ColSize);
end;    

function GetDynArrayRefCnt(const ADynArray): Longword;
begin
  if Pointer(ADynArray) = nil then
    Result := 1 {or 0, depending what you need}
  else
    Result := PLongword(Longword(ADynArray) - 8)^;
end;

procedure TMat.CopyElementsIfOthersRefer;
begin
  if GetDynArrayRefCnt(_Elem) > 1 then
    Self.Assign(Self);
end;
4

3 回答 3

9

您可以使用记录中的接口字段引用来确定您的数组是否被多个记录共享：只需检查接口后面对象的引用计数，您就会知道数组中的数据是共享的。这样，您可以在修改时延迟复制，但在未修改矩阵时仍使用数据共享。

于 2010-12-07T18:26:55.607 回答
4

您不能通过隐式或显式运算符覆盖记录分配。IMO 最好的办法是不使用直接分配，而是使用 M.Assign 方法：

procedure TMat.Assign(const M: TMat);
begin
// "Copy" currently only copies the first dimension,
//  bug report is open - see comment by kibab 
//  _Elem:= Copy(M._Elem);
  ..
end;

前任

M1.Assign(M2);

代替

M1:= M2;
于 2010-12-07T11:13:38.647 回答
3

我刚刚意识到这可能不是一个好主意的原因。确实，通过运算符重载，调用代码变得更加简单。但是您可能会遇到性能问题。

例如，考虑简单的代码A := A+B;，并假设您使用 Barry 接受的答案中的想法。使用运算符重载这个简单的操作将导致分配一个新的动态数组。实际上，您可能希望就地执行此操作。

这种就地操作在线性代数矩阵算法中非常常见，原因很简单，如果你能避免它，你不想撞到堆——它很昂贵。

对于小值类型（例如复数、3x3 矩阵等），那么在记录中重载运算符是有效的，但我认为，如果性能很重要，那么对于大矩阵，运算符重载并不是最好的解决方案。

于 2010-12-08T20:24:09.800 回答