Différence entre décimal, float et double in.NET Je ne sais pas.

est la principale différence.

Float - 7 chiffres (32 bits)

Double - 15-16 chiffres (64 bits)

décimal - 28-29 chiffres significatifs (128 bits)

ont une précision beaucoup plus élevée et sont habituellement utilisées dans des applications financières qui exigent un haut degré de précision. Les décimales sont beaucoup plus lentes (jusqu'à 20X dans certains essais) qu'un double / flotteur.

décimales et flotteurs / Doubles ne peuvent pas être comparés sans moulage, alors que les flotteurs et les Doubles le peuvent. Les décimales permettent aussi d'encoder ou de suivre les zéros.

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

résultat:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

la structure décimale est strictement axée sur les calculs financiers exigeant de l'exactitude, qui sont relativement peu tolérants à l'arrondissement. Les décimales ne conviennent pas aux applications scientifiques, cependant, pour plusieurs raisons:

• une certaine perte de précision est acceptable dans de nombreux calculs scientifiques en raison des limites pratiques du problème physique ou de l'artefact mesuré. Une perte de précision n'est pas acceptable en finance.
• décimal est beaucoup (beaucoup) plus lent que float et double pour la plupart des opérations, principalement parce que les opérations à virgule flottante sont faites en binaire, tandis que la substance décimale est faite en base 10 (c.-à-d. flottants et doubles sont traités par le matériel FPU, tels que MMX/SSE, tandis que les décimales sont calculées dans le logiciel).
• décimal a une gamme de valeur beaucoup plus petite que double, malgré le fait qu'il supporte plus de chiffres de précision. Par conséquent, décimal ne peut pas être utilisé pour représenter de nombreuses valeurs scientifiques.

pour plus d'information vous pouvez aller à la source de cette image:

http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/921a8ffc-9829-4145-bdc9-a96c1ec174a5

float 7 chiffres de précision

double a environ 15 chiffres de précision

decimal a environ 28 chiffres de précision

si vous avez besoin d'une meilleure précision, utilisez le double au lieu du flotteur. Dans les CPU modernes les deux types de données ont presque la même performance. Le seul avantage de l'aide du flotteur est qu'ils prennent moins d'espace. Ce n'est pratiquement important que si vous en avez beaucoup.

j'ai trouvé ce qui est intéressant. Ce Que Tout Informaticien Devrait Savoir Sur L'Arithmétique À Virgule Flottante

personne N'a mentionné que

Dans les paramètres par défaut, de Flotteurs (Système d'.Simple) et doubles(système.Double) ne sera jamais utiliser vérification du débordement en mode décimal (système.Décimal) toujours utiliser vérification du débordement.

je veux dire

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

lancers OverflowException .

mais pas ceux-ci:

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

&

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

Je ne vais pas répéter des tonnes de bonnes (et de mauvaises) informations déjà répondues dans d'autres réponses et commentaires, mais je vais répondre à votre question de suivi avec un tip:

quand quelqu'un utiliserait-il l'un d'eux?

utiliser décimal pour Compter valeurs

utiliser flotteur / double pour mesuré valeurs

Quelques exemples:

• de l'argent (nous ne compter l'argent ou de la mesure de l'argent?)

• "151900920 de la distance" (ne nous le comte de distance ou de mesurer la distance? * )

• scores (ne nous compter les scores ou de mesurer les scores?)

nous comptons toujours l'argent et ne devrions jamais le mesurer. Nous mesurons habituellement la distance. On compte souvent les scores.

* dans certains cas , ce que j'appellerais distance nominale , nous pourrions en effet vouloir "compter" la distance. Par exemple, il s'agit peut-être de signes de pays qui indiquent les distances par rapport aux villes, et nous savons que ces distances n'ont jamais plus d'un chiffre décimal (xxx.x km).

les types de variables décimales, doubles et flottantes sont différents de la façon dont ils stockent les valeurs. La précision est la principale différence lorsque le flotteur est un type de données à virgule flottante de précision simple (32 bits), le double est un type de données à virgule flottante de double précision (64 bits) et le décimal est un type de données à virgule flottante de 128 bits.

flotteur-32 bits (7 chiffres)

Double-64 bits (15-16 chiffres)

décimal-128 bit (28-29 chiffres significatifs)

la principale différence est les flotteurs et les Doubles sont des types binaires à virgule flottante et une décimale stockera la valeur comme un type à virgule flottante. Ainsi, les décimales ont une précision beaucoup plus élevée et sont généralement utilisées dans des applications de calcul monétaire (financier) ou scientifique qui exigent un haut degré de précision. Mais en termes de performances, les décimales sont plus lentes que les types double et float.

décimal peut représenter 100% avec précision nombre dans la précision du format décimal, tandis que flottant et Double, ne peut pas représenter avec précision tous les nombres, même les nombres qui sont dans leur précision de formats respectifs.

décimal

dans le cas d'applications financières, ou des calculs scientifiques, il est préférable d'utiliser des types décimaux parce qu'il vous donne un niveau élevé de précision et facile à éviter les erreurs d'arrondissement

Double

sont probablement les types de données les plus couramment utilisés pour les valeurs réelles, à l'exception du traitement de l'argent.

Float

il est utilisé principalement dans les bibliothèques graphiques parce que les demandes très élevées de pouvoir de traitement, également utilisé des situations qui peuvent endurer des erreurs d'arrondissement.

1. Double et float peuvent être divisés par entier zéro sans exception à la fois la compilation et le temps d'exécution.
2. décimal ne peut pas être divisé par zéro entier. La Compilation échouera toujours, si vous faites cela.

entiers, comme a été mentionné, sont des nombres entiers. Ils ne peuvent pas stocker le point quelque chose, comme .7, de .42, et .007. Si vous avez besoin de stocker des nombres qui ne sont pas des nombres entiers, vous avez besoin d'un type différent de variable. Vous pouvez utiliser le type double ou le type float. Vous définissez ces types de variables jusqu'exactement de la même manière: au lieu d'utiliser le mot int , vous tapez double ou float . Comme ceci:

float myFloat;
double myDouble;

( float est l'abréviation de "floating point", et signifie Juste un nombre avec un point quelque chose au bout.)

La différence entre les deux réside dans la taille des nombres qu'ils peuvent tenir. Pour float , vous pouvez avoir jusqu'à 7 chiffres de votre numéro. Pour double s, vous pouvez avoir jusqu'à 16 chiffres. Pour être plus précis, voici la taille officielle:

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

float est un nombre 32 bits, et double est un nombre 64 bits.

Double cliquez sur votre nouveau bouton pour obtenir le code. Ajouter les trois lignes suivantes à votre bouton:

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

arrêtez votre programme et retournez à la fenêtre de codage. Changez cette ligne:

myDouble = 0.007;
myDouble = 12345678.1234567;

lancez votre programme et cliquez sur votre double bouton. La boîte de message affiche correctement le nombre. Ajoutez un autre nombre à la fin, cependant, et C# va de nouveau arrondir vers le haut ou vers le bas. La morale est que si vous voulez de la précision, faites attention à arrondir!

cela a été un fil intéressant pour moi, comme aujourd'hui, nous venons d'avoir un petit bug méchant, concernant decimal ayant moins de précision qu'un float .

dans notre code C#, Nous sommes en train de lire des valeurs numériques à partir D'une feuille de calcul Excel, les convertissant en un decimal , puis en envoyant ce decimal de nouveau à un Service pour enregistrer dans une base de données SQL Server .

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

maintenant, pour presque tous de nos valeurs Excel, cela a fonctionné magnifiquement. Mais pour certains, de très petites valeurs Excel, en utilisant decimal.TryParse perdu la valeur complètement. Un tel exemple est

• cellValue = 0.00006317592

• décimal.TryParse (cellValue.ToString(), valeur); // retourne 0

la solution, curieusement, était de convertir les valeurs Excel en un double d'abord, puis en un 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;
    …
}

même si double a moins de précision qu'un decimal , cela a réellement assuré que de petits nombres seraient encore reconnus. Pour une raison quelconque, double.TryParse decimal.TryParse les mettrait à zéro.

Impair. Très bizarre.

flotteur ~ ± 1,5 x 10-45 à ±3,4 x 1038 --------7 figures

double ~ ±5,0 x 10-324 à ± 1,7 x 10308 ------15 ou 16 chiffres

décimal ~ ±1,0 x 10-28 à ±7,9 x 1028 --------28 ou 29 chiffres

pour les applications telles que les jeux et les systèmes embarqués où la mémoire et la performance sont à la fois critiques, float est généralement le type numérique de choix car il est plus rapide et la moitié de la taille d'un double. Les entiers étaient l'arme de choix, mais les performances en virgule flottante ont dépassé les entiers dans les processeurs modernes. La décimale est sortie!

les types de variables décimales, doubles et flottantes sont différents de la façon dont ils stockent les valeurs. La précision est la principale différence lorsque le flotteur est un type de données à virgule flottante de précision simple (32 bits), le double est un type de données à virgule flottante de double précision (64 bits) et le décimal est un type de données à virgule flottante de 128 bits.

flotteur-32 bits (7 chiffres)

Double-64 bits (15-16 chiffres)

décimal-128 bit (28-29 chiffres significatifs)

plus d'information... différence entre décimal, Float et Double

Le problème avec tous ces types est qu'une certaine imprécision subsiste ET que ce problème peut se produire avec de petits nombres décimaux comme dans l'exemple suivant

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

Question: quelle valeur contient la variable bLower?

réponse: sur un ventilateur de machine 32 bits contient vrai !!!

si je remplace Double par décimal, bLower contient FALSE qui est la bonne réponse.

en double, le problème est que fMean-fDelta = 1.099999999 qui est inférieur à 1.1.

attention: je pense que le même problème peut certainement exister pour un autre nombre parce que décimal est seulement un double avec une plus grande précision et la précision a toujours une limite.

en fait, Double, flottant et décimal correspondent à décimal binaire en COBOL !

il est regrettable que D'autres types numériques mis en œuvre dans COBOL n'existent pas .Net. Pour ceux qui Je ne sais pas COBOL, il existe en COBOL suivant le type numérique

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) 

en termes simples:

1. les types de variables décimales, doubles et flottantes diffèrent de la façon dont elles emmagasinent les valeurs.
2. précision différence principale (notez Qu'il ne s'agit pas de la seule différence) où float est une précision simple (32 bits) type de données à virgule flottante, double est une double précision (64 bits)) de données à virgule flottante et de type décimal est une virgule flottante 128 bits type de données.
3. Le tableau de synthèse:

/==========================================================================================
    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)
/==========================================================================================

la principale différence entre ces deux méthodes est la précision.

float est un nombre 32-bit , double est un nombre 64-bit et decimal est un nombre 128-bit .

vous pouvez également consulter la documentation ici:

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/decimal

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/float

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/double