Diferença entre decimal, float e double no .net?


Respostas:


2267

floate doublesão tipos de pontos binários flutuantes . Em outras palavras, eles representam um número como este:

10001.10010110011

O número binário e a localização do ponto binário são ambos codificados no valor.

decimalé um tipo de ponto decimal flutuante . Em outras palavras, eles representam um número como este:

12345.65789

Novamente, o número e a localização do ponto decimal são codificados no valor - é o que torna decimalainda um tipo de ponto flutuante em vez de um tipo de ponto fixo.

O importante a ser observado é que os humanos estão acostumados a representar não-inteiros em uma forma decimal e esperam resultados exatos em representações decimais; nem todos os números decimais são exatamente representáveis ​​no ponto flutuante binário - 0,1, por exemplo -, portanto, se você usar um valor de ponto flutuante binário, obterá uma aproximação de 0,1. Você ainda obterá aproximações ao usar um ponto decimal flutuante - o resultado da divisão de 1 por 3 não pode ser exatamente representado, por exemplo.

Quanto ao que usar quando:

  • Para valores que são "decimais naturalmente exatos", é bom usar decimal. Isso geralmente é adequado para qualquer conceito inventado por humanos: os valores financeiros são o exemplo mais óbvio, mas também existem outros. Considere a pontuação atribuída a mergulhadores ou patinadores no gelo, por exemplo.

  • Para valores que são mais artefactos da natureza que não pode realmente ser medidos exatamente de qualquer maneira, float/ doublesão mais apropriadas. Por exemplo, dados científicos geralmente seriam representados neste formulário. Aqui, os valores originais não serão "decimais precisos" para começar, portanto, não é importante que os resultados esperados mantenham a "precisão decimal". Os tipos de ponto binário flutuante são muito mais rápidos do que os decimais.


58
float/ doubleGeralmente não representam números como 101.101110, normalmente ele é representado como algo como 1101010 * 2^(01010010)- um expoente
Mingwei Samuel

79
@Azzard: é isso que significa a parte "e a localização do ponto binário" da resposta.
Jon Skeet

112
Estou surpreso que ainda não tenha sido dito, floaté uma palavra-chave alias em C # e não é do tipo .Net. é System.Single.. singlee doublesão tipos de pontos binários flutuantes.
Brett Caswell

54
@BKSpurgeon: Bem, apenas da mesma maneira que você pode dizer que tudo é do tipo binário, quando é uma definição bastante inútil. Decimal é um tipo decimal, na medida em que é um número representado como um número inteiro e uma escala, de modo que o resultado é uma escala significativa e * 10 ^, enquanto que float e double são escala significativa e * 2 ^. Você pega um número escrito em decimal e move o ponto decimal o suficiente para a direita para obter um número inteiro para calcular o significando e a escala. Para float / double, você começaria com um número escrito em binário.
Jon Skeet

21
Outra diferença: flutuar 32 bits; duplo de 64 bits; e decimal de 128 bits.
David

1073

Precisão é a principal diferença.

Flutuador - 7 dígitos (32 bits)

Duplo -15-16 dígitos (64 bits)

Decimal -28-29 dígitos significativos (128 bits)

Os decimais têm uma precisão muito maior e geralmente são usados ​​em aplicativos financeiros que exigem um alto grau de precisão. Os decimais são muito mais lentos (até 20 vezes mais em alguns testes) do que um double / float.

Decimais e Bóias / Dobros não podem ser comparados sem um elenco, enquanto Bóias e Dobros podem. Os decimais também permitem a codificação ou zeros à direita.

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

Resultado:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

65
@Thecrocodilehunter: desculpe, mas não. Decimal pode representar todos os números que podem ser representados em notação decimal, mas não 1/3, por exemplo. 1.0m / 3.0m será avaliado para 0.33333333 ... com um número grande, mas finito, de 3s no final. Multiplicá-lo por 3 não retornará um 1,0 exato.
Erik P.

50
@Thecrocodilehunter: Eu acho que você está confundindo precisão e precisão. São coisas diferentes neste contexto. Precisão é o número de dígitos disponíveis para representar um número. Quanto mais precisão, menos você precisa arredondar. Nenhum tipo de dados tem precisão infinita.
Igby Largeman

13
@Thecrocodilehunter: Você está assumindo que o valor que está sendo medido é exatamente 0.1 - isso raramente acontece no mundo real! Qualquer formato de armazenamento finito confunde um número infinito de valores possíveis com um número finito de padrões de bits. Por exemplo, floatconflitará 0.1e 0.1 + 1e-8, enquanto decimalconflitará 0.1e 0.1 + 1e-29. Certamente, dentro de um determinado intervalo , certos valores podem ser representados em qualquer formato com perda zero de precisão (por exemplo, floatpode armazenar qualquer número inteiro até 1.6e7 com perda zero de precisão) - mas isso ainda não é precisão infinita .
Daniel Pryden

27
@Thecrocodilehunter: Você perdeu o meu argumento. não0.1 é um valor especial ! A única coisa que torna 0.1"melhor" do que 0.10000001é porque os seres humanos gostam da base 10. E mesmo com um floatvalor, se você inicializar dois valores 0.1da mesma maneira, ambos terão o mesmo valor . Só que esse valor não será exatamente 0.1 - será o valor mais próximo do 0.1que pode ser representado exatamente como afloat . Claro, com flutuadores binários (1.0 / 10) * 10 != 1.0, mas também com flutuadores decimais (1.0 / 3) * 3 != 1.0. Nem é perfeitamente preciso.
Daniel Pryden

16
@Thecrocodilehunter: Você ainda não entende. Não sei mais dizer isso claramente: em C, se o fizer double a = 0.1; double b = 0.1;, a == b será verdade . É apenas isso ae ambos não bserão exatamente iguais . Em C #, se você o fizer , também será verdadeiro. Mas, nesse caso, nem de nem será exatamente igual - ambos irão igual . Nos dois casos, alguma precisão é perdida devido à representação. Você teimosamente diz que tem precisão "infinita", o que é falso . 0.1decimal a = 1.0m / 3.0m; decimal b = 1.0m / 3.0m;a == bab1/30.3333...decimal
Daniel Pryden

84

A estrutura decimal é estritamente voltada para cálculos financeiros que exigem precisão, que são relativamente intolerantes ao arredondamento. Os decimais não são adequados para aplicações científicas, no entanto, por várias razões:

  • Uma certa perda de precisão é aceitável em muitos cálculos científicos devido aos limites práticos do problema ou artefato físico sendo medido. Perda de precisão não é aceitável em finanças.
  • Decimal é muito (muito) mais lento que float e duplicado para a maioria das operações, principalmente porque as operações de ponto flutuante são feitas em binário, enquanto as coisas decimais são feitas na base 10 (ou seja, flutuações e duplas são tratadas pelo hardware da FPU, como MMX / SSE , enquanto os decimais são calculados em software).
  • O decimal tem uma faixa de valor inaceitavelmente menor que o dobro, apesar de suportar mais dígitos de precisão. Portanto, Decimal não pode ser usado para representar muitos valores científicos.

5
Se você estiver fazendo cálculos financeiros, é absolutamente necessário rolar seus próprios tipos de dados ou encontrar uma boa biblioteca que atenda às suas necessidades exatas. A precisão em um ambiente financeiro é definida por organismos de padrões (humanos) e eles têm regras muito específicas localizadas (tanto em tempo quanto em geografia) sobre como fazer cálculos. Coisas como arredondamento correto não são capturadas nos tipos de dados numéricos simples em .Net. A capacidade de fazer cálculos é apenas uma parte muito pequena do quebra-cabeça.
James Moore

76
+---------+----------------+---------+----------+---------------------------------------------+
| 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                               |
+---------+----------------+---------+----------+---------------------------------------------+

Veja aqui para mais informações .


5
Você deixou de fora a maior diferença, que é a base usada para o tipo decimal (decimal é armazenado como base 10, todos os outros tipos numéricos listados são base 2).
BrainSlugs83

1
Os intervalos de valores para Single e Double não estão representados corretamente na imagem acima ou na postagem do fórum de origem. Como não podemos facilmente substituir o texto aqui, use o caractere de interpolação: Single deve ser 10 ^ -45 e 10 ^ 38, e Double deve ser 10 ^ -324 e 10 ^ 308. Além disso, o MSDN tem a flutuação com um intervalo de -3,4x10 ^ 38 a + 3,4x10 ^ 38. Pesquise MSDN para System.Single e System.Double em caso de alterações de link. Único: msdn.microsoft.com/en-us/library/b1e65aza.aspx Duplo: msdn.microsoft.com/en-us/library/678hzkk9.aspx
deegee

2
Decimal é de 128 bits ... meio que ocupa 16 bytes não 12
user1477332

51

Não reiterarei toneladas de informações boas (e ruins) já respondidas em outras respostas e comentários, mas responderei sua pergunta de acompanhamento com uma dica:

Quando alguém usaria um desses?

Use decimal para valores contados

Use float / double para valores medidos

Alguns exemplos:

  • dinheiro (contamos dinheiro ou medimos dinheiro?)

  • distance (contamos distância ou medimos distância? *)

  • pontuações (contamos pontuações ou medimos pontuações?)

Sempre contamos dinheiro e nunca devemos medi-lo. Normalmente medimos a distância. Contamos frequentemente pontuações.

* Em alguns casos, o que eu chamaria de distância nominal , podemos realmente querer 'contar' a distância. Por exemplo, talvez estejamos lidando com sinais de países que mostram distâncias para cidades e sabemos que essas distâncias nunca têm mais de um dígito decimal (xxx.x km).


1
Eu realmente gosto desta resposta, especialmente a pergunta "contamos ou medimos dinheiro?" No entanto, além do dinheiro, não consigo pensar em nada que seja "contado" que não seja simplesmente inteiro. Vi alguns aplicativos que usam decimal simplesmente porque o dobro tem muito poucos dígitos significativos. Em outras palavras, decimal pode ser usado porque C # não tem um quádruplo tipo en.wikipedia.org/wiki/Quadruple-precision_floating-point_format
John Henckel

48

float 7 dígitos de precisão

double tem cerca de 15 dígitos de precisão

decimal tem cerca de 28 dígitos de precisão

Se você precisar de uma precisão melhor, use duplo em vez de flutuar. Nas CPUs modernas, os dois tipos de dados têm quase o mesmo desempenho. O único benefício de usar float é que eles ocupam menos espaço. Praticamente importa apenas se você tiver muitos deles.

Achei isso interessante. O que todo cientista da computação deve saber sobre aritmética de ponto flutuante


1
@RogerLipscombe: Eu consideraria doubleadequado em aplicativos de contabilidade nesses casos (e basicamente apenas naqueles casos) em que nenhum tipo inteiro maior que 32 bits estava disponível, e doubleestava sendo usado como se fosse um tipo inteiro de 53 bits (por exemplo, para manter um número inteiro de centavos ou um número inteiro de centésimos de centavo). Atualmente, não há muito uso para essas coisas, mas muitas linguagens ganharam a capacidade de usar valores de ponto flutuante de precisão dupla muito antes de ganharem matemática inteira de 64 bits (ou, em alguns casos, até 32 bits!).
Supercat 29/05

1
Sua resposta implica precisão é a única diferença entre esses tipos de dados. Como a aritmética binária de ponto flutuante é normalmente implementada na FPU de hardware , o desempenho é uma diferença significativa. Isso pode ser irrelevante para alguns aplicativos, mas é crítico para outros.
saille

6
O @supercat double nunca é adequado em aplicativos de contabilidade. Porque Double pode apenas aproximar valores decimais (mesmo dentro do intervalo de sua própria precisão). Isso ocorre porque o dobro armazena os valores em um formato centrado na base 2 (binária).
BrainSlugs83

2
@ BrainSlugs83: O uso de tipos de ponto flutuante para armazenar quantidades não inteiras seria impróprio, mas historicamente era muito comum que os idiomas tivessem tipos de ponto flutuante que pudessem representar precisamente valores maiores de número inteiro do que seus tipos inteiros poderiam representar . Talvez o exemplo mais extremo tenha sido o Turbo-87, cujos únicos tipos inteiros estavam limitados a -32768 a +32767, mas cujo IIRC Realpoderia representar valores de até 1,8E + 19 com precisão de unidade. Eu acho que seria muito mais saudável para uma aplicação de contabilidade de usar Realpara representar um número inteiro de moedas de um centavo do que ...
supercat

1
... para tentar executar matemática de precisão múltipla usando um monte de valores de 16 bits. Para a maioria dos outros idiomas, a diferença não foi tão extrema, mas por muito tempo foi muito comum que os idiomas não tivessem nenhum tipo de número inteiro que fosse além do 4E9, mas que tivessem um doubletipo com precisão de unidade de até 9E15. Se for necessário armazenar números inteiros maiores que o maior tipo inteiro disponível, o uso doublepoderá ser mais simples e eficiente do que tentar falsificar a matemática de multiprecisão, especialmente porque os processadores têm instruções para executar 16x16-> 32 ou. ..
supercat

36

Ninguém mencionou isso

Nas configurações padrão, os flutuadores (System.Single) e os duplos (System.Double) nunca usarão a verificação de estouro, enquanto Decimal (System.Decimal) sempre usará a verificação de estouro.

Quero dizer

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

lança OverflowException .

Mas estes não:

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

&

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

1
float.MaxValue+1 == float.MaxValue, assim como decimal.MaxValue+0.1D == decimal.MaxValue. Talvez você quis dizer algo como float.MaxValue*2?
Supercat

@supercar Mas não é verdade que decimal.MaxValue + 1 == decimal.MaxValue
GorkemHalulu

@supercar decimal.MaxValue + 0.1m == decimal.MaxValue ok
GorkemHalulu

1
A System.Decimalexceção é lançada pouco antes de se tornar incapaz de distinguir unidades inteiras, mas se um aplicativo supostamente estiver lidando com, por exemplo, dólares e centavos, isso pode ser tarde demais.
Supercat

28
  1. Double e float podem ser divididos pelo número inteiro zero, sem uma exceção, tanto na compilação quanto no tempo de execução.
  2. O decimal não pode ser dividido pelo número inteiro zero. A compilação sempre falhará se você fizer isso.

6
Eles com certeza podem! Eles também têm alguns valores "mágicos", como Infinito, Infinito Negativo e NaN (não um número), que o tornam muito útil para detectar linhas verticais ao computar inclinações ... Além disso, se você precisar decidir entre chamar float .TryParse, double.TryParse e decimal.TryParse (para detectar se uma string é um número, por exemplo), recomendo o uso de double ou float, pois eles analisarão "Infinity", "-Infinity" e "NaN" corretamente , enquanto decimal não.
BrainSlugs83

A compilação falha apenas se você tentar dividir um literal decimalpor zero (CS0020), e o mesmo se aplica aos literais integrais. No entanto, se um valor decimal em tempo de execução for dividido por zero, você receberá uma exceção e não um erro de compilação.
de Drew Noakes

@ BrainSlugs83 No entanto, poderá não querer analisar "Infinito" ou "NaN", dependendo do contexto. Parece uma boa exploração para a entrada do usuário se o desenvolvedor não for suficientemente rígido.
Inverno

28

Inteiros, como foi mencionado, são números inteiros. Eles não podem armazenar algo do ponto, como 0,7, 0,42 e 0,007. Se você precisar armazenar números que não sejam números inteiros, precisará de um tipo diferente de variável. Você pode usar o tipo duplo ou flutuante. Você configura esses tipos de variáveis ​​exatamente da mesma maneira: em vez de usar a palavra int, você digita doubleou float. Como isso:

float myFloat;
double myDouble;

( floaté a abreviação de "ponto flutuante" e significa apenas um número com um ponto no final.)

A diferença entre os dois está no tamanho dos números que eles podem conter. Para float, você pode ter até 7 dígitos no seu número. Para doubles, você pode ter até 16 dígitos. Para ser mais preciso, eis o tamanho oficial:

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

floaté um número de 32 bits e doubleé um número de 64 bits.

Clique duas vezes no seu novo botão para obter o código. Adicione as três linhas a seguir ao código do botão:

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

Pare o seu programa e retorne à janela de codificação. Mude esta linha:

myDouble = 0.007;
myDouble = 12345678.1234567;

Execute seu programa e clique no botão duplo. A caixa de mensagem exibe corretamente o número. Adicione outro número no final, porém, e o C # será novamente arredondado para cima ou para baixo. A moral é que se você quer precisão, tenha cuidado ao arredondar!


2
O "apontar algo" que você mencionou é geralmente referido como "a parte fracionária" de um número. "Ponto flutuante" não significa "um número com um ponto no final"; mas "Ponto flutuante" distingue o tipo de número, em oposição a um número "Ponto fixo" (que também pode armazenar um valor fracionário); a diferença é se a precisão é fixa ou flutuante. - Os números de ponto flutuante oferecem uma faixa dinâmica de valores muito maior (Mín e Máx), ao custo da precisão, enquanto que os números de ponto fixo fornecem uma quantidade constante de precisão ao custo do intervalo.
BrainSlugs83

16
  • float: ± 1,5 x 10 ^ -45 a ± 3,4 x 10 ^ 38 (~ 7 números significativos
  • duplo: ± 5,0 x 10 ^ -324 a ± 1,7 x 10 ^ 308 (15-16 figuras significativas)
  • decimal: ± 1,0 x 10 ^ -28 a ± 7,9 x 10 ^ 28 (28-29 algarismos significativos)

9
A diferença é mais do que apenas precisão. - decimalé realmente armazenado no formato decimal (em oposição à base 2; portanto, não perde ou arredonda os dígitos devido à conversão entre os dois sistemas numéricos); além disso, decimalnão tem conceito de valores especiais como NaN, -0, ∞ ou -∞.
precisa saber é o seguinte

13

Esta tem sido uma discussão interessante para mim, pois hoje, tivemos apenas um bug desagradável, por decimalter menos precisão que a float.

Em nosso código C #, estamos lendo valores numéricos de uma planilha do Excel, convertendo-os em um decimale enviando-os decimalnovamente para um Serviço para salvar em um banco de dados do SQL Server .

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

Agora, para quase todos os nossos valores do Excel, isso funcionou perfeitamente. Mas, para alguns valores muito pequenos do Excel, o uso decimal.TryParsedo valor foi perdido completamente. Um exemplo é

  • cellValue = 0.00006317592

  • Decimal.TryParse (cellValue.ToString (), valor out); // retornaria 0

A solução, estranhamente, foi converter os valores do Excel em um doubleprimeiro e depois em um 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;
    
}

Embora doubletenha menos precisão que a decimal, isso realmente garantiu que pequenos números ainda seriam reconhecidos. Por alguma razão, double.TryParsefoi realmente capaz de recuperar números tão pequenos, enquanto decimal.TryParseos definiria como zero.

Ímpar. Muito estranho.


3
Por curiosidade, qual foi o valor bruto de cellValue.ToString ()? Decimal.TryParse ("0.00006317592", out val) parece funcionar ...
micahtan

11
-1 Não me interpretem mal, se for verdade, é muito interessante, mas esta é uma pergunta à parte, certamente não é uma resposta a esta pergunta.
weston

2
Talvez porque a célula do Excel retornasse um valor duplo e ToString () fosse "6.31759E-05", portanto o decimal.Parse () não gostou da notação. Aposto que se você verificasse o valor de retorno de Decimal.TryParse (), seria falso.
SergioL 15/10

2
As Respostas @weston geralmente complementam outras respostas, preenchendo as nuances perdidas. Esta resposta destaca uma diferença em termos de análise. É muito uma resposta para a pergunta!
Robino 20/05

1
Er ... decimal.Parse("0.00006317592")funciona - você tem algo mais acontecendo. - Notação possivelmente científica?
precisa saber é o seguinte

9

Para aplicativos como jogos e sistemas incorporados nos quais a memória e o desempenho são críticos, o float geralmente é o tipo numérico de escolha, pois é mais rápido e tem a metade do tamanho de um dobro. Os números inteiros costumavam ser a arma preferida, mas o desempenho do ponto flutuante ultrapassou o número inteiro nos processadores modernos. Decimal está certo!


Praticamente todos os sistemas modernos, até telefones celulares, têm suporte de hardware para duplicação; e se o seu jogo tiver uma física simples, você notará uma grande diferença entre double e float. (Por exemplo, o cálculo da velocidade / fricção num simples clone Asteroides, duplos permitir a aceleração de fluxo muito mais fluida que flutuador -. Parece que não importa, mas totalmente faz.)
BrainSlugs83

As duplas também têm o dobro do tamanho das flutuações, o que significa que você precisa coletar o dobro de dados, o que prejudica o desempenho do cache. Como sempre, meça e proceda de acordo.
yoyo 22/09

7

Os tipos de variável Decimal, Double e Float são diferentes na maneira como eles armazenam os valores. Precisão é a principal diferença em que float é um tipo de dados de ponto flutuante de precisão única (32 bits), double é um tipo de dados de ponto flutuante de precisão dupla (64 bits) e decimal é um tipo de dados de ponto flutuante de 128 bits.

Flutuador - 32 bits (7 dígitos)

Duplo - 64 bits (15-16 dígitos)

Decimal - 128 bits (28-29 dígitos significativos)

Mais sobre ... a diferença entre Decimal, Float e Double


5

O problema com todos esses tipos é que uma certa imprecisão subsiste E que esse problema pode ocorrer com pequenos números decimais, como no exemplo a seguir

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

Pergunta: Qual valor a variável bLower contém?

Resposta: Em uma máquina de 32 bits, o bLower contém VERDADEIRO !!!

Se substituir Double por Decimal, o bLower conterá FALSE, que é a boa resposta.

Em dobro, o problema é que fMean-fDelta = 1.09999999999 é menor que 1.1.

Cuidado: Eu acho que esse mesmo problema certamente pode existir para outro número, porque Decimal é apenas um duplo com maior precisão e a precisão sempre tem um limite.

De fato, Double, Float e Decimal correspondem ao decimal BINARY em COBOL!

É lamentável que outros tipos numéricos implementados no COBOL não existam no .Net. Para aqueles que não conhecem COBOL, existem em COBOL seguindo o tipo numérico

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) 

4

Em palavras simples:

  1. Os tipos de variável Decimal, Double e Float são diferentes na maneira como eles armazenam os valores.
  2. Precisão é a principal diferença (observe que essa não é a única diferença) em que float é um tipo de dados de ponto flutuante de precisão única (32 bits), double é um tipo de dados de ponto flutuante de precisão dupla (64 bits) e decimal é 128 bits tipo de dados de ponto flutuante.
  3. A tabela de resumo:

/==========================================================================================
    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)
/==========================================================================================
Você pode ler mais aqui , Flutuante , Duplo e Decimal .


O que essa resposta acrescenta que ainda não foi abordada nas respostas existentes? Aliás, sua linha "ou" na linha "decimal" está incorreta: a barra na página da Web da qual você está copiando indica divisão em vez de uma alternativa.
Mark-Dickinson-

1
E eu contestaria fortemente que a precisão é a principal diferença. A principal diferença é a base: ponto flutuante decimal versus ponto flutuante binário. Essa diferença é o que o torna Decimaladequado para aplicações financeiras e é o principal critério a ser usado ao decidir entre Decimale Double. É raro que a Doubleprecisão não seja suficiente para aplicações científicas, por exemplo (e Decimalmuitas vezes não é adequada para aplicações científicas devido ao seu alcance limitado).
Mark Dickinson

2

A principal diferença entre cada um deles é a precisão.

floaté um 32-bitnúmero, doubleé um 64-bitnúmero e decimalé um 128-bitnúmero.


0
  • Decimal de 128 bits (28-29 dígitos significativos) No caso de aplicativos financeiros, é melhor usar os tipos decimais, pois fornece um alto nível de precisão e é fácil evitar erros de arredondamento. Use decimal para matemática não inteira onde a precisão é necessária (por exemplo, dinheiro e moeda)

  • Tipo duplo de 64 bits (15 a 16 dígitos) Os tipos duplos são provavelmente o tipo de dados mais usado para valores reais, exceto manipulando dinheiro. Use double para matemática não inteira, onde a resposta mais precisa não é necessária.

  • Flutuar 32 bits (7 dígitos) É usado principalmente em bibliotecas gráficas, porque demandas muito altas de capacidade de processamento também usavam situações que podem suportar erros de arredondamento.

Decimalssão muito mais lentos que um double/float.

Decimalse Floats/Doublesnão pode ser comparado sem um elenco enquanto Floatse Doublespode.

Decimals também permite a codificação ou zeros à direita.


-1

Para definir decimal, flutuar e dobrar em .Net (c #)

você deve mencionar valores como:

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

e verifique os resultados.

E os bytes ocupados por cada um são

Float - 4
Double - 8
Decimal - 12
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.