Unterschied zwischen Dezimal, Float und Double in .NET?

Was ist der Unterschied zwischen decimal, floatund doublein .NET?

Wann würde jemand eines davon verwenden?

floatund doublesind schwimmend binäre Punkttypen . Mit anderen Worten, sie repräsentieren eine Zahl wie diese:

10001.10010110011

Die Binärzahl und die Position des Binärpunkts werden beide innerhalb des Werts codiert.

decimalist ein schwimmender dezimaler Punkt - Typ . Mit anderen Worten, sie repräsentieren eine Zahl wie diese:

12345.65789

Auch hier werden sowohl die Zahl als auch die Position des Dezimalpunkts innerhalb des Werts codiert - das macht decimalimmer noch einen Gleitkommatyp anstelle eines Festpunkttyps aus.

Es ist wichtig zu beachten, dass Menschen es gewohnt sind, Nicht-Ganzzahlen in Dezimalform darzustellen und genaue Ergebnisse in Dezimaldarstellungen zu erwarten. Nicht alle Dezimalzahlen können im binären Gleitkomma genau dargestellt werden (z. B. 0,1). Wenn Sie also einen binären Gleitkommawert verwenden, erhalten Sie tatsächlich eine Annäherung an 0,1. Sie erhalten auch weiterhin Annäherungen, wenn Sie einen Gleitkommapunkt verwenden - das Ergebnis der Division von 1 durch 3 kann beispielsweise nicht genau dargestellt werden.

Was ist zu verwenden, wenn:

• Für Werte, die "natürlich exakte Dezimalstellen" sind, ist es gut zu verwenden decimal. Dies ist normalerweise für alle vom Menschen erfundenen Konzepte geeignet: Finanzielle Werte sind das offensichtlichste Beispiel, aber es gibt auch andere. Betrachten Sie zum Beispiel die Punktzahl für Taucher oder Eisläufer.

• Für Werte , die mehr Artefakte der Natur sind , die nicht wirklich gemessen werden kann , genau wie auch immer, float/ doublesind besser geeignet. Beispielsweise würden wissenschaftliche Daten normalerweise in dieser Form dargestellt. Hier sind die ursprünglichen Werte zunächst nicht "dezimal genau", daher ist es für die erwarteten Ergebnisse nicht wichtig, die "dezimale Genauigkeit" beizubehalten. Gleitende Binärpunkttypen sind viel schneller zu verarbeiten als Dezimalstellen.

Präzision ist der Hauptunterschied.

Float - 7 Stellen (32 Bit)

Doppelte -15-16 Stellen (64 Bit)

Dezimal -28-29 signifikante Stellen (128 Bit)

Dezimalstellen haben eine viel höhere Präzision und werden normalerweise in Finanzanwendungen verwendet, die ein hohes Maß an Genauigkeit erfordern. Dezimalstellen sind viel langsamer (in einigen Tests bis zu 20-mal) als ein Double / Float.

Dezimalstellen und Floats / Doubles können nicht ohne Besetzung verglichen werden, während Floats und Doubles dies können. Dezimalstellen ermöglichen auch die Codierung oder nachgestellten Nullen.

float flt = 1F/3;
double dbl = 1D/3;
decimal dcm = 1M/3;
Console.WriteLine("float: {0} double: {1} decimal: {2}", flt, dbl, dcm);

Ergebnis:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

Die Dezimalstruktur ist streng auf finanzielle Berechnungen ausgerichtet, die Genauigkeit erfordern und die Rundungen relativ unverträglich sind. Dezimalstellen sind für wissenschaftliche Anwendungen jedoch aus mehreren Gründen nicht ausreichend:

• Ein gewisser Genauigkeitsverlust ist in vielen wissenschaftlichen Berechnungen aufgrund der praktischen Grenzen des gemessenen physikalischen Problems oder Artefakts akzeptabel. Präzisionsverlust ist im Finanzbereich nicht akzeptabel.
• Dezimal ist für die meisten Operationen viel (viel) langsamer als Float und Double, hauptsächlich weil Gleitkommaoperationen in Binärform ausgeführt werden, während Dezimalzahlen in Basis 10 ausgeführt werden (dh Floats und Doubles werden von der FPU-Hardware wie MMX / SSE verarbeitet während Dezimalstellen in Software berechnet werden).
• Dezimal hat einen unannehmbar kleineren Wertebereich als doppelt, obwohl mehr Genauigkeitsziffern unterstützt werden. Daher kann Dezimal nicht verwendet werden, um viele wissenschaftliche Werte darzustellen.

+---------+----------------+---------+----------+---------------------------------------------+
| C#      | .Net Framework | Signed? | Bytes    | Possible Values                             |
| Type    | (System) type  |         | Occupied |                                             |
+---------+----------------+---------+----------+---------------------------------------------+
| sbyte   | System.Sbyte   | Yes     | 1        | -128 to 127                                 |
| short   | System.Int16   | Yes     | 2        | -32768 to 32767                             |
| int     | System.Int32   | Yes     | 4        | -2147483648 to 2147483647                   |
| long    | System.Int64   | Yes     | 8        | -9223372036854775808 to 9223372036854775807 |
| byte    | System.Byte    | No      | 1        | 0 to 255                                    |
| ushort  | System.Uint16  | No      | 2        | 0 to 65535                                  |
| uint    | System.UInt32  | No      | 4        | 0 to 4294967295                             |
| ulong   | System.Uint64  | No      | 8        | 0 to 18446744073709551615                   |
| float   | System.Single  | Yes     | 4        | Approximately ±1.5 x 10-45 to ±3.4 x 1038   |
|         |                |         |          |  with 7 significant figures                 |
| double  | System.Double  | Yes     | 8        | Approximately ±5.0 x 10-324 to ±1.7 x 10308 |
|         |                |         |          |  with 15 or 16 significant figures          |
| decimal | System.Decimal | Yes     | 12       | Approximately ±1.0 x 10-28 to ±7.9 x 1028   |
|         |                |         |          |  with 28 or 29 significant figures          |
| char    | System.Char    | N/A     | 2        | Any Unicode character (16 bit)              |
| bool    | System.Boolean | N/A     | 1 / 2    | true or false                               |
+---------+----------------+---------+----------+---------------------------------------------+

Weitere Informationen finden Sie hier .

Ich werde nicht viele gute (und einige schlechte) Informationen wiederholen, die bereits in anderen Antworten und Kommentaren beantwortet wurden, aber ich werde Ihre Folgefrage mit einem Tipp beantworten:

Wann würde jemand eines davon verwenden?

Verwenden Sie für gezählte Werte eine Dezimalzahl

Verwendung float / double für Messwerte

Einige Beispiele:

• Geld (zählen wir Geld oder messen wir Geld?)

• Entfernung (zählen wir die Entfernung oder messen wir die Entfernung? *)

• Scores (zählen wir Scores oder messen wir Scores?)

Wir zählen immer Geld und sollten es niemals messen. Wir messen normalerweise die Entfernung. Wir zählen oft Punkte.

* In einigen Fällen, was ich als nominelle Entfernung bezeichnen würde , möchten wir möglicherweise tatsächlich die Entfernung "zählen". Vielleicht haben wir es mit Länderzeichen zu tun, die Entfernungen zu Städten anzeigen, und wir wissen, dass diese Entfernungen niemals mehr als eine Dezimalstelle (xxx.x km) haben.

float 7 Stellen Genauigkeit

double hat ungefähr 15 Stellen Genauigkeit

decimal hat ungefähr 28 Stellen Genauigkeit

Wenn Sie eine bessere Genauigkeit benötigen, verwenden Sie double anstelle von float. In modernen CPUs haben beide Datentypen fast die gleiche Leistung. Der einzige Vorteil der Verwendung von Float ist, dass sie weniger Platz beanspruchen. Praktisch nur wichtig, wenn Sie viele davon haben.

Ich fand das interessant. Was jeder Informatiker über Gleitkomma-Arithmetik wissen sollte

Niemand hat das erwähnt

In den Standardeinstellungen verwenden Floats (System.Single) und Doubles (System.Double) niemals die Überlaufprüfung, während Decimal (System.Decimal) immer die Überlaufprüfung verwendet.

ich meine

decimal myNumber = decimal.MaxValue;
myNumber += 1;

löst eine OverflowException aus .

Aber diese nicht:

float myNumber = float.MaxValue;
myNumber += 1;

&

double myNumber = double.MaxValue;
myNumber += 1;

1. Double und Float können sowohl bei der Kompilierung als auch zur Laufzeit ausnahmslos durch die Ganzzahl Null geteilt werden.
2. Dezimal kann nicht durch Ganzzahl Null geteilt werden. Die Kompilierung schlägt immer fehl, wenn Sie dies tun.

Ganzzahlen sind, wie erwähnt, ganze Zahlen. Sie können den Punkt nicht wie .7, .42 und .007 speichern. Wenn Sie Zahlen speichern müssen, die keine ganzen Zahlen sind, benötigen Sie einen anderen Variablentyp. Sie können den Double-Typ oder den Float-Typ verwenden. Sie richten diese Variablentypen genauso ein: Anstatt das Wort zu verwenden int, geben Sie doubleoder ein float. So was:

float myFloat;
double myDouble;

( floatsteht für "Gleitkomma" und bedeutet nur eine Zahl mit einem Punkt am Ende.)

Der Unterschied zwischen den beiden liegt in der Größe der Zahlen, die sie halten können. Für floatSie können bis zu 7 Ziffern in Ihrer Nummer haben. Für doubles können Sie bis zu 16 Ziffern haben. Um genauer zu sein, hier ist die offizielle Größe:

float:  1.5 × 10^-45  to 3.4 × 10^38  
double: 5.0 × 10^-324 to 1.7 × 10^308

floatist eine 32-Bit-Nummer und doubleeine 64-Bit-Nummer.

Doppelklicken Sie auf Ihre neue Schaltfläche, um zum Code zu gelangen. Fügen Sie Ihrem Schaltflächencode die folgenden drei Zeilen hinzu:

double myDouble;
myDouble = 0.007;
MessageBox.Show(myDouble.ToString());

Halten Sie Ihr Programm an und kehren Sie zum Codierungsfenster zurück. Ändern Sie diese Zeile:

myDouble = 0.007;
myDouble = 12345678.1234567;

Führen Sie Ihr Programm aus und klicken Sie auf die Doppelschaltfläche. Das Meldungsfeld zeigt die Nummer korrekt an. Fügen Sie am Ende jedoch eine weitere Zahl hinzu, und C # wird erneut aufgerundet. Die Moral ist, wenn Sie Genauigkeit wollen, achten Sie auf Rundungen!

• float: ± 1,5 x 10 ^ -45 bis ± 3,4 x 10 ^ 38 (~ 7 signifikante Zahlen
• doppelt: ± 5,0 x 10 ^ -324 bis ± 1,7 x 10 ^ 308 (15-16 signifikante Zahlen)
• dezimal: ± 1,0 x 10 ^ -28 bis ± 7,9 x 10 ^ 28 (28-29 signifikante Zahlen)

Dies war ein interessanter Thread für mich, da wir heute gerade einen bösen kleinen Fehler hatten, decimalweil wir weniger Präzision als a hattenfloat .

In unserem C # -Code lesen wir numerische Werte aus einer Excel-Tabelle, konvertieren sie in eine decimalund senden sie decimaldann an einen Dienst zurück, um sie in einer SQL Server- Datenbank zu speichern.

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    decimal value = 0;
    Decimal.TryParse(cellValue.ToString(), out value);
}

Für fast alle unsere Excel-Werte hat dies wunderbar funktioniert. Bei einigen sehr kleinen Excel-Werten decimal.TryParseging der Wert jedoch vollständig verloren. Ein solches Beispiel ist

• cellValue = 0,00006317592

• Decimal.TryParse (cellValue.ToString (), out value); // würde 0 zurückgeben

Seltsamerweise bestand die Lösung darin, die Excel-Werte zuerst in eine doubleund dann in eine zu konvertieren decimal:

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    double valueDouble = 0;
    double.TryParse(cellValue.ToString(), out valueDouble);
    decimal value = (decimal) valueDouble;
    …
}

Obwohl doublees weniger präzise als a ist decimal, stellte dies tatsächlich sicher, dass kleine Zahlen immer noch erkannt werden. Aus irgendeinem Grund double.TryParsewar es tatsächlich möglich, so kleine Zahlen abzurufen, während decimal.TryParsesie auf Null gesetzt würden.

Seltsam. Sehr komisch.

Für Anwendungen wie Spiele und eingebettete Systeme, bei denen sowohl Speicher als auch Leistung von entscheidender Bedeutung sind, ist Float normalerweise der numerische Typ der Wahl, da es schneller und halb so groß wie ein Double ist. Früher waren Ganzzahlen die Waffe der Wahl, aber die Gleitkomma-Leistung hat die Ganzzahl in modernen Prozessoren überholt. Dezimal ist richtig!

Die Variablentypen Decimal, Double und Float unterscheiden sich in der Art und Weise, wie sie die Werte speichern. Die Genauigkeit ist der Hauptunterschied, bei dem Gleitkomma ein Gleitkomma-Datentyp mit einfacher Genauigkeit (32 Bit) ist, double ein Gleitkomma-Datentyp mit doppelter Genauigkeit (64 Bit) und decimal ein 128-Bit-Gleitkomma-Datentyp.

Float - 32 Bit (7 Stellen)

Double - 64 Bit (15-16 Stellen)

Dezimal - 128 Bit (28-29 signifikante Stellen)

Mehr über ... den Unterschied zwischen Decimal, Float und Double

Das Problem bei all diesen Typen ist, dass eine bestimmte Ungenauigkeit besteht UND dass dieses Problem bei kleinen Dezimalzahlen wie im folgenden Beispiel auftreten kann

Dim fMean as Double = 1.18
Dim fDelta as Double = 0.08
Dim fLimit as Double = 1.1

If fMean - fDelta < fLimit Then
    bLower = True
Else
    bLower = False
End If

Frage: Welchen Wert enthält die Variable bLower?

Antwort: Auf einer 32-Bit-Maschine enthält bLower TRUE !!!

Wenn ich Double durch Decimal ersetze, enthält bLower FALSE, was die gute Antwort ist.

Im doppelten Fall besteht das Problem darin, dass fMean-fDelta = 1.09999999999 ist, was niedriger als 1.1 ist.

Achtung: Ich denke, dass das gleiche Problem sicherlich für andere Zahlen bestehen kann, da Dezimal nur ein Doppel mit höherer Genauigkeit ist und die Genauigkeit immer eine Grenze hat.

Tatsächlich entsprechen Double, Float und Decimal der BINARY-Dezimalstelle in COBOL!

Es ist bedauerlich, dass andere in COBOL implementierte numerische Typen in .Net nicht vorhanden sind. Für diejenigen, die COBOL nicht kennen, gibt es in COBOL folgenden numerischen Typ

BINARY or COMP like float or double or decimal
PACKED-DECIMAL or COMP-3 (2 digit in 1 byte)
ZONED-DECIMAL (1 digit in 1 byte) 

In einfachen Worten:

1. Die Variablentypen Decimal, Double und Float unterscheiden sich in der Art und Weise, wie sie die Werte speichern.
2. Präzision ist der Hauptunterschied (Beachten Sie, dass dies nicht der einfache Unterschied ist), wobei float ein Gleitkomma-Datentyp mit einfacher Genauigkeit (32 Bit) ist, double ein Gleitkomma-Datentyp mit doppelter Genauigkeit (64 Bit) und dezimal ein 128-Bit- ist Gleitkomma-Datentyp.
3. Die Übersichtstabelle:

/==========================================================================================
    Type       Bits    Have up to                   Approximate Range 
/==========================================================================================
    float      32      7 digits                     -3.4 × 10 ^ (38)   to +3.4 × 10 ^ (38)
    double     64      15-16 digits                 ±5.0 × 10 ^ (-324) to ±1.7 × 10 ^ (308)
    decimal    128     28-29 significant digits     ±7.9 x 10 ^ (28) or (1 to 10 ^ (28)
/==========================================================================================

Der Hauptunterschied zwischen diesen ist die Präzision.

floatist eine 32-bitZahl, doubleist eine 64-bitZahl und decimalist eine 128-bitZahl.

• Dezimalzahl 128 Bit (28-29 signifikante Stellen) Bei Finanzanwendungen ist es besser, Dezimaltypen zu verwenden, da dies ein hohes Maß an Genauigkeit bietet und Rundungsfehler leicht zu vermeiden sind. Verwenden Sie Dezimalstellen für nicht ganzzahlige Mathematik, wenn Präzision erforderlich ist (z Geld und Währung)

• Double 64 Bit (15-16 Stellen) Double Types sind wahrscheinlich der am häufigsten verwendete Datentyp für reale Werte, außer für den Umgang mit Geld. Verwenden Sie double für nicht ganzzahlige Mathematik, bei der die genaueste Antwort nicht erforderlich ist.

• Float 32 Bit (7 Stellen) Es wird hauptsächlich in Grafikbibliotheken verwendet, da sehr hohe Anforderungen an die Verarbeitungsleistung gestellt werden und auch Situationen verwendet werden, in denen Rundungsfehler auftreten können.

Decimalssind viel langsamer als ein double/float.

Decimalsund Floats/Doubleskann nicht ohne Besetzung verglichen werden, während Floatsund Doubleskann.

Decimals Erlauben Sie auch die Kodierung oder nachgestellten Nullen.

So definieren Sie Dezimal, Float und Double in .Net (c #)

Sie müssen Werte wie folgt angeben:

Decimal dec = 12M/6;
Double dbl = 11D/6;
float fl = 15F/6;

und überprüfen Sie die Ergebnisse.

Und die von jedem belegten Bytes sind

Float - 4
Double - 8
Decimal - 12