Delphi 请求如何创建一个TComplexMath类的简单示例（包括源代码）

我正在用Borland Delphi7做一些Pascal编程。我已经下载了一个相当基本（免费）的复杂数学函数源代码库，但不幸的是，它没有任何使用示例。由于我对Pascal中的类不是很熟悉，我想我只需要一个简单的例子来说明它的用法就可以了

任何事情都可以，即使是两个数字相加的例子也能让我开始。这是我试过的（我知道这很蹩脚）。我认为我的问题是我不知道如何使用类构造函数

uses ComplexMath in 'complexmath.pas'

var z1,z2,z3 : TComplexNumber;
begin
  z1.R:=1.0; z1.I:=2.0;
  z2.R:=3.0; z2.I:=-1.0;
  z3 := TComplexMath.Add(z1,z2);
end.

此处提供了TComplexMath的完整源代码：。我还剪切并粘贴了下面源代码的部分列表（请注意，除了我明确指出已剪切的代码外，此代码是完整的文件）

部分TComplexMath源代码列表为：

unit ComplexMath;

interface

uses Windows, SysUtils, Classes, Controls, Math;

type
  TComplexNumber = record
    R : single;
    I : single;
  end;

TComplexMath = class(TComponent)
  private
    { Private declarations }
  protected
    { Protected declarations }
  public
    { Public declarations }
    constructor Create(AOwner : TComponent); override;

    function Add(C1, C2 : TComplexNumber) : TComplexNumber; overload;
    { Returns the complex sum of C1 and C2 }

    function Add(C1, C2, C3 : TComplexNumber) : TComplexNumber; overload;
    { Returns the complex sum of C1 and C2 and C3 }

    ... and a bunch more like this ...

implementation

procedure Register;
  begin
    RegisterComponents('delphi.about.com', [TComplexMath]);
  end;

constructor TComplexMath.Create(AOwner : TComponent);
  begin
    inherited Create(AOwner);
  end;

 function TComplexMath.Add(C1, C2 : TComplexNumber) : TComplexNumber;
   begin
     Result.R := C1.R + C2.R;
     Result.I := C1.I + C2.I;
   end;

    ... and a bunch more like this ...

end.

---

经过一段时间的努力，我最终去掉了类定义，只使用了函数本身（就像一个简单的函数库）。虽然这对我很有用，但我知道这不是这个组件的预期用途。如果有人能给我举一个非常简单的例子，说明如何按预期的方式使用这个类，我将不胜感激。

预期的用法如下：

var
  cm: TComplexMath;

  z, w, sum: TComplexNumber;
begin

  cm := TComplexMath.Create(Self) // or nil, can most likely be anything
  try
    sum := cm.Add(z, w); // Now sum is the sum of z and w
  finally
    cm.Free;
  end;

end;

您还可以在应用程序启动（或单元初始化等）时创建

TComplexMath

的实例，并在应用程序的生命周期中使用该实例：

unit Unit1;

interface

var
  cm: TComplexMath;

...

implementation

procedure Test;
begin

  sum := cm.Add(z, w); // Now sum is the sum of z and w

end;

...

initialization

  cm := TComplexMath.Create(nil);

finialization

  cm.Free;

最后，由于它是一个组件，您可以在设计时将其放到表单上。该实例将被称为

ComplexMath1

，您可以在form类中使用它，如

procedure TForm1.Button1Click(Sender: TObject);
var
  z, w, sum: TComplexNumber;    
begin
  sum := ComplexMath1.Add(z, w);
end;

---

我真的不喜欢这个班的设计。首先，您只需要它的一个实例，那么为什么不改为使用函数类函数呢？真的：为什么要使用类呢？最后，如果您使用现代版本的Delphi，您可以使用高级记录和运算符重载使

z+w

之类的东西在源代码中工作，就像

z

和

w

是简单的类型，比如整数

我根本不会使用那个代码。在我看来，它真的很弱。这里有更好的：

type
  TComplex = record
  public
    class operator Implicit(const D: Double): TComplex;
    class operator Negative(const C: TComplex): TComplex;
    class operator Equal(const C1, C2: TComplex): Boolean;
    class operator NotEqual(const C1, C2: TComplex): Boolean;
    class operator Add(const C1, C2: TComplex): TComplex;
    class operator Add(const C: TComplex; const D: Double): TComplex;
    class operator Add(const D: Double; const C: TComplex): TComplex;
    class operator Subtract(const C1, C2: TComplex): TComplex;
    class operator Subtract(const C: TComplex; const D: Double): TComplex;
    class operator Subtract(const D: Double; const C: TComplex): TComplex;
    class operator Multiply(const C1, C2: TComplex): TComplex;
    class operator Multiply(const C: TComplex; const D: Double): TComplex;
    class operator Multiply(const D: Double; const C: TComplex): TComplex;
    class operator Divide(const C1, C2: TComplex): TComplex;
    class operator Divide(const C: TComplex; const D: Double): TComplex;
    class operator Divide(const D: Double; const C: TComplex): TComplex;
    function IsZero: Boolean;
    function IsNonZero: Boolean;
    function Conj: TComplex;
    function Sqr: TComplex;
    function Sqrt: TComplex;
    function Mag: Double;
    function SqrMag: Double;
  public
    r: Double;
    i: Double;
  end;

const
  ZeroComplex: TComplex = ();//initialise to zero;

class operator TComplex.Implicit(const D: Double): TComplex;
begin
  Result.r := D;
  Result.i := 0.0;
end;

class operator TComplex.Negative(const C: TComplex): TComplex;
begin
  Result.r := -C.r;
  Result.i := -C.i;
end;

class operator TComplex.Equal(const C1, C2: TComplex): Boolean;
begin
  Result := (C1.r=C2.r) and (C1.i=C2.i);
end;

class operator TComplex.NotEqual(const C1, C2: TComplex): Boolean;
begin
  Result := not (C1=C2);
end;

class operator TComplex.Add(const C1, C2: TComplex): TComplex;
begin
  Result.r := C1.r + C2.r;
  Result.i := C1.i + C2.i;
end;

class operator TComplex.Add(const C: TComplex; const D: Double): TComplex;
begin
  Result.r := C.r + D;
  Result.i := C.i;
end;

class operator TComplex.Add(const D: Double; const C: TComplex): TComplex;
begin
  Result.r := D + C.r;
  Result.i := C.i;
end;

class operator TComplex.Subtract(const C1, C2: TComplex): TComplex;
begin
  Result.r := C1.r - C2.r;
  Result.i := C1.i - C2.i;
end;

class operator TComplex.Subtract(const C: TComplex; const D: Double): TComplex;
begin
  Result.r := C.r - D;
  Result.i := C.i;
end;

class operator TComplex.Subtract(const D: Double; const C: TComplex): TComplex;
begin
  Result.r := D - C.r;
  Result.i := -C.i;
end;

class operator TComplex.Multiply(const C1, C2: TComplex): TComplex;
begin
  Result.r := C1.r*C2.r - C1.i*C2.i;
  Result.i := C1.r*C2.i + C1.i*C2.r;
end;

class operator TComplex.Multiply(const C: TComplex; const D: Double): TComplex;
begin
  Result.r := C.r*D;
  Result.i := C.i*D;
end;

class operator TComplex.Multiply(const D: Double; const C: TComplex): TComplex;
begin
  Result.r := D*C.r;
  Result.i := D*C.i;
end;

class operator TComplex.Divide(const C1, C2: TComplex): TComplex;
var
  R, Denominator: Double;
begin
  if abs(C2.r)>=abs(C2.i) then begin
    R := C2.i/C2.r;
    Denominator := C2.r+R*C2.i;
    Result.r := (C1.r+R*C1.i)/Denominator;
    Result.i := (C1.i-R*C1.r)/Denominator;
  end else begin
    R := C2.r/C2.i;
    Denominator := C2.i+R*C2.r;
    Result.r := (C1.r*R+C1.i)/Denominator;
    Result.i := (C1.i*R-C1.r)/Denominator;
  end;
end;

class operator TComplex.Divide(const C: TComplex; const D: Double): TComplex;
begin
  Result := C*(1.0/D);
end;

class operator TComplex.Divide(const D: Double; const C: TComplex): TComplex;
var
  R, Denominator: Double;
begin
  if abs(C.r)>=abs(C.i) then begin
    R := C.i/C.r;
    Denominator := C.r+R*C.i;
    Result.r := D/Denominator;
    Result.i := -R*Result.r;
  end else begin
    R := C.r/C.i;
    Denominator := C.i+R*C.r;
    Result.i := -D/Denominator;
    Result.r := -R*Result.i;
  end;
end;

function TComplex.IsZero: Boolean;
begin
  Result := Self=ZeroComplex;
end;

function TComplex.IsNonZero: Boolean;
begin
  Result := Self<>ZeroComplex;
end;

function TComplex.Conj: TComplex;
begin
  Result.r := r;
  Result.i := -i;
end;

function TComplex.Sqr: TComplex;
begin
  Result := Self*Self;
end;

function TComplex.Sqrt: TComplex;
var
  x, y, v, w: Double;
begin
  if IsZero then begin
    Result := ZeroComplex;
  end else begin
    x := abs(r);
    y := abs(i);
    if x>=y then begin
      v := y/x;
      w := System.Sqrt(x)*System.Sqrt(0.5*(1.0+System.Sqrt(1.0+v*v)));
    end else begin
      v := x/y;
      w := System.Sqrt(y)*System.Sqrt(0.5*(v+System.Sqrt(1.0+v*v)));
    end;
    if r>=0.0 then begin
      Result.r := w;
      Result.i := i/(2.0*w);
    end else begin
      if i>=0.0 then begin
        Result.i := w;
      end else begin
        Result.i := -w;
      end;
      Result.r := i/(2.0*Result.i);
    end;
  end;
end;

function TComplex.Mag: Double;
var
  x, y, Temp: Double;
begin
  x := abs(r);
  y := abs(i);
  if x=0.0 then begin
    Result := y;
  end else if y=0.0 then begin
    Result := x;
  end else if x>y then begin
    Temp := y/x;
    Result := x*System.Sqrt(1.0+Temp*Temp);
  end else begin
    Temp := x/y;
    Result := y*System.Sqrt(1.0+Temp*Temp);
  end;
end;

function TComplex.SqrMag: Double;
begin
  Result := System.Sqr(r) + System.Sqr(i);
end;

类型
t复杂=记录
公众的
类运算符隐式（const D:Double）：t复杂；
类运算符负（常数C:TComplex）：TComplex；
类运算符Equal（常数C1，C2:t复数）：布尔；
类运算符NotEqual（常量C1，C2:TComplex）：布尔；
类操作符Add（constc1，C2:TComplex）：TComplex；
类运算符Add（常数C:TComplex；常数D:Double）：TComplex；
类运算符Add（常数D:Double；常数C:TComplex）：TComplex；
类运算符减法（常量C1，C2:TComplex）：TComplex；
类运算符减法（常数C:TComplex；常数D:Double）：TComplex；
类运算符减法（常数D:Double；常数C:TComplex）：TComplex；
类运算符乘法（常数C1，C2:TComplex）：TComplex；
类运算符乘法（常数C:TComplex；常数D:Double）：TComplex；
类运算符乘法（常数D:Double；常数C:TComplex）：TComplex；
类运算符除法（常数C1，C2:TComplex）：TComplex；
类运算符除法（常数C:TComplex；常数D:Double）：TComplex；
类运算符除法（常数D:Double；常数C:TComplex）：TComplex；
函数为零：布尔；
函数为非零：布尔型；
函数Conj:t复杂；
功能Sqr:TComplex；
函数Sqrt:t复杂；
功能Mag：双功能；
函数SqrMag:Double；
公众的
r：双倍；
i:双份；
结束；
常数
ZeroComplex:TComplex=（）//初始化为零；
类运算符TComplex.Implicit（const D:Double）：TComplex；
开始
结果：r:=D；
结果：i:=0.0；
结束；
类运算符TComplex.Negative（常量C:TComplex）：TComplex；
开始
结果r:=-C.r；
结果i:=-C.i；
结束；
类运算符TComplex.Equal（常量C1，C2:TComplex）：布尔；
开始
结果：=（C1.r=C2.r）和（C1.i=C2.i）；
结束；
类运算符TComplex.NotEqual（常量C1，C2:TComplex）：布尔；
开始
结果：=非（C1=C2）；
结束；
类运算符TComplex.Add（常量C1，C2:TComplex）：TComplex；
开始
结果r:=C1.r+C2.r；
结果i:=C1.i+C2.i；
结束；
类运算符TComplex.Add（常数C:TComplex；常数D:Double）：TComplex；
开始
结果r:=C.r+D；
结果：i:=C.i；
结束；
类运算符TComplex.Add（常数D:Double；常数C:TComplex）：TComplex；
开始
结果r:=D+C.r；
结果：i:=C.i；
结束；
类运算符TComplex.Subtract（常量C1，C2:TComplex）：TComplex；
开始
结果r:=C1.r-C2.r；
结果i:=C1.i-C2.i；
结束；
类运算符TComplex.Subtract（常数C:TComplex；常数D:Double）：TComplex；
开始
结果r:=C.r-D；
结果：i:=C.i；
结束；
类运算符TComplex.Subtract（常数D:Double；常数C:TComplex）：TComplex；
开始
结果r:=D-C.r；
结果i:=-C.i；
结束；
类运算符TComplex.Multiply（常数C1，C2:TComplex）：TComplex；
开始
结果r:=C1.r*C2.r-C1.i*C2.i；
结果i:=C1.r*C2.i+C1.i*C2.r；
结束；
类运算符TComplex.Multiply（常数C:TComplex；常数D:Double）：TComplex；
开始
结果r:=C.r*D；
结果i:=C.i*D；
结束；
类运算符TComplex.Multiply（常数D:Double；常数C:TComplex）：TComplex；
开始
结果r:=D*C.r；
结果i:=D*C.i；
结束；
类运算符TComplex.Divide（常量C1，C2:TComplex）：TComplex；
变量
R、 分母：双；
开始
如果abs（C2.r）>=abs（C2.i），则开始
R:=C2.i/C2.R；
分母：=C2.r+r*C2.i；
结果r:=（C1.r+r*C1.i）/分母；
结果i:=（C1.i-R*C1.R）/分母；
结束，否则开始
R:=C2.R/C2.i；
分母：=C2.i+R*C2.R；
结果r:=（C1.r*r+C1.i）/分母；
结果i:=（C1.i*R-C1.R）/分母；
结束；
结束；
类运算符TComplex.Divide（常数C:TComplex；常数D:Double）：TComplex；
开始
结果：=C*（1.0/D）；
结束；
类运算符TComplex.Divide（常数D:Double；常数C:TComplex）：TComplex；
变量
R、 分母：双；
开始
如果abs（C.r）>=abs（C.i），则开始
R:=C.i/C.R；
分母