Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

[Andreas13]

Hallo Community,
ich möchte gerne Optionale (= vorbelegte) FunktionsParameter vom Type Record nach folgendem Muster verwenden:

Delphi-Quellcode:

Function p_ex(V, T, n: Extended; z: Extended = 1.25): Extended;
Begin
 . . .
End;

So funktioniert es natürlich einwandfrei.
Nun möchte ich einen vorbelegten Record als Parameter z übergeben:

Delphi-Quellcode:

Type
  TDRecord = Record
    X: Double;
    Y: Double;
  End;
      
Function p_Rec(V, T, n: Extended; z: TDRecord = (1.25, 2.5): Extended;
Begin
 . . .
End;

was der Compiler freilich ablehnt.

Hat jemand eine Idee wie ich den Parameter z mit Default-Werten vorbelegen könnte?
Geht das überhaupt?

Danke im Voraus!
Gruß, Andreas

[uligerhardt]

Als Defaultparameter geht das nicht, aber mit overload:

Delphi-Quellcode:

function p_Rec(V, T, n: Extended; const z: TDRecord): Extended; overload;
begin
 . . .
end;

function p_Rec(V, T, n: Extended): Extended; overload;
const
  z: TDRecord = (X: 1.25; Y: 2.5);
begin
  Result := p_Rec(V, T, n, z);
end;

[Andreas13]

Danke Uli für Deinen Vorschlag! Der einzige Schönheitsfehler ist nur, daß sich dadurch der Code verdoppelt und Redundanzen mit den bekannten Nachteilen entstehen.
Vielleicht kennt jemand einen noch besseren Weg?
Gruß, Andreas

[KodeZwerg]

Das Record wie eine Klasse aufbauen, also per "strict private" variablen und einer "Init" methode vielleicht?

[uligerhardt]

Zitat:

Zitat von Andreas13 (Beitrag 1490683)

Danke Uli für Deinen Vorschlag! Der einzige Schönheitsfehler ist nur, daß sich dadurch der Code verdoppelt und Redundanzen mit den bekannten Nachteilen entstehen.
Vielleicht kennt jemand einen noch besseren Weg?
Gruß, Andreas

Nö - die eine Routine ist ja nur ein dünner Wrapper, der die andere aufruft.

[Andreas13]

@KodeZwerg:
Die einfache herkömmliche Alternative wäre, in der rufenden Routine den Record z vorzubelegen

Delphi-Quellcode:

z.X:= 1.25; z.Y:= 2.5;

und z so als Parameter zu übergeben.
Daraus Klassen zu machen mit "strict private" Variablen und einer "Init" - Methode wäre eine Kanone auf ein Spätzchen, zumal ich etliche solche Funktionen mit Vorbelegung habe. Dadurch wäre sowohl der Code, als auch die Benutzung wesentlich komplizierter.

@Uligerhardt:
In manchen Fällen wäre es in der Tat nur ein dünner Wrapper, wenn die Werte in z linear in die Routine

Delphi-Quellcode:

p_Rec(V, T, n: Extended; const z: TDRecord): Extended;

eingehen, also wenn z.B. gilt:

Delphi-Quellcode:

p_Rec(V, T, n, z) := z.X*p_Rec(V, T, n) + z.Y;

Aber oft sind die Werte z.X und z.Y auf eine wesentlich kompliziertere, nichtlineare Art und Weise in der Funktion enthalten.

Man kann sich das etwa so vorstellen: Die StandardFunktion verwendet für die Berechnung einer komplexen Formel z.B.

Delphi-Quellcode:

z.X:= 1.25; z.Y:= 2.5;

. Es gibt aber noch Funktion_1, Funktion_2, Funktion_3 etc., welche mit der gleichen Formel aber mit verschiedenen z-Werten arbeiten können. In solchen Fällen wäre es kein dünner Wrapper mehr, sondern eine Duplizierung des Codes der Berechnungsroutine.
Aber für die linearen Fälle ist Dein Vorschlag mit

Delphi-Quellcode:

overload;

eine gute Lösung.
Danke & Gruß, Andreas

[uligerhardt]

Zitat:

Zitat von Andreas13 (Beitrag 1490696)

@Uligerhardt:
In manchen Fällen wäre es in der Tat nur ein dünner Wrapper, wenn die Werte in z linear in die Routine

Delphi-Quellcode:

p_Rec(V, T, n: Extended; const z: TDRecord): Extended;

eingehen, also wenn z.B. gilt:

Delphi-Quellcode:

p_Rec(V, T, n, z) := z.X*p_Rec(V, T, n) + z.Y;

Aber oft sind die Werte z.X und z.Y auf eine wesentlich kompliziertere, nichtlineare Art und Weise in der Funktion enthalten.

Man kann sich das etwa so vorstellen: Die StandardFunktion verwendet für die Berechnung einer komplexen Formel z.B.

Delphi-Quellcode:

z.X:= 1.25; z.Y:= 2.5;

. Es gibt aber noch Funktion_1, Funktion_2, Funktion_3 etc., welche mit der gleichen Formel aber mit verschiedenen z-Werten arbeiten können. In solchen Fällen wäre es kein dünner Wrapper mehr, sondern eine Duplizierung des Codes der Berechnungsroutine.
Aber für die linearen Fälle ist Dein Vorschlag mit

Delphi-Quellcode:

overload;

eine gute Lösung.
Danke & Gruß, Andreas

Meine Lösung kann Defaultparameter ersetzen, mehr nicht. Was du hier beschreibst, ginge ja auch mit Defaultparametern nicht.

[KodeZwerg]

Delphi-Quellcode:

type
  MyRec = packed record
    public
      procedure DoJob(const AValue: Integer = -1; const BValue: DOUBLE = 1.23);
  end;

var
  Form15: TForm15;

implementation

{$R *.dfm}

procedure MyRec.DoJob(const AValue: Integer = -1; const BValue: Double = 1.23);
begin
  //
end;

Habe es gerade mal ausprobiert und es compiliert ohne einen Fehler zu werfen.

[Andreas13]

@Uligerhardt:

Zitat:

Meine Lösung kann Defaultparameter ersetzen, mehr nicht. Was du hier beschreibst, ginge ja auch mit Defaultparametern nicht.

Doch Uli, es funktioniert bestens, denn beim Aufruf der Funktion kann ich die optionalen Parameterwerte überschreiben, d.h. mit neuen Werten belegen, mit denen dann gerechnet werden soll.

Hallo KodeZwerg,
ja, aber damit hast Du den Record in optional vorbelegte Teile zerpflückt. Das würde bei mir etwa entsprechen:

Delphi-Quellcode:

Function p_Rec(V, T, n: Extended; X: Double = 1.25; X: Double = 2.5): Extended;
Begin
 . . .
End;

Das habe schon lange so, was ohne Probleme funktioniert. Aber die Liste meiner optionalen Parameter kann auch mal deutlich länger sein bis zu 20 Elementen und mehr, daher dachte ich ein einen vorbelegten Record, weil dies übersichtlicher wäre.

Hinzu kommt andererseits der eigentliche Auslöser, der mich über die Parameterübergabe als vorbelegten optionalen Record bewogen hat: Das ist die Verwendung der mathematischen Bibliothek Neslib.MultiPrecision. Das sind die Beweggründe & Vorläufer dafür, damit Ihr das Ganze besser verstehen könnt:

1): High-Precision Floating-Point Types for Delphihttps://blog.grijjy.com/2021/05/05/h...#comment-29726
2): High-Precision Floating-Point Types for Delphi - Hilfe beim Linken von C object files https://www.delphipraxis.net/207850-...ml#post1488969
3): Hilfe beim Linken von C object files in in Delphi XE5? https://entwickler-ecke.de/viewtopic...&postorder=asc
4): und meine Beiträge zu:
https://github.com/neslib/Neslib.Mul...ue+is%3Aclosed

Ich versuche momentan meine früheren Berechnungen testweise von

Delphi-Quellcode:

Extended

auf die höhere Genauigkeit DoubleDouble (32 Ziffern) und QuadDouble (64 Ziffern) umzustellen.
Beide neuen Datentypen sind im wesentlichen Records:

Delphi-Quellcode:

Type 
DoubleDouble = record
  public
  X: array [0..1] of Double;
  . . .
End;
  . . .

QuadDouble = record
  public
  X: array [0..3] of Double;
    . . .
End;

Und diese Records kann man nicht zerpflücken, denn die Teile des Record-Arrays enthalten die weiteren Nachkommastellen, die nicht vom Benutzer, sondern von der Bibliothek intern nach aufwendigen iterativen Berechnungen bestimmt werden.

Damit ich meine zahlreichen "alten" Berechnungen, die viele vorbelegte optionale Parameter des Typs

Delphi-Quellcode:

Extended

enthalten auf

Delphi-Quellcode:

DoubleDouble

oder

Delphi-Quellcode:

QuadDouble

umstellen kann, müßte ich vorbelegte Records übergeben können, oder auf die Annehmlichkeit der vorbelegten optionalen Parameter verzichten...

Gruß, Andreas

[Uwe Raabe]

Nun, der Compiler lässt aber nun mal Default-Werte bei Record-Parametern nicht zu. Dann bleibt halt nur der von Uli beschriebene Ansatz mit overload.

Für den anfangs beschriebenen Anwendungsfall sehe ich da auch keinen wesentlichen Nachteil.

Delphi-Quellcode:

function p_Rec(V, T, n: Extended; const z: TDRecord): Extended; overload;
begin
 . . .
end;

function p_Rec(V, T, n: Extended): Extended; overload;
const
  z: TDRecord = (X: 1.25; Y: 2.5);
begin
  Result := p_Rec(V, T, n, z);
end;

Es lassen sich so Aufrufe mit und ohne z-Parameter schreiben, die auch korrekt ausgeführt werden. Wenn das nicht für deinen Anwendungsfall passt, dann zeig den doch mal. Es hilft ja nicht, wenn wir hier Lösungen für ein Problem suchen, was gar nicht existiert. Ich persönlich kann im Moment noch nicht sehen, wo es bei dir genau hakt.

[Andreas13]

Hallo Uwe,
für einfachere Anwendungsfälle mit linearem Verhalten reicht der von Uli vorgeschlagene Ansatz mit overload.
Aber hier ist ein einfaches Praxisbeispiel, wo ein overload nicht mehr ausreicht:

Delphi-Quellcode:

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended;
                                                   c1: Extended = 0.0235;
                                                   c2: Extended = 0.80;
                                                   c3: Extended = 230;
                                                   c4: Extended = 1.80;
                                                   c5: Extended = 0.3;
                                                   c6: Extended = 0.80): Extended;

// Berechnung der Nußelt-Zahl in turbulent durchströmten Wärmeaustauscher-Rohren

VAR
  Z: Extended;

Begin
  Z     := c1*(Power(Re, c2) - c3);
  Z     := Z*(c4*Power(Pr, c5) - c6);
  Z     := Z*(1 + Power(d_i/L, 2/3));
  Result:= Z*Power(Eta/Eta_W, 0.14);
End;{Nu_Rohr_Turbulent}
{---------------------}

mit zwei verschiedenen – mit dem Datentype

Delphi-Quellcode:

Extended

funktionierenden – Aufrufen:

Delphi-Quellcode:

    Re   := 75270.7430748079;
    Pr   := 3.01;
    d_i  := 0.05;
    L    := 8.0;
    Eta  := 0.000469874;
    Eta_W:= 0.000354;

    Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W);
    WriteLn('Nu_Standard   = ', Nu:10:4);

    Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, 0.037, 0.75, 180, 1, 0.42, 0);
    WriteLn('Nu_Variante 1 = ', Nu:10:4);

Und das wollte ich gerne auch mit

Delphi-Quellcode:

DoubleDouble

aus der Bibliothek Neslib.MultiPrecision realisieren, ohne viel am bestehenden Code ändern zu müssen:

Delphi-Quellcode:

Wunsch_Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: DoubleDouble;
                                                          c1: DoubleDouble = 0.0235;
                                                          c2: DoubleDouble = 0.80;
                                                          c3: DoubleDouble = 230;
                                                          c4: DoubleDouble = 1.80;
                                                          c5: DoubleDouble = 0.3;
                                                          c6: DoubleDouble = 0.80): DoubleDouble;
VAR
  Z: DoubleDouble;

Begin
  Z     := c1*(Power(Re, c2) - c3);
  Z     := Z*(c4*Power(Pr, c5) - c6);
  Z     := Z*(1 + Power(d_i/L, 2/3));
  Result:= Z*Power(Eta/Eta_W, 0.14);
End;{Nu_Rohr_Turbulent}
{---------------------}

Was der Compiler aber bekanntlich nicht zuläßt. Auch ein overload hilft hier leider nicht weiter.

Momentan sehe ich dazu als einfachste Möglichkeit, wenn ich den Routinen, die die Funktion aufrufen, die Variablen c1, c2, c3, c4, c5, c6 explizit deklariere und diese jeweils mit den verschiedenen Sätzen von Werten belege und die Funktion immer mit der vollständig belegten Parameterliste aufrufe:

Delphi-Quellcode:

Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, c6);

Es ist zwar etwas umständlicher, zumal ich viele derartige Funktionen habe, aber besser als gar nichts. Vielleicht kann eine künftige Delphi-Version optionale & vorbelegte Records und Arrays handhaben...

Danke für alle Beiträge!
Grüße, Andreas

[himitsu]

Was genau soll eigentlich erreicht werden?

Delphi-Quellcode:

type
  TDRecord = record
    X, Y: Extended;
    class operator Initialize(out Dest: TMyRecord);
  end;

class operator TMyRecord.Initialize(out Dest: TMyRecord);
begin
  //FillChar(Dest, SizeOf(Dest), 0); // aka ZeroMemory(@Dest, SizeOf(Dest));
  Dest.X := 1.25;
  Dest.Y := 2.5;
end;

Seit letztem Jahr in Delphi 10.4
http://docwiki.embarcadero.com/RADSt...anaged_Records



Abgesehn davon sollte Extended niemals direkt verwendet werden.
Es gibt nur Single (32 Bit) und Double (64 Bit) als Typen für Variablen und Extended war bloß für interne Berechnungen vorgesehn.
Drum kennen viele Sprachen diesen Typen garnicht erst (selbst der C++Builder kennt es nicht).

In Win64 und bei ARM ist es nur ein Alias für Double, außerdem kann der Typ somit 8 oder 10 Byte groß sein,
sogar auch mal 16 oder 12 Byte sind möglich, wobei es dort intern immernoch nur 8/10 "genutzte" Bytes sind und der Rest ist nutzloses Align.

Wer in der System.pas oder der Hilfe mal nach Extended guckt, dem wird schlecht.


OK, es gibt aktuell auch eine Library mit Float-Typen bis 256 Bit (siehe SuFu) und natürlich auch schoon ewig massig BigNumberList, aber nativ werden diese Typen nicht von der Hardware unterstützt. (sind aus mehreren Typen/Variablen zusammengesetzt und werden per software behandelt, so wie z.B. auch schon immer Int64 und UInt64 im Win32-Compiler intern aus 2x UInt32 besteht)

[Uwe Raabe]

Zitat:

Zitat von Andreas13 (Beitrag 1490725)

Auch ein overload hilft hier leider nicht weiter.

Eins nicht - sechs schon.

[Sinspin]

Was spricht gegen sowas:

Delphi-Quellcode:

function DDInit(values: array of DoubleDouble): TMyRecord;
var
  l: integer;

begin
  for l := 0 to Length(values)-1 to
    case l of
      0 : Result.Var0 := values[l];
      1 : Result.VarX := values[l];
      2 : Result.BlaBla := values[l];
      ....
    end;
end;

Sozusagen dynanisches array convertiert in record.

[himitsu]

Und jetzt darfst das DocInsight nicht vergessen, weil sonst weiß niemand, wie man diese Funktion aufrufen soll.

[Sinspin]

Zitat:

Zitat von himitsu (Beitrag 1490751)

Und jetzt darfst das DocInsight nicht vergessen, weil sonst weiß niemand, wie man diese Funktion aufrufen soll.

:lol:
Da könntest Du recht haben.

Delphi-Quellcode:

type
TMyRecord = record c1,c2,c3,c4,c5,c6: extended;end;

function DDInit(values: array of Extended): TMyRecord;
var
  l: integer;

begin
  FillChar(Result, SizeOf(Result), 0); // alles null, oder eben manuell default werte

  for l := 0 to Length(values)-1 to
    case l of
      0 : Result.C1 := values[l];
      1 : Result.C2 := values[l];
      2 : Result.C3 := values[l];
      3 : Result.C4 := values[l];
      4 : Result.C5 := values[l];
      5 : Result.C6 := values[l];
    end;
end;

Alt:

Zitat:

Zitat von Andreas13 (Beitrag 1490725)

Delphi-Quellcode:

// deklaration
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended;
                                                   c1: Extended = 0.0235;
                                                   c2: Extended = 0.80;
                                                   c3: Extended = 230;
                                                   c4: Extended = 1.80;
                                                   c5: Extended = 0.3;
                                                   c6: Extended = 0.80): Extended;
// aufruf
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, c6);

Neu:

Delphi-Quellcode:

// deklaration
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended; Data: TMyrecord): Extended;
// aufruf
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, DDInit([0.0235, 0.80, 230, 1.80, 0.3, 0.80]));

Oder, einfach ganz ohne funktion, als array :roll:

Delphi-Quellcode:

// deklaration
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended; Data: array of Extended): Extended;
// aufruf
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, [0.0235, 0.80, 230, 1.80, 0.3, 0.80]);

Gleiches Vorgehen wie bei

Delphi-Quellcode:

Format

Parameter die man nicht braucht übergibt man nicht. (das muss die Funktion intern dann selber erkennen und behandeln.)

[Uwe Raabe]

Zitat:

Zitat von Uwe Raabe (Beitrag 1490727)

Zitat:

Zitat von Andreas13 (Beitrag 1490725)

Auch ein overload hilft hier leider nicht weiter.

Eins nicht - sechs schon.

Um das mal zu verdeutlichen:

Delphi-Quellcode:

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, c6: DoubleDouble): DoubleDouble; overload;
VAR
  Z: DoubleDouble;
Begin
  Z := c1*(Power(Re, c2) - c3);
  Z := Z*(c4*Power(Pr, c5) - c6);
  Z := Z*(1 + Power(d_i/L, 2/3));
  Result:= Z*Power(Eta/Eta_W, 0.14);
End;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, DoubleDouble(0.80));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, DoubleDouble(0.3));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, DoubleDouble(1.80));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, DoubleDouble(230));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, DoubleDouble(0.80));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, DoubleDouble(0.0235));
end;

Und die entsprechende Aufrufsequenz wäre dann in etwas so aus:

Delphi-Quellcode:

var
  Re: DoubleDouble;
  Pr: DoubleDouble;
  d_i: DoubleDouble;
  L: DoubleDouble;
  Eta: DoubleDouble;
  Wta_W: DoubleDouble;
begin
  Re := DoubleDouble(75270.7430748079);
  Pr := DoubleDouble(3.01);
  d_i := DoubleDouble(0.05);
  L := DoubleDouble(8.0);
  Eta := DoubleDouble(0.000469874);
  Eta_W:= DoubleDouble(0.000354);

  Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W);
  WriteLn('Nu_Standard = ', Nu.ToString(TMPFloatFormat.Fixed, 4));

  Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, DoubleDouble(0.037), DoubleDouble(0.75), DoubleDouble(180), DoubleDouble(1), DoubleDouble(0.42), DoubleDouble(0));
  WriteLn('Nu_Variante 1 = ', Nu.ToString(TMPFloatFormat.Fixed, 4));

Sollten allerdings die optionalen Parameter eh immer mit Double- bzw. Extended-Literalen übergeben werden, dann kann man die auch gleich als Double bzw. Extended deklarieren und die Umwandlung innerhalb der Funktion machen:

Delphi-Quellcode:

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: DoubleDouble;
                                                   c1: Extended = 0.0235;
                                                   c2: Extended = 0.80;
                                                   c3: Extended = 230;
                                                   c4: Extended = 1.80;
                                                   c5: Extended = 0.3;
                                                   c6: Extended = 0.80): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W,
      DoubleDouble(c1), DoubleDouble(c2), DoubleDouble(c3), DoubleDouble(c4), DoubleDouble(c5), DoubleDouble(c6));
end;

Übrigens könnte man dem DoubleDouble für Win32 noch ein Explicit(Extended) spendieren.

[Andreas13]

Chapeau, Uwe: Du bist wirklich ein echter Master Developer! Es funktioniert alles! Besonders Dein letzter Vorschlag:

Zitat:

Sollten allerdings die optionalen Parameter eh immer mit Double- bzw. Extended-Literalen übergeben werden, dann kann man die auch gleich als Double bzw. Extended deklarieren und die Umwandlung innerhalb der Funktion machen: ...

erleichtert mir das Umsteigen enorm.

Vielen-vielen Dank Dir und Euch allen: Ihr seid die GRÖSSTEN! Ich habe sehr viel von Euch gelernt.
Viele Grüße, Andreas :thumb: :dancer:

[himitsu]

Warum kommt niemand auf die Idee sich mal zu überlegen, ob es überhaupt sinnvoll ist, sooooo viele Parameter zu haben.

PS, dazu wird in vielen StyleGuides was gesagt, nicht nur bezüglich Delphi.
Lösung: DataRecords bzw. DataObjects

Aber das kann man auch problemlos umdrehen, also anstatt Parameter-Record/Objekt an Funktion, einfach die Funktion in den Record/Objekt.

Delphi-Quellcode:

type
  TNuRohrTubulent = record  // oder als Klasse
    Re, Pr, d_i, L, Eta, Eta_W: Double;
    c1, c2, c3, c4, c5, c6: Double;
    class operator Initialize(out Dest: TNuRohrTubulent);
    function Calc: Double;
  end;

class operator TNuRohrTubulent.Initialize(out Dest: TNuRohrTubulent);
begin
  Dest.Re := NaN;
  Dest.Pr := NaN;
  Dest.d_i := NaN;
  Dest.L := NaN;
  Dest.Eta := NaN;
  Dest.Eta_W := NaN;
  Dest.c1 := 0.0235;
  Dest.c2 := 0.80;
  Dest.c3 := 230;
  Dest.c4 := 1.80;
  Dest.c5 := 0.3;
  Dest.c6 := 0.80;
end; 

function TNuRohrTubulent.Calc: Double;
begin
  Assert(not (IsNan(Re) or IsNan(Pr) or IsNan(d_i) or IsNan(L)
    or IsNan(Eta) or IsNan(Eta_W)), 'TNuRohrTubulent: params missing');
  Result := c1
    * (Power(Re, c2) - c3)
    * (Power(Pr, c5) * c4 - c6)
    * (Power(d_i / L, 2/3) + 1)
    * Power(Eta / Eta_W, 0.14);
end;

[Andreas13]

Himitsu,
der Grund ist die für mich wesentlich einfachere und übersichtlichere Handhabung der "stinknormal" prozedual erstellten altmodischen – aber vielfach getesteten und bewährten – Funktionen & Prozeduren meistens ohne Klassen und Records. Warum kompliziert, wenn es auch einfach geht.
Ich weiß, meine Ansichten sind nicht ganz zeitgemäß: Mein fortgeschrittenes Alter möge als Entschuldigung dienen…

Danke & Gruß, Andreas

[himitsu]

Naja "zeitgemäß" ....

das mit den "zuvielen Parametern" wird schon seit Jahrzehnten in StyleGuids/Pattern angekreidet, dass man sowas besser nicht machen sollte.

Delphi-Quellcode:

type
  TNuRohrTubulentParameter = record // oder object
    Re, Pr, d_i, L, Eta, Eta_W: Double;
    c1, c2, c3, c4, c5, c6: Double;
  end;

function NuRohrTubulent(const Parameter: TNuRohrTubulentParameter): Double;

[Uwe Raabe]

Nun braucht man nur noch ein Create für den Record mit den besagten optionalen Parametern und man ist wieder am Anfang - nur komplizierter.

Ne, is klar. Parameter Records sind schon besser, weil man damit sowas wie benannte Parameter realisieren kann, die Parameter leicht erweitern oder verändern kann. Aber es ist halt auch vor dem Aufruf um einiges komplexer.

[himitsu]

Das Create Initialize machen die Records jetzt auch alleine. (siehe #19)

Komplizierter? (bei Verwendung oder nur bei der Definition)

Naja, beim Befüllen ist es aber sicherer sichtbarer was an wen übergeben wird.
Bei vielen Parametern kann man schnell mal verrutschen, vorallem wenn alles den selben Typ hat ... und rein optisch kommt es fast auf's Selbe raus, wie die Array-Lösung von #14.



In den Record kann man auch eine/mehrere Setter-Funktionen machen, wo man dennoch mehrere Parameter zusammen befüllen kann. (z.B. in 2-3 kleinere Gruppen aufgeteilt)
Beim Record muß man sich um die Instanz nicht zu kümmern, also z.B.

Delphi-Quellcode:

X := NuRohrTubulent(TNuRohrTubulentParameter.Create.SetRPDL(Re, Pr, d_i, L).SetEta(Eta, Eta_W).SetC(c1, c2, c3, c4, c5, c6));

und hier lässt sich ebenso problemlos was weglassen, z.B. die ganzen Cs.