was ist eine expicite Typumwandlung ?

[stoxx]

Hallo, bin gerade am testen mit den class operatoren:
Funktioniert soweit gut, aber für was braucht man eine explicite Typumwandlung und was macht man damit ?
Vielen Dank !

Delphi-Quellcode:

  IBZeit  : TIBZeit;
  crlf : STring;

begin

crlf := #13#10;
IBZeit:= now;

st := IBZeit  +  crlf;
st := st + DateTimeToStr(IBZeit) + crlf;

showmessage(st);

Delphi-Quellcode:

//==============================================================================
type

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(Self : TIBZeit) : String;
    class operator implicit(Self : TIBZeit) : TDateTime;

    class operator explicit(Self : TIBZeit) : String;  // unklar
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(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.explicit(self : TIBZeit): STring;
var    formatString : STring;
begin
 // für was nehm ich das ?
end;

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

[Dax]

Eine implizite Typumwandlung von Integer zu String ermöglich sowas:

Delphi-Quellcode:

var i: Integer; s: string;

s := i;

Das ist intuitiv, man denkt sich sofort, "Ah, der schreibt mir die Zahl in den String."

Explizite sind anders. Sie erlauben zwar auch Umwandlungen in andere Typen, aber nicht durch alleinige Zuweisung, du musst noch casten!

Delphi-Quellcode:

var i: Integer; s: string;

s := string(i);

[shmia]

Delphi-Quellcode:

// implizite Typumwandlung
// Compiler müsste hier eigentlich einen Fehler melden
ShowMessage(IBZeit);  

// explizite Typumwandlung
// ich sag dem Compiler mit "as" wie er umwandln soll
// er ist beruhigt und findet auch die passende klassenfunktion
ShowMessage(IBZeit as string);

[stoxx]

hmm ... ok ... *überleg* .. klar ...
aber ich bekomm es noch nicht ganz hin, was mach ich mit dem class Operator explicit bei Überladen von Operatoren wie in meinem Beispiel ?

[stoxx]

Zitat von shmia:

Delphi-Quellcode:

// implizite Typumwandlung
// Compiler müsste hier eigentlich einen Fehler melden
ShowMessage(IBZeit);  

// explizite Typumwandlung
// ich sag dem Compiler mit "as" wie er umwandln soll
// er ist beruhigt und findet auch die passende klassenfunktion
ShowMessage(IBZeit as string);

Hmm .. irgendwie stimmt das nicht;

Showmessage(IBZeit) funktioniert, und er ruft den impliciten Class Operator auf (und meldet auch keinen Fehler, funktioniert ja)

und Showmessage(IBZEit as String) funktioniert bei records nicht ..... hmmm

[Khabarakh]

Dann eben mit einem harten Typecast wie in Dax' Beispiel.
Aber ein impliziter und ein expliziter Operator mit der gleichen Signatur wie in deinem Beispiel macht wenig Sinn.

Grundsätzlich sollte man explizite Casts immer dann einsetzen, wenn entweder ein Informationsverlust stattfinden könnte (z.B. Int zu Byte, woran sich aber Delphi nicht hält ) oder der Cast fehlschlagen könnte (um Dax' Beispiel aufzugreifen: Jeder Integer lässt sich in einen String konvertieren, aber nicht unbedingt umgekehrt).

[Sharky]

Zitat von Khabarakh:

.... wenn entweder ein Informationsverlust stattfinden könnte ....

Also wenn ein Inforamtionverlust stattfinden kann möchte ich kein Typecast in meinem Code sehen.

[stoxx]

ah, ich habs jetzt, danke !!

der Unterschied ist einfach, dass ich das so aufrufen muss:

Delphi-Quellcode:

i := Integer(IBZeit);
showmessage(InttoStr(i));

und nich so aufrufen kann:

i := IBZeit

Delphi-Quellcode:

class operator TIBZeit.explicit(self : TIBZeit): Int64;
begin
 result := 21343243;
end;

[Khabarakh]

Zitat von Sharky:

Zitat von Khabarakh:

.... wenn entweder ein Informationsverlust stattfinden könnte ....

Also wenn ein Inforamtionverlust stattfinden kann möchte ich kein Typecast in meinem Code sehen.

Und wenn man einfach nur das unterste Byte eines Integers benötigt? Oder weiß, dass der Wert im Byte-Bereich liegt?
Der Compiler weiß ja nicht, ob es einen Informationsverlust geben wird oder er auch beabsichtigt ist. Deshalb warnt er vor diesem könnte mit einem expliziten Cast.

@stoxx: Der Unterschied ist einfach, dass dich der Compiler vor den zwei o.g. Gründen warnen will, er will dich ja nicht sinnlos mit Schreibarbeit quälen .

[add]Ein dritter Grund: Bytegleiche, aber sinnverändernde Casts wie Pointer -> Integer oder Double -> Int64.[/add]

[stoxx]

mal noch eine blöde Frage, (oder soll ich einen neuen Thread aufmachen)

Delphi-Quellcode:

var s : String;
    Time : TDateTime;

in dem obigen Beispiel kann ich zwar

 s := IBZeit; zuweisen

aber NICHT

Time := IBZEIT;

kapier das nicht, obwohl beide definiert sind

Delphi-Quellcode:

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;

was hab ich da jetzt falsch gemacht ??
DAnke !