Ich frage mich, was der Unterschied zwischen diesen beiden Variablen in C ist:
float price = 3.00;
und
float price = 3.00f;
Was ist die Verwendung von Suffix f
in diesem Fall?
c
floating-point
Alex
quelle
quelle
Antworten:
3.00
wird als a interpretiertdouble
, im Gegensatz dazu3.00f
wird dies vom Compiler als a angesehenfloat
.Das
f
Suffix teilt dem Compiler einfach mit, welches afloat
und welches a istdouble
.Siehe MSDN (C ++)
quelle
float price = 7.50 / 2.50;
gegenüber haben, kannfloat price = 7.50f / 2.50f;
das Ergebnis aufgrund der unterschiedlichen Auflösung abweichen. Im ersten Fall muss der Compiler die Berechnung durchführen unddouble
dann das Ergebnis in konvertierenfloat
. Im zweiten Fall erfolgt die Berechnung infloat
. Beachten Sie, dass wenn nur ein Wert ist,double
das Ganze als berechnet wirddouble
. Der C-Compiler darf dies nicht optimieren, da sich die Rundung unterscheiden würde. AlsofloatvarA = floatvarB / 2.0
schlechter abschneidet als mit2.0f
.Zusätzlich zu dem, was bereits gesagt wurde, ist es wichtiger, den Überblick über 1.0 gegenüber 1.0f zu behalten, als viele Menschen erkennen. Wenn Sie Code wie folgt schreiben:
float x; ... float y = x * 2.0;
Dann wird x zu einem Double befördert, da 2.0 ein Double ist. Der Compiler darf diese Heraufstufung nicht optimieren, da dies sonst gegen den C-Standard verstoßen würde. Die Berechnung erfolgt mit doppelter Genauigkeit, und das Ergebnis wird implizit in einen Float abgeschnitten. Dies bedeutet, dass die Berechnung langsamer (wenn auch genauer) ist als wenn Sie 2.0f oder 2 geschrieben hätten.
Wenn Sie 2 geschrieben hätten, wäre die Konstante vom Typ int, der zu einem Float heraufgestuft würde, und die Berechnung wäre mit "Float-Präzision" durchgeführt worden. Ein guter Compiler würde Sie vor dieser Aktion warnen.
Lesen Sie hier mehr über die Regeln für die "übliche arithmetische Konvertierung":
http://msdn.microsoft.com/en-us/library/3t4w2bkb%28v=vs.80%29.aspx
quelle
float y = x * 2.0;
. Tatsächlich generiert ein Compiler, der sein Geld wert ist, eine Multiplikation mit einfacher Genauigkeitfloat y = x * (double)0.1f;
, eine viel beeindruckendere Leistung (aber immer noch eine korrekte Optimierung).double
Multiplikation mit2.0
und nicht durchzuführen2.0f
. Compiler dürfen keine Optimierung verwenden, die das numerische Ergebnis ändern würde.(float)((double)float_x * (double)float_y) == float_x * float_y
eine Gleichheit, die der Compiler für diese Optimierung umgekehrt anwendet. Dies funktioniert, weil die Näherungen von 2 alsdouble
undfloat
identisch sind.Denn durch nicht angehängte Gleitkomma-Literale werden Doppelte verwendet, und Rundung bedeutet, dass selbst kleine Literale unterschiedliche Werte annehmen können, wenn sie auf Gleitkomma- und Doppelrundungen gerundet werden. Dies kann im folgenden Beispiel beobachtet werden:
float f=0.67; if(f == 0.67) printf("yes"); else printf("no");
Dies wird ausgegeben
no
, da0.67
es einen anderen Wert hat, wenn es auf Float gerundet wird, als wenn es auf Double gerundet wird. Auf der anderen Seite:float f=0.67; if(f == 0.67f) printf("yes"); else printf("no");
Ausgänge
yes
.Das Suffix kann entweder in Groß- oder Kleinbuchstaben angegeben werden.
Versuchen Sie dies auch:
printf(" %u %u\n", sizeof(.67f), sizeof(.67));
Überprüfen Sie @ Codepade
quelle
3.00 ist ein Double, 3.00f ist ein Float.
quelle
Dies liegt daran, dass der Standardtyp eines numerischen Gleitkomma-Literals - die Zeichen 3.00 sind doppelt und nicht float. Um dies zu kompilieren, müssen Sie das Suffix f (oder F) hinzufügen.
quelle
Hinzufügen einiger weiterer Kombinationen von Vergleichen zwischen Float- und Double-Datentypen.
int main() { // Double type constant(3.14) converts to Float type by // truncating it's bits representation float a = 3.14; // Problem: float type 'a' promotes to double type and the value // of 'a' depends on how many bits added to represent it. if(a == 3.14) std::cout<<"a: Equal"<<std::endl; else std::cout<<"a: Not Equal"<<std::endl; float b = 3.14f; // No type conversion if(b == 3.14) // Problem: Float to Double conversion std::cout<<"b: Equal"<<std::endl; else std::cout<<"b: Not Equal"<<std::endl; float c = 3.14; // Double to Float conversion (OK even though is not a good practice ) if(c == 3.14f) // No type conversion std::cout<<"c: Equal"<<std::endl; // OK else std::cout<<"c: Not Equal"<<std::endl; float d = 3.14f; if(d == 3.14f) std::cout<<"d: Equal"<<std::endl; // OK else std::cout<<"d: Not Equal"<<std::endl; return 0; }
Ausgabe:
quelle
Oft ist der Unterschied nicht wichtig, da der Compiler die Doppelkonstante ohnehin in einen Float umwandelt. Beachten Sie jedoch Folgendes:
template<class T> T min(T a, T b) { return (a < b) ? a : b; } float x = min(3.0f, 2.0f); // will compile x = min(3.0f, 2); // compiler cannot deduce T type x = min(3.0f, 2.0); // compiler cannot deduce T type
quelle