7

更新： 简单的解决方法。方法/操作员字段之前的数据字段。

今天我试图用我能做的最简单的例子来重现这个错误。

  • 我从只有简单的设置和打印方法（没有运算符）的基本记录 (TBasicRecord) 开始，传递 const x:TBasicBecord 没有问题。

  • 然后我添加了一个一元运算符，认为这会触发错误，但将记录作为 const 传递仍然没有问题。

  • 然后我添加了一个二元运算符，但仍然没有出现错误。

  • 最后，我注意到在我的简单示例中，我在方法字段之前声明了数据字段，结果证明这就是消除错误所需的全部内容。

我也将我的数据字段设为私有，所以起初我认为这一定是问题所在，但最终结果证明它无关紧要。唯一不同的是我是否将数据字段放在运算符和方法字段之前。

总的来说，我对这个决议很满意。就我个人而言，无论如何我总是将数据字段放在首位。有趣的是，反过来这样做似乎并没有引起任何其他问题，只要您不尝试将记录类型作为“const”参数传递到任何地方。

原帖：

以前我一直在使用 Delphi 7，但今天安装了 Delphi 2006 以访问 D7 不支持的操作员方法。

我正在尝试编译此处对较早问题的答复之一中列出的代码（复数实现）：Request simple example of how to a TComplexMath class (source included)

以下是相关代码的部分列表：

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;
    c: Double;
  end;

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

问题是，当我尝试编译此代码时（在 D2006 中），每个采用 TComplex 类型的运算符都会给出 E2037 错误：“----”的声明与之前的声明不同。（其中“---”是操作员名称）。

我的解决方法是从每个 TComplex 参数中删除const关键字，然后代码正确地符合（并运行）。我可以保留“const x: Double”参数，编译器没有给出错误，但我必须从所有其他参数中删除“const”。

有谁知道这是否是一些未启用的编译器选项？还是在更高版本的 Delphi 中支持此功能，但在 D2006 中不支持？还是只是我做错了其他事情？

另外，如果我不能在这里使用 const 参数，那么将var替换为const会有什么好处（与完全删除 const 关键字相比）。

4

2 回答 2

10

您不应该替换const为var. 让我解释一下为什么。

背景

function Add(a: integer): integer;
begin
  result := a + 5;
end;

返回其参数 + 5。尝试ShowMessage(IntToStr(Add(10))). 您也可以这样做a := 10; ShowMessage(IntToStr(Add(a)))以获得相同的结果。在这两种情况下，传递给函数的东西Add都是数字10。消息显示15。

参数的预期用途var是这样的：

procedure Add(var a: integer);
begin
  a := a + 5;
end;

var表示参数变量应该通过引用传递；也就是说，只有指向参数变量的指针应该传递给过程/函数。

因此，现在你可以做

a := 10;
Add(a);
ShowMessage(IntToStr(a)); // You get 15

现在你甚至不能做Add(10)，因为10它根本不是一个变量！

比较， 

function Add(a: integer): integer;
begin
  a := a + 5;
  result := a;
end;

不会影响a。所以，

a := 10;
ShowMessage(IntToStr(Add(a))); // You get 15
ShowMessage(IntToStr(a)); // You get 10

现在，考虑这个可怕的功能：

function Add(var a: integer): integer;
begin
  a := a + 5;
  result := a;
end;

这也将返回它的参数 + 5，但它也会影响它的参数（非常意外！！），并且除了变量作为参数之外你不能传递任何东西（所以Add(10)不会工作！！）！

a := 10;
ShowMessage(IntToStr(Add(a))); // You get 15
ShowMessage(IntToStr(a)); // You get 15 (!!!)

那么，什么是const？好吧，const粗略的意思是“尽可能通过引用传递（以加快速度；例如，您不需要复制大记录），但永远不要接受对参数的任何更改”。因此，一个const参数有效地作为普通参数工作，除了你不能改变它：

function Add(const a: integer): integer;
begin
  result := a + 5;
end;

工作时

function Add(const a: integer): integer;
begin
  a := a + 5;
  result := a;
end;

甚至不编译！但你仍然可以做到Add(10)。

相关案例

从这个讨论中，应该清楚你不应该替换const为var. 确实，

  1. 如果您从 更改const为var，您的函数将不再接受文字 ( 10) 或表达式 (Tag + 30或SomeFunc(a, b)) 的参数。这是一个主要的表演停止者！
  2. 函数的未来实现可能会更改参数，这会意外更改作为参数传递的变量。

第一点的例子。使用const或普通参数：

function Complex(a, b: real): TComplex;
begin
  result.r := a;
  result.c := b;
end;

...

var
  c, d: TComplex;
begin    
  d := -c;                        // Works!
  d := -Complex(10, 20);          // Works!

但是使用var：

var
  c, d: TComplex;
begin    
  d := -c;                        // Works!
  d := -Complex(10, 20);          // [DCC Error] Unit5.pas(262):
                                  // E2015 Operator not applicable to this
                                  // operand type

这也不起作用（使用var）：

var
  a, b, c: TComplex;
begin

  a := -(b + c);

确实，现在的参数Negative不是变量，而是表达式b + c。所以你输得很惨！

第二点的例子。假设你有一个糟糕的一天，你把 to 的实现搞砸Negative了

class operator TComplex.Negative(var C: TComplex): TComplex;
begin
  C.r := -C.r;
  C.c := -C.c;
  result := C;
end;

然后是以下代码，

var
  c, d: TComplex;
begin

  c := Complex(10, 20);
  d := -c;

  ShowMessage(FloatToStr(c.r));
  ShowMessage(FloatToStr(d.r));

曾经导致消息10,-10会突然改变并产生-10, -10，这是非常出乎意料的！

结论

因此，在您的情况下，解决方案只是const完全删除（而不是用var！替换它）。

于 2013-02-28T21:42:39.907 回答
6

不要在运算符重载中用 var 替换 const。时期。

即使您承诺永远不会修改函数体内的 var 参数（一开始是一个可疑的基础），只是 var 参数的存在会破坏运算符函数的一个非常重要的方面：表达式的组合。运算符函数中的 var 参数使得无法将该运算符与复合表达式中的其他运算符组合在一起，因为函数结果无法传递给 var 参数。

示例：(A + B) * C。

如果 A、B 和 C 都是 TComplex 类型，则编译为TComplex.Multiply(TComplex.Add(A, B), C). 如果 TComplex.Multiply 使用 var params 声明，则 Add 的函数结果不能传递给 Multiply（因为函数结果是中间值，而不是位于特定内存地址的变量），这意味着像 ( A + B) * C 不会编译。

因此，如果您希望您的运算符可用于复合表达式，请不要在您的运算符函数中使用 var 参数。

于 2013-03-01T01:52:54.810 回答