Float-Literale sind unumstößlich Extended?

[Stevie]

Delphi-Quellcode:

{$APPTYPE CONSOLE}

uses
  SysUtils,
  TypInfo;

type
  TypeHelper = record
    class function TypeOf<T>(const value: T): string; static;
  end;

class function TypeHelper.TypeOf<T>(const value: T): string;
begin
  Result := PTypeInfo(TypeInfo(T)).Name + ' kind: ' + GetEnumName(TypeInfo(TTypeKind), Ord(GetTypeKind(T))) + ' size: ' + SizeOf(T).ToString;
end;

const
  c = 3.14;
begin
  Writeln(TypeHelper.TypeOf(3.15));
  Writeln(TypeHelper.TypeOf(c));
  Readln;
end.

Außerdem kompiliert das hier nicht:

Zitat von himitsu:

Delphi-Quellcode:

const
  kFeetToMeter = Double(3.2808);

[Uwe Raabe]

Ist ja interessant! Woher kommt dann aber die 8 für Sizeof(c)?

[himitsu]

Zitat von Uwe Raabe:

Ist ja interessant! Woher kommt dann aber die 8 für Sizeof(c)?

Delphi-Quellcode:

const
  A = 1;
  B = 10000;
  C = $FFFFFFFF;
  D = Integer($FFFFFFFF);  // -1
  F = 0.5;
  G = 1.333333333;

procedure TForm1.FormCreate(Sender: TObject);
begin
  ShowMessage(Format('%d %d %d %d %d %d', [SizeOf(A), SizeOf(B), SizeOf(C), SizeOf(D), SizeOf(F), SizeOf(G)]));
  // 32 Bit: 1 2 4 4 8 10
  // GetTypeName(TypeInfo(F)) oder PTypeInfo(TypeInfo(F)).Name geht nicht
end;

Für untypisierte Konstanten nimmt Delphi meistens erstmal den kleinst möglichen Typen und wenn die spätere Verwendungsstelle keinen anderen Typen vorgibt, dann wird er dort so verwendet.
Bei Floats, wird aber eher oft auf das Größere gegangen, wegen eventueller Rundungsfehler.



Tja, rein theoretisch wäre SizeOf für untypisierte Konstanten nicht verwendbar und teilweise ist sowas auch nicht kompilierbar.


Ich würde eher empfehlen du vergisst Extended.
Single, Double und Currency sind die Typen für gebrochene Zahlen und davon ist Double der Größte. Kommt doch mal irgendwo ein Extended vor, dann ist es zumindestens kein Nachteil.

Offiziell war Extended nie als Speichertyp vorgesehen (nur für die Berechnungen innerhalb der CPU, bzw. für temporäre Variablen/Zwischenergebnisse des Compilers).
Bezütlich 64 Bit-Compilate und der CrossCompiler wurde das in Delphi nun angepasst.

Zitat von ein x87-Designer und die Intel Corporation:

The temporary real (extended) format was designed not to store data at higher precision as such, but rather primarily to allow for the computation of double results more reliably and accurately by minimising overflow and roundoff-errors in intermediate calculations

Drum ist der Typ in anderen höheren Programmiersprachen nicht verfügbar, bzw. wird selten als Variablentyp benutzt. ("long double" in C/C++)

[Der schöne Günther]

Zitat von himitsu:

Ich würde eher empfehlen du vergisst Extended.

Das würde ich ja so gerne. Nur nimmt der Delphi-Compiler für Überladungen ja immer Extended an wenn man eine Zahl schreibt. Das würde ich gerne auf z.B. Single oder Double ändern.

[himitsu]

Zitat von Der schöne Günther:

Nur nimmt der Delphi-Compiler für Überladungen ja immer Extended an wenn man eine Zahl schreibt.

Aber auch nur, weil du ihm diese Überladung anbietest

[Der schöne Günther]

Das Ganze ist trotzdem irgendwie ein Mysterium. 💫

[freimatz]

Nein.

[Sherlock]

Kurz und knapp, ich verstehe Dein Problem nicht: Du weißt, was passiert, Du weißt wie Du es vermeiden kannst, Du willst aber, das es automatisch geht. Korrekt zusammengefaßt?

Automatismen sind nur für die breite Masse und dienen der Vermeidung von Problemen, darum wird immer der Weg gewählt, der die geringsten Probleme erwarten läßt. Solltest Du hierbei ein Problem für die breite Masse sehen, erstell eben ein Ticket.

Sherlock

[Jost Riedel]

In dem Pascal, das Niklaus Wirth erfunden hat, und auch in den ersten Turbo-Pascal Versionen, war es ganz schlicht so: Eine Konstante war ein Platzhalter für ein Literal, wurde also erst ausgewertet bei Verwendung (wie ein Macro).

Bei Overloads klappt das nicht mehr - die werden nach Typ selektiert, also muß dort auch eine Heuristik für eine Typauswahl funktionieren. Und die funktioniert ganz gut. Wer eine feinere Kontrolle braucht: Da gibt es Möglichkeiten.