Fluent Design und Records

[hschmid67]

Super!

Vielen, vielen Dank. Jetzt hab ich es verstanden.

Hier noch mein vollständiges Beispiel, das jetzt funktioniert (natürlich nur im Anfangsstadium):

Delphi-Quellcode:

unit hs.str2;

interface

type
  PhsStr2 = ^ThsStr2;
  ThsStr2 = record
    FStr: string;
    function Init(const mString: string): PhsStr2;
    class operator implicit(const aValue: ThsStr2): string;
    class operator implicit(const aValue: string): ThsStr2;
  end;

implementation

uses
  System.SysUtils;

{ ThsStr2 }

class operator ThsStr2.implicit(const aValue: ThsStr2): string;
begin
  Result := aValue.FStr;
end;

class operator ThsStr2.implicit(const aValue: string): ThsStr2;
begin
  Result.FStr := aValue;
end;

function ThsStr2.Init(const mString: string): PhsStr2;
begin
  FStr := mString;
  Result := @Self;
end;

end.

Und der Aufruf läuft jetzt erfolgreich:

Delphi-Quellcode:

procedure Test;
var
  lStr: ThsStr2;
  lDummy: string;
begin
  lDummy := lStr.Init('dummy');
end;

Genau das, was ich gesucht hatte - und in meinen Augen dann richig schöner Code, denn man kann das Ganze ja beliebig erweitern, etwa


lDummy := lStr.Init('dummy').CopyFromChar('-').CopyToChar('#');

Das möchte ich nämlich gerade machen: All meine String-Funktionen in einen Aufruf, in ein Objekt/einen Record zu packen, ohne globale Proceduren oder besonderes Speichermanagement (zumindest nicht sichtbar).

Jetzt wäre es nur noch schön, wenn man es so aufrufen könnte:


lDummy := lStr('dummy').CopyFromChar('-').CopyToChar('#');

also ohne das Init, aber das geht wohl nicht...

Vielen Dank und viele Grüße
Harald

[uligerhardt]

Schaut gut aus. Bzgl. des letzten Satzes: Du könntest dem Record einen Konstruktor oder eine Factory-Funktion verpassen. Dann solltest du so etwas schreiben können:

Delphi-Quellcode:

lDummy := ThsStr2.Create('dummy').CopyFromChar('-').CopyToChar('#'); // Mit Record-Konstruktor
// oder
lDummy := MakehsStr2('dummy').CopyFromChar('-').CopyToChar('#'); // Mit Factory-Funktion

[hschmid67]

Hallo, auch hierfür nochmal danke.
Klar, das, was ich mit Objekten und Interfaces machen kann, also eine Factory-Methode, das kann ich auch mit einem Record machen - hätte ich auch selbst drauf kommen können.

Verblüffend, was man mit Delphi doch auch alles machen kann, wenn man nur weiß, wie!

Ich werde es jetzt also so machen (doch eine globale Funktion, aber die eine passt dann schon):

function hsStr(const mValue: string = ''): ThsStr2;

und dann sieht der Aufruf tatsächlich so aus - und ich kann es mit oder ohne Initialisierungsstring aufrufen:

lDummy := hsStr('dummy').CopyFromChar('-').CopyToChar('#');

Vielen Dank und herzliche Grüße

Harald

[uligerhardt]

[hschmid67]

noch zwei Ergänzungen:

Ich war vorhin wohl doch zu voreilig: Es funktioniert nicht ganz ohne Dereferenzierung, zumindest nicht die implizite Zuweisung. Will ich das Ergebnis nach einem Implicit-Operator direkt einem String zuweisen, dann geht es nur so:

Delphi-Quellcode:

lDummy := hsStr('dummy').CopyFromChar('-').CopyToChar('#')^;  // funktioniert mit dem abschließenden ^
lDummy := hsStr('dummy').CopyFromChar('-').CopyToChar('#');  // funktioniert NICHT ohne das abschließende ^

hmmm

Allerdings habe ich inzwischen auch die Geschwindigkeit der beiden Konstrukte getestet, also einmal mit einem Objekt/Interface und einmal mit einem Record und die Record-Variante ist bei sonst völlig identischem Code fast doppelt so schnell.

Viele Grüße
Harald

[uligerhardt]

Zitat von hschmid67:

Ich war vorhin wohl doch zu voreilig: Es funktioniert nicht ganz ohne Dereferenzierung, zumindest nicht die implizite Zuweisung. Will ich das Ergebnis nach einem Implicit-Operator direkt einem String zuweisen, dann geht es nur so:

Delphi-Quellcode:

lDummy := hsStr('dummy').CopyFromChar('-').CopyToChar('#')^;  // funktioniert mit dem abschließenden ^
lDummy := hsStr('dummy').CopyFromChar('-').CopyToChar('#');  // funktioniert NICHT ohne das abschließende ^

hmmm

Dass man den ^ überhaupt manchmal weglassen darf, ist eh schon eine Krücke. Wo es dann zu uneindeutig wird, ist es halt ganz verboten.

Zitat von hschmid67:

Allerdings habe ich inzwischen auch die Geschwindigkeit der beiden Konstrukte getestet, also einmal mit einem Objekt/Interface und einmal mit einem Record und die Record-Variante ist bei sonst völlig identischem Code fast doppelt so schnell.

Jo. Ich vermute mal, weil keine überflüssigen Speichereservierungen vorgenommen werden. Bei einem Interface kämen dann auch noch die virtuelle Methodenauflösung hinzu, wenn ich mich nicht täusche.