Class operator implizit: Parameter dieses Typs dürfen keine Standardwerte haben

[Codehunter]

Moin!

Ich lasse mal den Quelltextauszug für sich sprechen:

Delphi-Quellcode:

interface

type
  TIntBoolean = record
  strict private
    FValue: Boolean;
  public
    property AsBoolean: Boolean read FValue write FValue;
    class operator Implicit(AInteger: Integer): TIntBoolean;
    class operator Implicit(AIntBoolean: TIntBoolean): Integer;
    class operator Implicit(ABoolean: Boolean): TIntBoolean;
    class operator Implicit(AIntBoolean: TIntBoolean): Boolean;
  end;

implementation

class operator TIntBoolean.Implicit(
  AInteger: Integer): TIntBoolean;
begin
  Result.AsBoolean := (AInteger > 0);
end;

class operator TIntBoolean.Implicit(
  ABoolean: Boolean): TIntBoolean;
begin
  Result.AsBoolean := ABoolean;
end;

class operator TIntBoolean.Implicit(
  AIntBoolean: TIntBoolean): Integer;
begin
  Result := Integer(AIntBoolean.AsBoolean);
end;

class operator TIntBoolean.Implicit(
  AIntBoolean: TIntBoolean): Boolean;
begin
  Result := AIntBoolean.AsBoolean;
end;

{... andere Unit ...}

interface

  function Produce(AParam: TIntBoolean = 1): string; // <-- E2268 Parameter dieses Typs dürfen keine Standardwerte haben

Warum bringt es der Compiler nicht hin, die implizite Integer-Zuweisung hier zu machen? Und besteht die Möglickeit, dies durch Änderungen an TIntBoolean dennoch zu bewerkstelligen?

PS: Nicht über die Banalität des Beispiels wundern. Ich habs nur abstrahiert um auf den Punkt zu kommen.

Grüße
Cody

[Uwe Raabe]

Zitat von Codehunter:

Warum bringt es der Compiler nicht hin, die implizite Integer-Zuweisung hier zu machen?

Der Compiler lässt halt keine Default-Parameter bei Records zu. Da schaut er dann nicht mehr, ob das über eine implizite Typumwandlung realisierbar wäre.

Lösen kannst du das wohl nur über ein overload:

Delphi-Quellcode:

  function Produce(AParam: TIntBoolean): string; overload;
  function Produce: string; overload; 
...
function Produce: string;
begin
  Result := Produce(1);
end;

[Codehunter]

Sprechen da deiner Meinung nach technische Gründe dagegen oder wäre das einen Feature Request wert? IMHO sind die überladbaren Operatoren viel später hinzu gekommen als die Sperre von Defaults für Records (die ja ohne implizite Operatoren tatächlich keinen Sinn ergeben). Möglicherweise wurde das ja bei der Implementierung der überladbaren Operatoren im Compiler schlichtweg nur vergessen?

[Uwe Raabe]

Zitat von Codehunter:

Sprechen da deiner Meinung nach technische Gründe dagegen oder wäre das einen Feature Request wert?

Wäre einen Versuch wert.

[Zacherl]

Ist vermutlich leicht OT, aber:

Die class operator sind in Delphi generell einfach schlecht implementiert. Wenn ich einen Impliziten Cast als Operator implementiere, will ich, dass Dieser IMMER angewendet wird. Egal, ob ich nur eine einfache Zuweisung mache oder aber eben eine Zuweisung nach vorheriger Addition mit z.B. einem Integer (für den ich bidirektional implizite Casts implementiert habe), etc. Das ist leider ebenfalls nicht möglich. Stattdessen muss zusätzlich der Additions/Subtraktions/... Operator überladen werden. Riecht ein wenig danach, als ob dein konkretes Problem auch unter diese Schiene fallen könnte.

Auch nie verstanden habe ich, dass die class operator jedes mal eine neue Instanz zurückgeben müssen und man nicht wenigstens die Möglichkeit hat den Operator auch mit var Parameter zu realisieren.

[Codehunter]

Zitat von Zacherl:

Auch nie verstanden habe ich, dass die class operator jedes mal eine neue Instanz zurückgeben müssen und man nicht wenigstens die Möglichkeit hat den Operator auch mit var Parameter zu realisieren.

DAS wiederum versteh ich schon. Immerhin heißt es ja class operator und nicht instance operator. Allerdings bin ich da auch schon drüber gestolpert, weil ich den class operator auf einer "Record-Instanz" (wenn man das mal so nennen will) ausgeführt habe und nicht dran dachte dass da eine andere Instanz bei raus kommt.

Auch spannend fände ich jedenfalls die Möglichkeit, wenn sich record helper for TTypIrgendwas mit class operators aufwerten ließen. Intuitiv hatte ich das versucht, ging aber nicht weil in helper records anscheinend gar keine class operators implementiert sind und der Compiler die etwas kryptische Meldung ausgab, dass er ein "var" oder ein "(" erwarten würde. Man stelle sich mal vor:

Delphi-Quellcode:

type
  TMyInteger = type of Integer;

  TMyIntegerHelper = record helper for TMyInteger
  public
    class operator Implicit {...} : string;
    {...}
    class operator Implicit {...} : Integer;
    {...}
  end;

{...}

procedure Produce;
var
  I: TMyInteger;
  S: string;
begin
  I := 4;
  S := I;
  WriteLn(S);
  WriteLn(I);
end;