Tutorial: Como usar números inteiros e de ponto flutuante em C#

Este tutorial ensina sobre os tipos numéricos em C#. Você escreve pequenas quantidades de código e, em seguida, compila e executa esse código. O tutorial contém uma série de lições que exploram números e operações matemáticas em C#. Essas lições ensinam os conceitos básicos da linguagem C#.

Neste tutorial, você:

Inicie um Codespace do GitHub com um ambiente de desenvolvimento em C#.
Explore a matemática de inteiros.
Aprenda a ordem das operações.
Aprenda os limites inteiros e a precisão.
Aprenda tipos de ponto flutuante.
Aprenda o tipo decimal.

Pré-requisitos

Você deve ter um dos seguintes:

Uma conta do GitHub para usar os Codespaces do GitHub. Se você ainda não tiver uma, poderá criar uma conta gratuita em GitHub.com.
Um computador com as seguintes ferramentas instaladas:
- O SDK do .NET 10.
- Visual Studio Code.
- O Kit de Desenvolvimento do C#.

Explorar aritmética de inteiros

Para iniciar um Codespace do GitHub com o ambiente do tutorial, abra uma janela do navegador para o repositório do codespace do tutorial. Selecione o botão código verde e a guia Codespaces . Em seguida, selecione o + sinal para criar um novo Codespace usando esse ambiente. Se você concluiu o tutorial hello world , você pode abrir esse codespace em vez de criar um novo.

Quando o codespace for carregado, crie um novo arquivo na pasta de tutoriais chamada numbers.cs.
Abra seu novo arquivo.

Digite ou copie o seguinte código para numbers.cs:

int a = 18;
int b = 6;
int c = a + b;
Console.WriteLine(c);

Execute este código digitando os seguintes comandos no terminal integrado:
```
cd ./tutorials
dotnet numbers.cs
```
Você viu uma das operações matemáticas fundamentais com inteiros. O int tipo representa um número inteiro inteiro, zero, positivo ou negativo. Use o + símbolo para adição. Outras operações matemáticas comuns para inteiros incluem:
- - para subtração
- * para multiplicação
- / para divisão

Comece explorando essas operações diferentes. Adicione estas linhas após a linha que grava o valor de c:

// subtraction
c = a - b;
Console.WriteLine(c);

// multiplication
c = a * b;
Console.WriteLine(c);

// division
c = a / b;
Console.WriteLine(c);

Execute esse código digitando dotnet numbers.cs na janela do terminal.

Você também pode experimentar escrevendo várias operações matemáticas na mesma linha, se desejar. Tente c = a + b - 12 * 17; , por exemplo. A combinação de variáveis e números constantes é permitida.

Dica

Ao explorar C# (ou qualquer linguagem de programação), você pode cometer erros ao escrever código. O compilador localiza esses erros e os relata para você. Quando a saída contiver mensagens de erro, examine atentamente o código de exemplo e o código em sua janela para ver o que corrigir. Você também pode pedir a Copilot para encontrar diferenças ou detectar erros. Esse exercício ajuda você a aprender a estrutura do código C#.

Você terminou a primeira etapa. Antes de iniciar a próxima seção, vamos mover o código atual para um método separado. Um método é uma série de instruções agrupadas e dada um nome. Você chama um método escrevendo o nome do método seguido por (). Organizar seu código em métodos torna mais fácil começar a trabalhar com um novo exemplo. Quando você terminar, seu código deverá ter esta aparência:

WorkWithIntegers();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

Explorar a ordem das operações

Comente a chamada para WorkingWithIntegers(). Isso faz com que a saída fique menos desordenada enquanto você trabalha nesta seção:
```
//WorkWithIntegers();
```
O elemento // inicia um comentário em C#. Os comentários são qualquer texto que você deseja manter no código-fonte, mas não são executados como código. O compilador não gera nenhum código executável a partir de comentários. Como WorkWithIntegers() é um método, você precisa apenas comentar uma linha.
A linguagem C# define a precedência de diferentes operações matemáticas com regras consistentes com as regras que você aprendeu em matemática. Multiplicação e divisão têm precedência sobre adição e subtração. Explore isso adicionando o seguinte código após a chamada WorkWithIntegers()e digitando dotnet numbers.cs na janela do terminal:
```
int a = 5;
int b = 4;
int c = 2;
int d = a + b * c;
Console.WriteLine(d);
```
A saída demonstra que a multiplicação é executada antes da adição.
Você pode forçar uma ordem de operação diferente adicionando parênteses em torno da operação ou das operações que deseja executar primeiro. Adicione as seguintes linhas e execute novamente:
```
d = (a + b) * c;
Console.WriteLine(d);
```
Explore mais combinando várias operações diferentes. Adicione algo semelhante às linhas a seguir. Tente dotnet numbers novamente na janela do terminal.
```
d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);
```
Você pode notar um comportamento interessante para números inteiros. A divisão de inteiros sempre produz um resultado inteiro, mesmo quando você espera que o resultado inclua uma parte decimal ou fracionária.

Se você não viu esse comportamento, tente o seguinte código:

int e = 7;
int f = 4;
int g = 3;
int h = (e + f) / g;
Console.WriteLine(h);

Digite dotnet numbers.cs novamente na janela do terminal para ver os resultados.

Antes de seguir em frente, vamos pegar todo o código que você escreveu nesta seção e colocá-lo em um novo método. Chame esse novo método OrderPrecedence. Seu código deve ter a seguinte aparência:

// WorkWithIntegers();
OrderPrecedence();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

void OrderPrecedence()
{
    int a = 5;
    int b = 4;
    int c = 2;
    int d = a + b * c;
    Console.WriteLine(d);

    d = (a + b) * c;
    Console.WriteLine(d);

    d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
    Console.WriteLine(d);

    int e = 7;
    int f = 4;
    int g = 3;
    int h = (e + f) / g;
    Console.WriteLine(h);
}

Explorar a precisão e os limites de inteiros

O exemplo anterior mostrou que a divisão de inteiros trunca o resultado. Você pode obter o resíduo usando o operador de resto, o caractere %.

Experimente o seguinte código após a chamada do método para OrderPrecedence():

int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
int e = (a + b) % c;
Console.WriteLine($"quotient: {d}");
Console.WriteLine($"remainder: {e}");

O tipo inteiro de C# difere dos inteiros matemáticos de uma outra maneira: o int tipo tem limites mínimos e máximos. Experimente o seguinte código para ver esses limites:
```
int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"The range of integers is {min} to {max}");
```
Se um cálculo produzir um valor que exceda esses limites, você terá uma condição de subfluxo ou estouro . A resposta parece quebrar de um limite para o outro. Para ver um exemplo, adicione estas duas linhas ao seu código:
```
int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");
```

Observe que a resposta está muito próxima do número inteiro mínimo (negativo). É o mesmo que min + 2. A operação de adição transbordou os valores permitidos para inteiros. A resposta é um número negativo grande, pois um estouro "envolve" do maior valor de inteiro possível para o menor.

Há outros tipos numéricos com limites e precisão diferentes que você pode usar quando o int tipo não atende às suas necessidades. Vamos explorar esses tipos de números em seguida.

Trabalhar com o tipo Double

O double tipo numérico representa um número de ponto flutuante de precisão dupla. Esses termos podem ser novos para você. Um número de ponto flutuante é útil para representar números não integrais que podem ser muito grandes ou pequenos em magnitude. Precisão dupla é um termo relativo que descreve o número de dígitos binários usados para armazenar o valor. Números de precisão dupla têm o dobro do número de dígitos binários como precisão única. Em computadores modernos, você geralmente usa precisão dupla do que números de precisão simples. Números de precisão única são declarados usando a float palavra-chave. Vamos explorar.

Adicione o seguinte código e veja o resultado:
```
double a = 5;
double b = 4;
double c = 2;
double d = (a + b) / c;
Console.WriteLine(d);
```
Observe que a resposta inclui a parte decimal do quociente.
Experimente uma expressão ligeiramente mais complicada com duplas. Você pode usar os seguintes valores ou substituir outros números:
```
double a = 19;
double b = 23;
double c = 8;
double d = (a + b) / c;
Console.WriteLine(d);
```
O intervalo de um valor duplo é muito maior do que valores inteiros. Experimente o código a seguir que você adiciona ao que escreveu até agora:
```
double max = double.MaxValue;
double min = double.MinValue;
Console.WriteLine($"The range of double is {min} to {max}");
```
Esses valores são impressos em notação científica. O número à esquerda é o E significand. O número à direita é o expoente, como uma potência de 10.
Assim como números decimais em matemática, as duplas em C# podem ter erros de arredondamento. Experimente este código:
```
double third = 1.0 / 3.0;
Console.WriteLine(third);
```
Você sabe que 0.3 é 3/10 e não exatamente o mesmo que 1/3. Da mesma forma, 0.33 é 33/100. Esse valor está mais próximo 1/3, mas ainda não é exato. Não importa quantas casas decimais você adicione, um erro de arredondamento permanece.

Desafio

Experimente outros cálculos com números grandes, números pequenos, multiplicação e divisão usando o double tipo. Tente cálculos mais complicados. Depois de passar algum tempo com o desafio, pegue o código que você escreveu e coloque-o em um novo método. Nomeie esse novo método WorkWithDoubles.

Trabalhar com tipos decimais

Você viu os tipos numéricos básicos em C#: inteiros e duplos. Ainda há outro tipo: o tipo decimal. O decimal tipo tem um intervalo menor, mas maior precisão que double.

Vamos dar uma olhada.

decimal min = decimal.MinValue;
decimal max = decimal.MaxValue;
Console.WriteLine($"The range of the decimal type is {min} to {max}");

Observe que o intervalo é menor que o double tipo.

Você pode ver a maior precisão com o tipo decimal ao tentar o seguinte código:
```
double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);

decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);
```
Observe que a matemática com o tipo decimal tem mais dígitos à direita do ponto decimal.

O M sufixo nos números indica que uma constante deve usar o decimal tipo. Caso contrário, o compilador assume o tipo double.

Observação

A letra M é a mais visualmente distinta entre as palavras-chave double e decimal.

Desafio

Agora que você conhece os diferentes tipos numéricos, escreva o código que calcula a área de um círculo cujo raio é de 2,50 centímetros. Lembre-se de que a área de um círculo é o raio quadrado multiplicado por PI. Uma dica: o .NET contém uma constante para PI, Math.PI que você pode usar para esse valor. Math.PI, como todas as constantes declaradas no System.Math namespace, é um double valor. Por esse motivo, você deve usar os valores de double em vez de decimal para esse desafio.

Você deve obter uma resposta entre 19 e 20.

Ao experimentá-lo, abra o painel de detalhes para ver como você fez:

double radius = 2.50;
double area = Math.PI * radius * radius;
Console.WriteLine(area);

Experimente outras fórmulas se quiser.

Você pode saber mais sobre números em C# nos seguintes artigos:

Recursos de limpeza

O GitHub exclui automaticamente o Codespace após 30 dias de inatividade. Se você planeja explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se você estiver pronto para visitar o site do .NET para baixar o SDK do .NET, poderá excluir seu Codespace. Para excluir o Codespace, abra uma janela do navegador e vá para seus Codespaces. Você deve ver uma lista de seus codespaces na janela. Selecione os três pontos (...) na entrada para o codespace do tutorial de aprendizado e selecione excluir.

Próxima etapa

Tuplas e tipos

Comentários

Esta página foi útil?

Last updated on 2025-12-11