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#. Estas lições ensinam os fundamentos da linguagem C#.

Neste tutorial, você:

Pré-requisitos

Deve ter um dos seguintes:

• Uma conta GitHub para usar Codespaces GitHub. Se ainda não tiver uma, pode criar uma conta gratuita no GitHub.com.
• Um computador com as seguintes ferramentas instaladas:
  • O SDK .NET 10.
  • Código do Visual Studio.
  • O C# DevKit.

Explore a matemática dos números inteiros

Para iniciar um GitHub Codespace com o ambiente de tutorial, abra uma janela do navegador para o repositório tutorial codespace. Selecione o botão verde de Código e o separador Codespaces . Depois seleciona o + sinal para criar um novo Codespace usando este ambiente. Se completaste o tutorial hello world , podes abrir esse codespace em vez de criares um novo.

1. Quando o seu espaço de código carregar, crie um novo ficheiro na pasta tutoriais chamado numbers.cs.

2. Abra o seu novo ficheiro.

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

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

4. Execute este código digitando os seguintes comandos no terminal integrado:

   cd ./tutorials
   dotnet numbers.cs
   

   Viste uma das operações matemáticas fundamentais com inteiros. O int tipo representa um número inteiro, zero, positivo ou negativo. Utiliza-se o símbolo + para adição. Outras operações matemáticas comuns para inteiros incluem:

   • - para subtração
   • * para multiplicação
   • / para divisão

5. Comece por explorar essas diferentes operações. Adicione estas linhas após a linha que escreve 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);
   

6. Execute este código escrevendo dotnet numbers.cs na janela do terminal.

Você também pode experimentar escrevendo várias operações matemáticas na mesma linha, se desejar. Experimente c = a + b - 12 * 17; , por exemplo. É permitido misturar variáveis e números constantes.

Terminaste o primeiro passo. Antes de começares a próxima secção, vamos mover o código atual para um método separado. Um método é uma série de afirmações agrupadas e com um nome. Chama um método escrevendo o nome do método seguido de (). Organizar o seu código em métodos facilita começar a trabalhar com um novo exemplo. Quando terminares, o teu código deverá ficar assim:

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);
}

Explore a ordem de operações

1. Comente a chamada para WorkingWithIntegers(). Isto torna a saída menos desordenada enquanto trabalhas nesta parte:

   //WorkWithIntegers();
   

   Em C#, o // inicia um comentário. Comentários são qualquer texto que queiras manter no teu código-fonte, mas não executar como código. O compilador não gera qualquer código executável a partir dos comentários. Como WorkWithIntegers() é um método, só precisas de comentar uma linha.

2. 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. A multiplicação e a divisão têm precedência sobre a adição e a subtração. Explore isso adicionando o seguinte código após a chamada a WorkWithIntegers(), e escrevendo 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 é realizada antes da adição.

3. Você pode forçar uma ordem diferente de operação adicionando parênteses em torno da operação ou operações que deseja executar primeiro. Adicione as seguintes linhas e execute novamente:

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

4. Explore mais combinando muitas operações diferentes. Adicione algo como as seguintes linhas. 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 inteira sempre produz um resultado inteiro, mesmo quando você esperaria que o resultado incluísse uma parte decimal ou fracionária.

5. Se não viu este comportamento, experimente o seguinte código:

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

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

Antes de continuar, vamos pegar em todo o código que escreveste nesta secção e colocá-lo num novo método. Chame esse novo método OrderPrecedence. Seu código deve ter esta 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);
}

Explore a precisão e os limites de números inteiros

A amostra anterior mostrou que a divisão inteira trunca o resultado. Podes obter o resto usando o operador resto, o % carácter.

1. Experimente o seguinte código após a chamada ao 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}");
   

2. O tipo inteiro C# difere dos inteiros matemáticos de uma outra maneira: o tipo int tem limites mínimos e máximos. Tente 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}");
   

3. Se um cálculo produzir um valor que exceda esses limites, terá uma condição de subfluxo ou de estouro. A resposta parece fluir 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 grande número negativo porque um overflow "salta" do maior valor inteiro possível para o menor.

Existem outros tipos numéricos com limites e precisão diferentes que podes usar quando o int tipo não corresponde às tuas necessidades. Vamos explorar esses tipos de números a seguir.

Trabalhar com o tipo duplo

O tipo numérico double 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 inteiros 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. Os números de precisão dupla têm o dobro do número de dígitos binários que os números de precisão única. Nos computadores modernos, é mais comum usar-se a dupla precisão do que números de precisão simples. Os números de precisão simples são declarados usando a float palavra-chave. Vamos explorar.

1. 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.

2. Tente uma expressão um pouco mais complicada com números do tipo double. 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);
   

3. O intervalo de um valor duplo é muito maior do que o de valores inteiros. Experimente adicionar o código seguinte ao que escreveu até agora:

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

   Estes valores são impressos em notação científica. O número à esquerda do E é o significante. O número à direita é o expoente, como uma potência de 10.

4. Assim como os números decimais em matemática, os duplos 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 de 1/3, mas ainda não é exato. Não importa quantas casas decimais você adicionar, um erro de arredondamento permanece.

Desafio

Experimente outros cálculos com números grandes, pequenos, multiplicação e divisão usando o double tipo. Tente cálculos mais complicados. Depois de passares algum tempo com o desafio, pega no código que escreveste e coloca-o num novo método. Nomeia esse novo método WorkWithDoubles.

Trabalhar com tipos decimais

Viste os tipos numéricos básicos em C#: inteiros e duplos. Há outro tipo a aprender: o tipo decimal. O tipo decimal tem um alcance menor, mas maior precisão do que double.

1. Vejamos:

   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 do que o tipo double.

2. Você pode ver a maior precisão com o tipo decimal tentando 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);
   

   Note que a matemática com o tipo decimal tem mais dígitos à direita do ponto decimal.

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

Desafio

Agora que já conheces os diferentes tipos numéricos, escreve código que calcule a área de um círculo cujo raio é de 2,50 centímetros. Lembre-se que a área de um círculo é o raio ao 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 namespace System.Math, é um valor double. Por essa razão, deves usar os valores de double em vez de decimal para este desafio.

Deverá obter uma resposta entre 19 e 20.

Quando experimentares, abre o painel de detalhes para veres como te saíste:

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

Tente outras fórmulas, se desejar.

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

• Tipos numéricos integrais
• Tipos numéricos de vírgula flutuante
• Conversões numéricas integradas

Recursos de limpeza

O GitHub apaga automaticamente o seu Codespace após 30 dias de inatividade. Se planeia explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se estiver pronto para visitar o site .NET para descarregar o SDK .NET, pode eliminar o seu Codespace. Para eliminar o seu Codespace, abra uma janela do navegador e vá aos seus Codespaces. Deves ver uma lista dos teus codespaces na janela. Selecione os três pontos (...) na entrada para o espaço de código do tutorial de aprendizado e selecione apagar.

Próximo passo