Clean Code - Default benutzen

[freimatz]

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

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?

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?

[Rollo62]

Was wäre damit ?

Delphi-Quellcode:

  TBlaResult = record
    one, two: Double;

    procedure Clear;   //das

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

[Der schöne Günther]

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.

[freimatz]

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

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)

[mensch72]

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.

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;

[Stevie]

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:

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:

Code:

pxor    xmm0, xmm0
movups  [eax], xmm0

[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.

[freimatz]

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.

[TiGü]

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

[mytbo]

Zitat von Stevie:

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

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