Ich bin gerade bischen am spielen mit den neuen coolen Features von überladenen Operatoren von Delphi2006

Ich möchte folgenen Aufruf starten:

zusammenfalten · markieren

Delphi-Quellcode:

var
  st : String;
  IBZeit : TIBZeit;

begin

IBZeit := now;
st := IBZEit;
showmessage(st);

st := IBZEit + '5min';
showmessage(st);


end;

jetzt ist es doch in der Tat so, dass er erstaunlicherweise zu der Zeit die 5 Minuten hinzuaddiert. (schonmal cool)
Er wandelt IBZeit sozusagen in TDateTime um. und den String auch in die IBZeit.
Woher weiß ich das ?
Man hätte ja genauso annehmen können, dass IBZeit in einen String umgewandelt wrd und dann der String '5min' angehangen wird.
Die Logik verstehe ich nicht so ganz. wie kommt das ?

zusammenfalten · markieren

Delphi-Quellcode:

//==============================================================================

TIBZeit = record
strict private
    Value : TDateTime; // am genauesten . unix Zeit ist ja nur bis auf eine Sekunde auflösend (Sekunden seit 1970)
public


    class operator implicit(UnixTime : Int64) : TIBZeit;
    class operator implicit(Zeit : TDateTime) : TIBZEit;
    class operator implicit(Value : String) : TIBZeit;

    class operator implicit(Self : TIBZeit) : String;
    class operator implicit(Self : TIBZeit) : TDateTime;


    class operator add(Zeit1, Zeit2 : TIBZeit) : TIBZeit;
end;



implementation
//==============================================================================

class operator TIBZeit.implicit(UnixTime : Int64) : TIBZEIT;
begin
 result.Value := UnixToDateTime(UnixTime);
end; // implicit
//==============================================================================
class operator TIBZeit.implicit(Zeit : TDateTime) : TIBZeit;
begin
 result.value := Zeit;
end; // implicit

//==============================================================================
class operator TIBZEit.implicit(Value : String) : TIBZeit;
var Stunden,Minuten, Sekunden, MilliSekunden : Word;
begin
  result.Value := 0;
  Stunden := 0;
  Minuten := 0;
  Sekunden := 0;
  Millisekunden := 0;
  Value := uppercase(Value);

  if pos('MIN', Value) > 0 then begin
     Value := StringReplace(Value,'MIN','', [rfReplaceAll]);
     Minuten := StrToInt(Value);
     result.Value := encodeTime(Stunden,Minuten,Sekunden,Millisekunden);
  end;

end; // implicit
//==============================================================================

//==============================================================================
class operator TIBZEit.implicit(Self : TIBZeit) : String;
var formatString : STring;
begin
   formatString := 'yyyymmdd hh:nn:ss';
   result := FormatDateTime(formatString, self.value) + ' CET';
end;

//==============================================================================
class operator TIBZEit.implicit(Self : TIBZeit) : TDateTime;
begin
  result := self.Value;
end;

//==============================================================================

class operator TIBZeit.add(Zeit1, Zeit2 : TIBZeit) : TIBZEit;
begin
   result := Zeit1.Value + Zeit2.Value;
end;

In dem Fall ist der Compiler wohl überfragt (und sollte eigentlich warnen bzw nen Fehler werfen weil unklar is was er denn nun tun soll), und nimmt einfach die erste deklarierte Umwandlung, um danach die beiden Zeiten zu addieren. Mit st := string(IBZeit) + '5min'; sollte es eigentlich funktionieren..

Ich glaube an den Comiler ...

Er weis ja, dass ein TIBTime (oder so) rauskommen soll, der eine Operand ists ja schon, und den andern wandelt er halt um ...

Zitat von jfheins:

Ich glaube an den Comiler ...

Er weis ja, dass ein TIBTime (oder so) rauskommen soll, der eine Operand ists ja schon, und den andern wandelt er halt um ...

das kann ziemlich gefährlich werden, und Brücken zum einstürzen bringen.

naja .. wird schon schief gehen

Zitat von jfheins:

Er weis ja, dass ein TIBTime (oder so) rauskommen soll, [...]

Es soll ein String rauskommen .

Ich kann das Verhalten nur für den CSC erklären, aber wenigstens würde er im oberen Beispiel das Gleiche wie der Delphi-Compiler ausspucken. Könnte also gut sein, dass die Borländer die Überladungsauflösung bei ihrem Compiler gleich oder wenigstens ähnlich gestaltet haben.

Zitat von C# Language Reference:

7.2.4 Binary operator overload resolution
An operation of the form x op y, where op is an overloadable binary operator, x is an expression of type X, and
y is an expression of type Y, is processed as follows:
• The set of candidate user-defined operators provided by X and Y for the operation operator op(x, y) is
determined. The set consists of the union of the candidate operators provided by X and the candidate
operators provided by Y, each determined using the rules of §7.2.5. If X and Y are the same type, or if X and
Y are derived from a common base type, then shared candidate operators only occur in the combined set
once.
• If the set of candidate user-defined operators is not empty, then this becomes the set of candidate operators
for the operation. Otherwise, the predefined binary operator op implementations become the set of
candidate operators for the operation. The predefined implementations of a given operator are specified in
the description of the operator (§7.7 through §7.13).

Eigene Operatoren werden also bevorzugt, der Compiler wählt die Überladung von X=TIBZeit.

Im Zweifelsfalle also lieber eine explizite Umwandlung verwenden .