//Windows - MSCV 9
int   a = 2;
float b = 2.1;

double c = 0.01;      //-> a = 0.010000000000000000;
float  d = 0.01;      //-> b = 0.0099999998;
double e = (double)d; //-> c = 0.009999999776482582;

Wie man schön sieht steht etwas beliebiges in derm neu hinzugekommenen Genauigkeitsbereich. Ist das standardmäßig beliebig oder kann den compiler irgendwie dazu zwingen, mir "0 aufzufüllen"?

...
Wie man schön sieht steht etwas beliebiges in derm neu hinzugekommenen Genauigkeitsbereich. Ist das standardmäßig beliebig oder kann den compiler irgendwie dazu zwingen, mir "0 aufzufüllen"?

Nein. Das ist auch garnicht möglich.
Ist dir eigentlich bekannt das double sowie float nur Näherungsweise arbeiten?
(Daher sollte man auch niemals gegen einen double oder floatwert exakt prüfen, sondern immer mit einer "Nährung" arbeiten).

0.1 lässt sich z.B. nur Nährungsweise darstellen, da es mittels einer 2er Potenz (1,2,4,8,18... sowie 0.5, 0.25, 0.125...) nicht genau darstellbar ist.

cu André

ABER:

float  a = 0.1;
double b = 0.1;
bool erg = std::fabs( (double)a-b )>1.E-10;

//Windows + cl:
-> erg=false;
//Linux gcc
-> erg=true;

Jetzt einmal ungeachtet der Tatsache, dass immer den genaueren Tyoen auf den "ungenaueren" casten sollte bei einem solchen Vergleich, kommt eben compiler Abhängig etwas anderes heraus. Und daher wollte ich wissen, ob das VErhalten irgendwie definiert ist.

Lass dir doch mal auf den verschiedenen Compilern und Plattformen ein sizeof(float) und sizeof(double) ausgeben.

Gib einfach mal dein float mit der gleichen Anzahl an Nachkommastellen aus.

Da steht nicht irgendwas beliebiges im neu hinzugekommenen bereich, sondern das gleiche.

Gib einfach mal dein float mit der gleichen Anzahl an Nachkommastellen aus.

wenn dort das gleiche stehen würde, dann würde des eps-test in beiden fällen funktionieren

#include <iostream>

int main() {

   double a = 0.01;
   float  b = 0.01;
   double c = b;

   std::cout.setf(std::ios::fixed); 
   std::cout.precision(10);
   std::cout << "Precision 10 double:    " << a << std::endl;
   std::cout << "Precision 10 float:     " << b << std::endl;
   std::cout << "Precision 10 assigned:  " << c << std::endl;
   std::cout.precision(20);
   std::cout << "Precision 20 double:    " << a << std::endl;
   std::cout << "Precision 20 float:     " << b << std::endl;
   std::cout << "Precision 20 assigned:  " << c << std::endl;
}

Du siehst, dass die Zuweisung eines float zu einem double den Wert überhaupt nicht ändert (Zumindest auf gängigen Platformen). Das ist auch ganz klar. Die zusätzlichen Bits der Mantisse eines double werden mit Nullen aufgefüllt und Nullen verändern den Wert nicht.

Du siehst die unterschiedlichen Werte nur deshalb, weil du bei beiden Ausgaben nicht die gleiche Präzision verwendet hast.

Das ist übrigends die Ausgabe auf meinem Rechner:

ponto@burns:~/Savage2> ./a.out
Precision 10 double:    0.0100000000
Precision 10 float:     0.0099999998
Precision 10 assigned:  0.0099999998
Precision 20 double:    0.01000000000000000021
Precision 20 float:     0.00999999977648258209
Precision 20 assigned:  0.00999999977648258209

0.00999999977648258209228515625