Float-Literale sind unumstößlich Extended?

[Der schöne Günther]

Delphi-Quellcode:

const someConstant = 3.14

ist kein Single, kein Double, sondern Extended. Da kann ich nichts dran machen, richtig? Keine Compilerschalter, nichts?

http://docwiki.embarcadero.com/RADSt...True_Constants

Zitat:

if constantExpression is a real, its type is Extended.

[Rollo62]

Probier mal so

Delphi-Quellcode:

Const
    kFeetToMeter: Double = 3.2808;

[Der schöne Günther]

Ja, ich weiß dass ich Konstanten typisieren kann, aber ich meinte wirklich wenn im Quelltext einfach

Delphi-Quellcode:

3.14

steht. Ich weiß dass ich auch

Delphi-Quellcode:

Single(3.14)

schreiben könnte, aber es wäre natürlich schön wenn ich da herum käme...

[Uwe Raabe]

Woher soll der Compiler denn wissen, welche Genauigkeit du haben willst, wenn du es ihm nicht sagst?

[Stevie]

Irgendwie schon komisch, dass das ansonsten so typenvernarrte Pascal bei Konstanten son untypisierten Blödsinn zulässt :gruebel:

[Uwe Raabe]

Zitat:

if constantExpression is a real, its type is Extended.

Diese Aussage ist falsch! Ich vermute, eine Float-Konstante ist ein Double, wenn sich die textuelle Darstellung exakt als Double darstellen lässt. Andernfalls ist es ein Extended. Außer bei 64-Bit, dann ist es immer ein Double.

Die Zahl 3.14 lässt sich zufälligerweise exakt als Double darstellen. Prüf mal

Delphi-Quellcode:

Sizeof(someConstant)

.

[Uwe Raabe]

Zitat:

Zitat von Stevie (Beitrag 1455650)

Irgendwie schon komisch, dass das ansonsten so typenvernarrte Pascal bei Konstanten son untypisierten Blödsinn zulässt :gruebel:

Als Wirth Pascal 1974 erfand, konnte ein Zielsystem allenfalls eine Float-Darstellung - da hatte man keine Wahl. Die IEEE 754 ist von 1985.

[himitsu]

Per se ist das erstmal garkein bestimmter Typ, denn dieser "Wert" wird an den Stellen eingesetzt (ähnlich einem Makro), wo er verwendet wird, und dort entscheidet sich dann jeweils der Typ, anhand dessen wo er zugewiesen wird.
Im Zweifelsfall ist es aber natürlich der größere Typ.

Die typisierten Konstanten sind "schreibgeschützte" Variablen, wo am Verwendungsort ein Zeiger darauf eingesetzt wird.

Delphi-Quellcode:

const
  kFeetToMeter = 3.2808;          // echte Konstante
  kFeetToMeter = Double(3.2808);  // echte Konstante mit Vorgabe, kann am Verwendungsort sich aber noch ändern
  kFeetToMeter: Double = 3.2808;  // typisierte Konstante

[Der schöne Günther]

Sorry, aber ich stimme euch nicht zu.

Erstens:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

procedure acceptFloat(const input: Single) overload; deprecated 'Single';
begin
   //
end;

procedure acceptFloat(const input: Double) overload; deprecated 'Double';
begin

end;

procedure acceptFloat(const input: Extended) overload; deprecated 'Extended';
begin

end;

begin
   acceptFloat(3.14);
end.

Hier wird definitiv die Extended-Version aufgerufen.


Und zweitens: Wenn ich den Mauszeiger auf eine untypisierte Float-Konstante halte bekomme ich einen Tooltip der glasklar "Extended" sagt: Anhang 52023


Edit: Aber

Delphi-Quellcode:

SizeOf(myConst)

sagt tatsächlich 8, obwohl definitiv die Extended-Überladung aufgerufen wird. Jetzt bin ich noch verwirrter als vorher.

[TiGü]

Zitat:

Zitat von Der schöne Günther (Beitrag 1455684)

Edit: Aber

Delphi-Quellcode:

SizeOf(myConst)

sagt tatsächlich 8, obwohl definitiv die Extended-Überladung aufgerufen wird. Jetzt bin ich noch verwirrter als vorher.

32- oder 64-Bit?

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

Zitat von himitsu (Beitrag 1455673)

Delphi-Quellcode:

const
  kFeetToMeter = Double(3.2808);

[Uwe Raabe]

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

[himitsu]

Zitat:

Zitat von Uwe Raabe (Beitrag 1455694)

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

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:

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:

Zitat von himitsu (Beitrag 1455697)

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:

Zitat von Der schöne Günther (Beitrag 1455699)

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 :zwinker:

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