Maßeinheiten als Typen

[Schokohase]

Zitat:

Zitat von Ghostwalker (Beitrag 1415477)

Und was machst du wenn Tuwas nur Gramm und Kilogramm verarbeiten soll nicht aber Tonnen oder Milligram ?

Nenne mir einen Grund warum dieses notwendig ist. Ich kann da keinen Grund erkennen.

Wird eine Formel anders, wenn du statt mit 100kg einfach mit 0,1t rechnest?

Oder würde die Formel nicht eher so aussehen

Delphi-Quellcode:

class operator TDuration.Divide( const a: TLength; const b: TDuration ): TSpeed;
begin
  Result := TSpeed.FromMetersPerSecond( a.Meters / b.Seconds );
end;

Oder um bei deinem Beispiel zu bleiben

Delphi-Quellcode:

function Tuwas( const gewichtA, gewichtB : TWeight ): Currency;
begin
  // Preis für A = 20 Euro pro Kilogramm
  // Preis für B = 30 Euro pro Gramm
  Result := 20 * gewichtA.Kilograms + 30 * gewichtB.Grams;
end;

Warum sollte es eine gesonderte Rolle spielen ob ich den Wert in Tonnen oder Kilogramm übergeben habe? In der Berechnung werden die korrekten Einheiten verwendet und nur das zählt.

[Ghostwalker]

hmm...ok..mit Type of macht es zumindest schon mal keine Probleme bei überladenen Methoden.

Aber wie bastel ich dann entsprechende Operatoren ?

[Fritzew]

Ich würde sagen, Du machst es Dir zu schwer.
Bei uns gibt es die gleiche Problematik. Allerdings versuchen wir das nicht innerhalb der Verarbeitung abzufangen.
Es gbt für jeden "Einheistfall" einen Basistypen. Bei uns für Länge, Flächen, Volumen, Gewicht, Winkel etc.
Der Basistyp muss halt Deinen gesamten Wertebereich der jeweiligen Einheit abfangen.
Umgewandelt wird nur zur Anzeige oder bei Lesen/Schreiben......
Das vereinfacht innerhalb des Programmes die ganze Rechnerei.
Wir haben Edits die den Basistyp bekommen und je nach Einstellung das in der jeweiigen Einheit anzeigt und annnimmt.
Alles einfach Testbar.

[Uwe Raabe]

Unter Verwendung der Units System.ConvUtils und System.StdConvs kann man da recht einfach was zaubern:

Delphi-Quellcode:

type
  TGramm = type Double;
  TKilogramm = type Double;

  TWeight = record
  private
    FConv: TConvType;
    FValue: Double;
  public
    constructor Create(AValue: Double; AConv: TConvType);
    class operator Implicit(A: TWeight): TGramm; overload;
    class operator Implicit(A: TGramm): TWeight; overload;
    class operator Implicit(A: TWeight): TKilogramm; overload;
    class operator Implicit(A: TKiloGramm): TWeight; overload;
    property Conv: TConvType read FConv write FConv;
    property Value: Double read FValue write FValue;
  end;

constructor TWeight.Create(AValue: Double; AConv: TConvType);
begin
  FValue := AValue;
  FConv := AConv;
end;

class operator TWeight.Implicit(A: TWeight): TGramm;
begin
  Result := Convert(A.Value, A.Conv, muGrams);
end;

class operator TWeight.Implicit(A: TGramm): TWeight;
begin
  Result := TWeight.Create(A, muGrams);
end;

class operator TWeight.Implicit(A: TWeight): TKilogramm;
begin
  Result := Convert(A.Value, A.Conv, muKilograms);
end;

class operator TWeight.Implicit(A: TKiloGramm): TWeight;
begin
  Result := TWeight.Create(A, muKilograms);
end;

Natürlich kannst du dir auch selbst deine Einheiten und Konvertierungen erstellen, aber es gibt halt mit den oben genannten Units schon einen vorgefertigten Mechanismus dafür.

Das Konvertieren geht dann über ein Cast auf TWeight:

Delphi-Quellcode:

procedure TuWas(const Value: TGramm); overload;
var
  K: TKiloGramm;
begin
  K := TWeight(Value);
  Writeln(Format('%1.3f g = %1.3f Kg', [Value, K]));
end;

procedure TuWas(const Value: TKiloGramm); overload;
var
  K: TGramm;
begin
  K := TWeight(Value);
  Writeln(Format('%1.3f Kg = %1.3f g', [Value, K]));
end;

Delphi-Quellcode:

var
  A: TKiloGramm;
  B: TGramm;
  C: TTonnen;
begin
  A := 50;
  B := 1500;
  TuWas(A);
  TuWas(B);
  TuWas(C);  // Fehlermeldung: Doppeldeutiger überladener Aufruf von 'TuWas'
end;

[Ghostwalker]

@Schokohase

Und wie stellst du sicher, das an Tuwas keine Tonnen übergeben werden, weil z.B. kein Preis dafür definiert ist ?

@Uwe

Naja...im Prinzip ists das gleiche, wenn ich alles in einen Typen reinschiebe. Außer das ich alles in einem Typen hab (der verdammt groß wird) hätte ich nicht wirklich was gewonnen. Die ganze Operator-Kombinationen müsst ich ja genauso implementieren und entsprechend testen.

[Schokohase]

Zitat:

Zitat von Ghostwalker (Beitrag 1415494)

@Schokohase

Und wie stellst du sicher, das an Tuwas keine Tonnen übergeben werden, weil z.B. kein Preis dafür definiert ist ?

Ähm, du hast das Beispiel falsch verstanden. Da gibt es etwas, da kostet das Kilogramm 20 Euro. Und da gibt es etwas anderes da kostet das Gramm 30 Euro.

Wenn du davon 3 Trillionen Tonnen haben möchtest, dann lasse ich mir über den Typen das Gewicht in Kilogram geben und multipliziere das mit den 20 Euro oder ich lasse mir das über den Typen in Gramm geben und multipilziere das mit den 30 Euro (je nachdem).

[Ghostwalker]

Ich glaub ich hab dich da schon richtig verstanden. Klar kann ich das umrechnen (von T in kg oder g). Wenn es aber keine T gibt (aus welchen Gründen auch immer), dann kann das Tuwas nicht unterscheiden.

[Medium]

Ich würde sagen, dass dann die Unterscheidung nicht mehr im Verantwortungsbereich von TuWas() liegt, sondern bereits vorher erledigt werden muss. Nämlich direkt nach der Eingabe in der Glue-Logic des Forms, weil das der einzige Zeitpunkt sein sollte, zu dem diese Unterscheidung Sinn ergibt. Vor allem weil ja vermutlich erst über die Beschriftung im Formular deutlich wird welche Einheit letztlich eingegeben wird. Die Geschäftslogik sollte das nicht mehr interessieren dürfen. Das wäre so meine Interpretation zumindest.

[bernau]

Zitat:

Zitat von Ghostwalker (Beitrag 1415503)

Wenn es aber keine T gibt (aus welchen Gründen auch immer), dann kann das Tuwas nicht unterscheiden.

Ich glaube wir tappen hier etwas im Dunkeln. Grundsätzlich ist es so, wenn es etwas in kg gibt, dann gibt es das auch in Tonnen. Es kann ja nicht sein, dass es von einem Artikel 100kg gibt, aber nicht 0,1Tonnen.

Ist es vielleicht so, dass es unterschiedliche Preise für kg und Tonnen gibt und du musst deshalb eine Unterscheidung machen. :glaskugel:

Hat irgendwie etwas von dem XY-Problem was Stevie in einem anderen Beitrag mal angesprochen hatte.

[Schokohase]

Zitat:

Zitat von Ghostwalker (Beitrag 1415503)

Ich glaub ich hab dich da schon richtig verstanden. Klar kann ich das umrechnen (von T in kg oder g). Wenn es aber keine T gibt (aus welchen Gründen auch immer), dann kann das Tuwas nicht unterscheiden.

Ich frage dich genau nach diesen Gründen - warum sollte das so sein - denn nur wenn es dazu eine vernünftige Begründung gibt, dann lohnt es sich auch darüber nachzudenken, warum man etwas auseinanderreißt, was eigentlich zusammengehört.

Ansonsten nimmt man einen Typen für eine Einhait, dieser speichert den Wert so wie der als SI Einheit definiert ist (Gewicht-> Kilogramm, Länge->Meter, Temeraturdifferenz->Kelvin, usw.) und schafft sich einfache Zugriffsmöglichkeiten um diese dann beliebig umzurechnen.

Also

Delphi-Quellcode:

TWeight.FromTons(1).Grams

ergibt dann die Zahl 1000000.