O que são tipos numéricos de ponto flutuante em C#
Na programação, o termo "ponto flutuante" refere-se a um tipo de dados numéricos que são usados para representar números decimais. Existem vários tipos diferentes de dados de ponto flutuante que você pode usar em C#, cada um com seu próprio conjunto de características e recursos.
Neste artigo, veremos mais de perto os tipos numéricos de ponto flutuante em C#.
Entendendo os tipos de dados numéricos
Antes de discutirmos o tipo de dados de ponto flutuante, é importante ter um entendimento básico dos diferentes tipos de dados numéricos que estão disponíveis em C#. Dados numéricos comumente usados incluem:
- Inteiro: Usado para representar números (e.g., 1, 2, 3, etc.).
- Ponto flutuante: Usado para representar números decimais (e.g., 1.2, 3.14, etc.).
- Decimal: Usado para representar números com maior precisão do que números de ponto flutuante (e.g., 3.14159265358979323846).
Agora, como sabemos, o ponto flutuante é usado para armazenar os dados decimais dentro deles. O próximo passo é discutir todas as formas diferentes de números de ponto flutuante.
O básico dos dados de ponto flutuante
Os dados de ponto flutuante são usados para representar números decimais que não podem ser representados com precisão usando dados inteiros. Por exemplo, se você deseja representar o número 1.5 Usando dados inteiros, você teria que arredondá -los para o valor mais próximo (1 ou 2). No entanto, com dados de ponto flutuante, você pode representar 1.5 exatamente.
A seguir estão os tipos de ponto flutuante usados em C# para representar valores decimais com diferentes faixas e níveis de precisão.
- flutuador: É um tipo de dados de ponto flutuante de 32 bits
- dobro: É um tipo de dados de ponto flutuante de 64 bits
- decimal: É um tipo de dados de ponto flutuante de 128 bits
Nos três tipos de dados de ponto flutuante, o decimal é de maior precisão.
Características dos tipos de dados de ponto flutuante
Os tipos numéricos de ponto flutuante em C# são usados para representar números que têm uma parte fracionária. A tabela a seguir ilustra as características de diferentes tipos de dados de ponto flutuante em C#:
| Tipos de dados de ponto flutuante | Faixa | Precisão | Tamanho |
|---|---|---|---|
| flutuador | ± 1.5 x 10−45 a ± 3.4 x 1038 | ~ 6-9 dígitos | 4 bytes [32 bits] |
| dobro | ± 5.0 × 10−324 a ± 1.7 × 10308 | ~ 15-17 dígitos | 8 bytes [64 bits] |
| decimal | ± 1.0 x 10-28 a ± 7.9228 x 1028 | 28-29 dígitos | 16 bytes [128 bits] |
Por padrão, cada um desses três pontos flutuantes tem valores iguais a zero. Cada um deles tem um valor mínimo e um valor máximo.
Usando dados de ponto flutuante em C#
Para declarar uma variável float, você pode usar a seguinte sintaxe:
flutuar myfloat = 3.14f;
Observe que você precisa adicionar o sufixo F ao valor para indicar que é um flutuador.
Para declarar uma variável dupla, você pode usar a seguinte sintaxe:
duplo mydouble = 3.14;
Por padrão, os literais de ponto flutuante em C# são tratados como duplos. Se você quiser usar um literal flutuante, pode adicionar o sufixo F ao valor.
Para declarar os literais decimais, usamos o sufixo M ou M:
Decimal myDecimal = 3.14m;
Compreendendo problemas de precisão de ponto flutuante
A precisão dos números de ponto flutuante em C# é limitado pelo número de bits usados para representar o número. Por exemplo, um número de ponto flutuante (float) usa 32 bits para representar o número, enquanto um número de ponto flutuante (duplo) usa 64 bits.
Uma conseqüência dessa precisão limitada é que nem todos os valores decimais podem ser representados exatamente usando números de ponto flutuante. Por exemplo, o valor 0.1 não pode ser declarado usando números de ponto flutuante. Isso pode levar a um comportamento inesperado ao realizar operações aritméticas.
Outra questão é que algumas operações podem introduzir erros de arredondamento. Por exemplo, adicionar dois números muito pequenos pode resultar em uma perda de precisão. Da mesma forma, subtrair dois números muito grandes também pode resultar em perda de precisão.
Por exemplo, considere o seguinte código:
duplo num1 = 0.1;
duplo num2 = 0.2;
resultado duplo = num1 + num2;
Você pode esperar que o valor do resultado seja 0.3, mas devido à maneira como os dados de ponto flutuante são armazenados, o valor real do resultado será ligeiramente diferente (neste caso, será aproximadamente 0.30000000000000004). Resultados como esses podem alterar a saída e causar comportamento inesperado no programa, por isso é importante estar ciente desses problemas de precisão.
Para resolver esses problemas, os tipos de dados decimais podem ser preferidos sobre flutuação e dobrar. O decimal tem maior precisão que o dobro e é melhor para representar valores que requerem um alto grau de precisão.
Conclusão
Os tipos de dados de ponto flutuante podem armazenar números com precisão diferente. Os três tipos principais incluem flutuação, dupla e decimal. Entre todos, o decimal tem a maior precisão. Usando esses tipos de ponto flutuante em C#, pode-se representar facilmente números decimais. Para uma descrição detalhada dos três tipos, leia o artigo.