Hallo,
ich bin gerade am grübeln zu der besten Variante. Gegeben sei ein

markieren

Delphi-Quellcode:

  TBlaResult = record
    one, two: Double;
  end;

Dann gibt es ein function irgendwo, da will man das zurücksetzen mit den Werten 0. (In anderen function abers). Was ist da nun am Besten?

zusammenfalten · markieren

Delphi-Quellcode:

//a)
function TBlaNullStrategy.DetermineBla(): TBlaResult;
begin
  Result.one := 0.0;
  Result.two := 0.0;
end;
//b)
function TBlaNullStrategy.DetermineBla(): TBlaResult;
begin
  Result := Default(TBlaResult);
end;
//c)
function TBlaNullStrategy.DetermineBla(): TBlaResult;
begin
  Result := Default(TBlaResult);
  Result.one := 0.0;
  Result.two := 0.0;
end;

Für mich ist bei a) schön, dass man explizit darstellt, dass es in diesem Fall die Werte 0 sind. Der Nachteil ist, dass wenn man mal TBlaResult erweitert und vergisst das hier anzupassen, man undefinierte Inhalte bekommt. (Hat FixInsight auch nicht gemerkt.)
Bei b) kann das nicht passieren und ist auch schön kurz. Es ist allerdings nicht explizit, man muss wissen dass der Default-Wrt von TBlaResult eben dann auch 0 ist.
c) wäre eine Kombination. Es kann nicht passieren und es ist auch schön explizit. Irgendwie aber auch DRY und auch mehr Code.
Meinungen?

Was wäre damit ?

markieren

Delphi-Quellcode:

  TBlaResult = record
    one, two: Double;

    procedure Clear; //das

    class function CreateNew : TBlaResult; static; // oder das
  end;

Zitat von freimatz:

Der Nachteil ist, dass wenn man mal TBlaResult erweitert und vergisst das hier anzupassen, man undefinierte Inhalte bekommt.

Das bringt mich jedes mal wieder zum Weinen. Wie schwierig könnte es wohl sein den Compiler zu ertüchtigen dass hier nicht initialisierte Werte im Spiel sind? Anscheinend ist das Raketenwissenschaft. Aus diesem Grund scheidet a) eigentlich aus.

Gegen c) spricht nichts - Ich bin kein Compiler-Experte, ich würde einem vernünftigem Compiler zutrauen die eigentlich überflüssigen Zuweisungen wegzuoptimieren.


PS: Abgesehen davon dass ich, wie bereits vorgeschlagen, dem Record unbedingt eine Default-Methode verpassen würde.

Ich bin nicht davon ausgegangen dass der Compiler das optimieren kann. Habe trotzdem kurz mal nachgeschaut (32-Bit):

markieren

Code:

Result := Default (...);
mov edx,[ebp+$08]
mov edi,edx
xor eax,eax
stosd
stosd
stosd
stosd

Result.one := 0;
mov eax,[ebp+$08]
xor edx,edx
mov [eax],edx
mov [eax+$04],edx

Result.two := 0;
mov eax,[ebp+$08]
xor edx,edx
mov [eax+$08],edx
mov [eax+$0c],edx

Dass er zweimal die Adresse von Result holt finde ich dann aber schon etwas schwach. (Ich bin mir aber nicht ganz sicher ob nicht eine Optimierung hier ausgeschaltet ist)

genau um dies vollautomatisch an exakt nur einer einzigen Stelle im Programm pro Record zentral zu lösen, wurden doch mit Delphi 10.4 Sydney die "Custom Managed Records" eingeführt

So steht nun einer <> NULL Initialisierung und bei Bedarf sogar dem automatischem "Aufräumen" CleanCode mäßig nix mehr im Weg.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyRecord = record
    Value: Integer;
    class operator Initialize (out Dest: TMyRecord);
    class operator Finalize(var Dest: TMyRecord);
  end;

class operator TMyRecord.Initialize (out Dest: TMyRecord);
begin
  Dest.Value := 10;
  Log('created' + IntToHex (Integer(Pointer(@Dest)))));
end;

class operator TMyRecord.Finalize(var Dest: TMyRecord);
begin
  Log('destroyed' + IntToHex (Integer(Pointer(@Dest)))));
end;

c) ist unnötig, wenn die Defaults eh 0.0 sind - das erledigt Default() schon - nur wenn sie von dem abweichen muss man da was setzen.
Dein gezeigner asm ist ohne Optimierung - mit sieht das so aus:

markieren

Code:

Result := Default(TBlaResult);
0041BDB4 8BFB            mov edi,ebx
0041BDB6 33C0             xor eax,eax
0041BDB8 AB              stosd
0041BDB9 AB              stosd
0041BDBA AB              stosd
0041BDBB AB              stosd
Result.one := 0.0;
0041BDBC 33C0             xor eax,eax
0041BDBE 8903             mov [ebx],eax
0041BDC0 894304           mov [ebx+$04],eax
Result.two := 0.0;
0041BDC3 33C0             xor eax,eax
0041BDC5 894308           mov [ebx+$08],eax
0041BDC8 89430C          mov [ebx+$0c],eax
Project456.dpr.30: end;
0041BDCB 5F              pop edi
0041BDCC 5B              pop ebx
0041BDCD C3               ret

Man könnt sich jetzt noch darüber beschweren, dass er mehrfach eax leert, aber so ist er halt unser lieber Delphi Compiler - von Peephole Optimizations kein Plan

Ein gescheiter Compiler würd da übrigens sowas draus machen:

markieren

Code:

pxor   xmm0, xmm0
movups [eax], xmm0

So müssen sich ungefähr früher die Bauern gefühlt haben wenn der Pfarrer was Lateinisches aus der Bibel gepredigt hat.

Ich verstehe kein Wort, aber wird schon alles richtig sein.

Wir haben uns in dem Fall für b) entschieden, in anderen für c)

"class operator" bringt bei uns nichts. "Default" ist hier ja völig ausreichend.
Vielleicht hätte ich auch noch explizit darauf hinweisen sollen, dass das hier in einer Strategie benutzt wird.

Zitat von Der schöne Günther:

So müssen sich ungefähr früher die Bauern gefühlt haben wenn der Pfarrer was Lateinisches aus der Bibel gepredigt hat.

Ich verstehe kein Wort, aber wird schon alles richtig sein.

Gib dich nicht auf!

Lern Assembler (lesen):
https://www.syncfusion.com/ebooks/assemblylanguage

Zitat von Stevie:

Ein gescheiter Compiler würd da übrigens sowas draus machen:

markieren

Code:

pxor   xmm0, xmm0
movups [eax], xmm0

Die Namen gescheiter Compiler darfst du uns jetzt aber nicht vorenthalten. Das wäre richtig gemein!

Bis bald...
Thomas