Delphi-PRAXiS - Delphi Maßeinheiten als Typen

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Algorithmen, Datenstrukturen und Klassendesign (https://www.delphipraxis.net/78-algorithmen-datenstrukturen-und-klassendesign/)

- - Delphi Maßeinheiten als Typen (https://www.delphipraxis.net/198184-masseinheiten-als-typen.html)

AW: Maßeinheiten als Typen

@Schokohase

Mein Post bezog sich insbesondere auf diese Aussage:

Zitat:

Zitat von TiGü (Beitrag 1415578)

Du musst nur verstehen das Kilogramm, Gramm, Mikrogramm, Nanogramm K E I N E verschiedenen Maßeinheiten sind.

und die ist schlicht [Zensiert]. :)

Klar sind 1000g = 1Kg [B]ABER] 1000g <> 1000Kg <> 1000m <> 1000V

AW: Maßeinheiten als Typen

Zitat:

Zitat von Ghostwalker (Beitrag 1415622)

@Schokohase

Mein Post bezog sich insbesondere auf diese Aussage:

Zitat:

Zitat von TiGü (Beitrag 1415578)

Du musst nur verstehen das Kilogramm, Gramm, Mikrogramm, Nanogramm K E I N E verschiedenen Maßeinheiten sind.

und die ist schlicht [Zensiert]. :)

Klar sind 1000g = 1Kg [B]ABER] 1000g <> 1000Kg <> 1000m <> 1000V

Man könnte auch sagen [zensiert] = richtig! :roll:

Sowas wie 1000g <> 1000kg zog niemand in Zweifel, da 1000 g ungleich zu 1000000 g ist (bzw. 1 kg ungleich 1000 kg).
Du denkst - oder es kommt uns allen nur so vor - das die MaßEINHEIT Gramm und Kilogramm zwei verschiedene Paar Schuhe sind.
Das ist aber nicht so. Das eine Schuh-Paar ist nur "größer", aber sonst das selbe (!) Modell.

Einen gängigen Weg, wie man das mit Operatoren im Record erschlagen kann, hast du im Laufe der letzten Seiten vielfach aufgezeigt bekommen.

AW: Maßeinheiten als Typen

Zitat:

Zitat von TiGü (Beitrag 1415623)

Du denkst - oder es kommt uns allen nur so vor - das die MaßEINHEIT Gramm und Kilogramm zwei verschiedene Paar Schuhe sind.

Jain. Ich denke ich hab mich da ein wenig zu Umgangssprachlich ausgedrückt. :)

Die Maßeinheiten Gramm und Kilogramm bezeichnen letztlich ein Gewicht. Der Unterschied besteht hier nur in der Granulierung oder dem Faktor mit Bezug zu den anderen Einheiten bei Gewichten.

Und richtig, es wurde ein Beispiel für die Impelentierung mit einem Typen genannt.

Leider konnte mir bisher keiner Erläutern, wo der Vorteil liegt, wenn man das als ein Typ implementiert (gegenüber der Implementierung durch einzelne Typen; den seh ich nämlich irgendwie nicht wirklich).

AW: Maßeinheiten als Typen

Zitat:

Zitat von Ghostwalker (Beitrag 1415626)

Leider konnte mir bisher keiner Erläutern, wo der Vorteil liegt, wenn man das als ein Typ implementiert (gegenüber der Implementierung durch einzelne Typen; den seh ich nämlich irgendwie nicht wirklich).

Wahrscheinlich weil du nur dein reales Problem siehst (was nichts mit Gewicht zu tun hat?) und eine schlechte Analogie verwendest und uns hier mit dem Gewicht-Beispiel mental verhungern lässt?!

AW: Maßeinheiten als Typen

Zitat:

Zitat von Ghostwalker (Beitrag 1415626)

Na dann erstelle doch einfach deine 21 Typen (Centigram, Decagram, Decigram, Gram, Hectogram, Kilogram, Kilopound, Kilotonne, LongHundredweight, LongTon, Megapound, Megatonne, Microgram, Milligram, Nanogram, Ounce, Pound, ShortHundredweight, ShortTon, Stone, Tonne) oder sogar mehr, wenn da noch Bedarf besteht.

Ich nehme da nur einen und bin schon fertig. Warum wohl? Eben, weil es schneller geht und ich keinen Vorteil bei der Aufsplitung sehe.

AW: Maßeinheiten als Typen

Zitat:

Zitat von Ghostwalker (Beitrag 1415626)

Weil durch einzelne Typen jede Methode, die bspw. einen Gewichtsparameter hat, für jeden Typen für Gewicht überladen werden muss.
Einfaches Beispiel:

Delphi-Quellcode:

			procedure doSomething(weight: TTon);

procedure doSomething(weight: TTonne);

procedure doSomething(weight: TKilogram);

procedure doSomething(weight: TGram);

procedure doSomething(weight: TMilligram);

procedure doSomething(weight: TMicrogram);

procedure doSomething(weight: TPound);

procedure doSomething(weight: TStone);

procedure doSomething(weight: TSlug);

// Aufruf:

doSomething(100 as TStone);

Im Gegensatz zu

Delphi-Quellcode:

			procedure doSomething(weight: TWeight);

// Aufruf:

doSomething(TWeight.getStones(100));

Und das ganze wird schlimmer, wenn du Parameter kombinieren willst:

Delphi-Quellcode:

			function computeSpeed(distance: TYards; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TMeters; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TMillimeters; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TKilometers; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TInches; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TMiles; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TYards; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TMeters; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TMillimeters; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TKilometers; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TInches; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TMiles; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TYards; time: THours): TMeterPerSecond

function computeSpeed(distance: TMeters; time: THours): TMeterPerSecond

function computeSpeed(distance: TMillimeters; time: THours): TMeterPerSecond

function computeSpeed(distance: TKilometers; time: THours): TMeterPerSecond

function computeSpeed(distance: TInches; time: THours): TMeterPerSecond

function computeSpeed(distance: TMiles; time: THours): TMeterPerSecond

AW: Maßeinheiten als Typen

Eine Anregung von jenseits des Delphi-Tellerrands:
Es gibt für C++ eine Bibliothek, die Deine Aufgabenstellung (m.E. perfekt) aufgreift:

https://www.boost.org/doc/libs/1_37_...ost_units.html

Ich habe die selbst schon verwendet und finde den Ansatz sehr gut.

Vielleicht kannst Du daraus ein paar Anregungen mitnehmen und Dir etwas erstellen, was (natürlich) nicht so komplett ist, aber den Bedarf erfüllt.

AW: Maßeinheiten als Typen

Hmm. Zurück auf den Boden. Ich kenn das, was der TE will, zB aus dem Bereich von Rezepturen. Da hast du Zutaten, mache in GRAMM, manche in KILOGRAMM, vielleicht sogar manche in LITER.
Wenn man das Gesamtgewicht der Rezeptur wissen will, muss man addieren + da wäre es natürlich ganz cool wenn schon der Compiler dafür sorgt, dass GRAMM und KILOGRAMM von der richtigen Methode addiert würden.

Aber wie ich auch schon gesagt habe, scheint mir das zu umständlich und auch knapp daneben gezielt. Denn ich habe ja immer eine Kombination aus Wert+Einheit + so würde ich das auch meinen Methoden übergeben:
Addiere(120, 'KG', 12, 'GRAMM');
AddiereKGzuGRAMM(120,12); // da kann ich sogar Typsicherheit haben! type TKG = type Float;
ToGramm(TKG):TGRAMM; // wieder: Typsicher
ToGramm(TMG):TGRAMM; // wieder: Typsicher + overloaded

AW: Maßeinheiten als Typen

Zitat:

Zitat von TigerLilly (Beitrag 1415759)

Denn ich habe ja immer eine Kombination aus Wert+Einheit

Genau, es ist eine Kombination, die man z.B. auch so abbilden kann

Delphi-Quellcode:

			TMassUnit = (Undefined, Gram, Kilogram, Milligram, Tonne);

TMass = record

private

  FValue: Extended; // Wert

  FUnit: TMassUnit; // Einheit

public

  constructor Create(AValue: Extended; AUnit: TMassUnit);

  property Value: Extended read FValue;

  property &Unit: TMassUnit read FUnit;

private

  function AsBaseUnit(): Extended;

  function AsBaseNumericType(AUnit: TMassUnit);

public

  property Grams: Extended index TMassUnit.Gram read AsBaseNumericType;

  property Kilograms: Extended index TMassUnit.Kilogram read AsBaseNumericType;

  property Milligrams: Extended index TMassUnit.Milligram read AsBaseNumericType;

  property Tonnes: Extended index TMassUnit.Tonne read AsBaseNumericType;

end;

function TMass.AsBaseUnit(): Extended;

var

  x:Extended;

begin

  x := Value;

  case FUnit of

    TMass.Gram: Result := x / 1e3;

    TMass.Kilogram: Result := x;

    TMass.Milligram: Result := x / 1e6;

    TMass.Tonne: Result := x * 1e3;

  else

    raise ENotImplementedException.Create('Fehler');

  end;

end;

function TMass.AsBaseNumericType(AUnit: TMassUnit): Extended;

var

  x: Extended;

begin

  if (AUnit = FUnit)

    Exit(FValue);

  x := AsBaseUnit();

  case AUnit of

    TMass.Gram: Result := x * 1e3;

    TMass.Kilogram: Result := x;

    TMass.Milligram: Result := x * 1e6;

    TMass.Tonne: Result := x / 1e3;

  else

    raise ENotImplementedException.Create('Fehler');

  end;

end;

In diesem Record kann man jetzt problemlos die Rechenoperationen und Umrechnungen implementieren und man hat einen Typen für das Gewicht.

AW: Maßeinheiten als Typen

Zitat:

Zitat von Schokohase (Beitrag 1415761)

In diesem Record kann man jetzt problemlos die Rechenoperationen und Umrechnungen implementieren und man hat einen Typen für das Gewicht.

roter text, du hast mir meinen gedanken geklaut, wollte fast das gleich schreiben da der komplette thread letztendlich auf sowas hinaus läuft, bin ich jedenfalls auch der meinung.