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

Artigo
05/10/2023

Este tutorial ensina tipos numéricos em C#. Você escreverá pequenas quantidades de código, depois compilará e executará 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 princípios básicos da linguagem C#.

Dica

Para colar um snippet de código dentro do modo de foco, você deve usar o atalho de teclado (Ctrl + v ou cmd + v).

Pré-requisitos

Este tutorial espera que você tenha um computador configurado para desenvolvimento local. Consulte Configurar seu ambiente local para obter instruções de instalação e uma visão geral do desenvolvimento de aplicativos no .NET.

Se você não quiser configurar um ambiente local, consulte a versão interativa no navegador deste tutorial.

Explorar a matemática de inteiros

Crie um diretório chamado numbers-quickstart. Torne esse o diretório atual e execute o seguinte comando:

dotnet new console -n NumbersInCSharp -o .

Importante

Os modelos C# para o .NET 6 usam instruções de nível superior. Se você já tiver atualizado para o .NET 6, talvez seu aplicativo não corresponda ao código descrito neste artigo. Para obter mais informações, consulte o artigo sobre Novos modelos C# geram instruções de nível superior

O SDK do .NET 6 também adiciona um conjunto de diretivas implícitasglobal using para projetos que usam os seguintes SDKs:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Essas diretivas implícitas global using incluem os namespaces mais comuns para o tipo de projeto.

Para obter mais informações, consulte o artigo sobre Diretivas de uso implícito

Abra Program.cs em seu editor favorito e substitua o conteúdo do arquivo pelo seguinte código:

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

Execute este código digitando dotnet run na janela de comando.

Você viu apenas uma das operações matemáticas fundamentais com números inteiros. O tipo int representa um inteiro, zero, um número inteiro positivo ou negativo. Você usa 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 diferentes operações. 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 este código digitando dotnet run na janela de comando.

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

Dica

À medida que explora C# (ou qualquer linguagem de programação), você cometerá erros ao escrever o código. O compilador encontrará esses erros e os reportará a você. Quando a saída contiver mensagens de erro, analise atentamente o código de exemplo e o código em sua janela para ver o que deve ser corrigido. Esse exercício ajudará você a conhecer a estrutura do código C#.

Você terminou a primeira etapa. Antes de iniciar a próxima seção, vamos passar o código atual para um método separado. Um método é uma série de instruções agrupadas que receberam um nome. Você nomeia 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 a seguinte 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);
}

A linha WorkWithIntegers(); invoca o método. O código a seguir declara o método e o define.

Explorar a ordem das operações

Comente a chamada para WorkingWithIntegers(). Isso tornará a saída menos congestionada enquanto você trabalha nesta seção:

//WorkWithIntegers();

O // inicia um comentário em C#. Os comentários são qualquer texto que você queira manter em seu código-fonte, mas não queria executar como código. O compilador não gera nenhum código executável a partir dos comentários. Como WorkWithIntegers() é um método, você precisa apenas comentar uma linha.

A linguagem C# define a precedência de operações matemáticas diferentes com regras consistentes às 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 a WorkWithIntegers() após a chamada e executando dotnet run:

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 diferente de operações, adicionando parênteses para delimitar a operação, ou operações, que você quer realizar 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 run novamente.

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

Talvez você tenha observado um comportamento interessante com relação aos 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ê ainda não viu esse comportamento, tente o seguinte:

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

Digite dotnet run novamente para ver os resultados.

Antes de avançarmos, pegue todo código que você escreveu nesta seção e coloque-o em um novo método. Chame esse novo método de 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 de inteiros e limites

Esse último exemplo mostrou que uma divisão de inteiros trunca o resultado. Você pode obter o restante usando o operador module, o caractere %. Tente o seguinte código após a chamada de 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 de inteiro C# difere do inteiros matemáticos de outra forma: o tipo int tem limites mínimo e máximo. Adicione este 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 excede esses limites, você terá uma condição de estouro negativo ou estouro. A resposta parece quebrar de um limite para o outro. Adicione estas duas linhas para ver um exemplo:

int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");

Observe que a resposta é muito próxima do mínimo inteiro (negativo). É o mesmo que min + 2. A operação de adição estourou os valores permitidos para números inteiros. A resposta é um número negativo muito 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ê usaria quando o tipo int não atendesse às suas necessidades. Vamos explorar esses outros tipos em seguida. Antes de iniciar a próxima seção, mova o código que você escreveu nesta seção para um método separado. Nomeie-o como TestLimits.

Trabalhar com o tipo Double

O tipo numérico double representa um número de ponto flutuante de precisão dupla. Esses termos podem ser novidade 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. Os números de precisão dupla têm o dobro do número de dígitos binários do que os de precisão simples. Em computadores modernos, é mais comum usar números de precisão dupla do que de precisão simples. Números de precisão simples são declarados usando a palavra-chave float. 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 duplos:

double e = 19;
double f = 23;
double g = 8;
double h = (e + f) / g;
Console.WriteLine(h);

O intervalo de um valor duplo é muito maior do que valores inteiros. Experimente o código a seguir abaixo do código que você escreveu até o momento:

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 do E é o significando. O número à direita é o expoente, como uma potência de 10. Assim como os números decimais em matemática, os duplos em C# podem ter erros de arredondamento. Experimente esse código:

double third = 1.0 / 3.0;
Console.WriteLine(third);

Você sabe que 0.3 repetido um número finito de vezes não é exatamente o mesmo que 1/3.

Desafio

Experimente outros cálculos com números grandes, números pequenos, multiplicação e divisão usando o tipo double. Experimente cálculos mais complicados. Após algum tempo no desafio, pegue o código que você escreveu e coloque-o em um novo método. Chame esse novo método de 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 tipo decimal tem um intervalo menor, mas precisão maior do 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 do que o tipo double. Veja a precisão maior com o tipo decimal experimentando o código a seguir:

double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);

decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);

O sufixo M nos números é o modo como você indica que uma constante deve usar o tipo decimal. Caso contrário, o compilador assumirá o tipo double.

Observação

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

Observe que o cálculo usando o tipo decimal tem mais dígitos à direita da vírgula decimal.

Desafio

Agora que você viu os diferentes tipos numéricos, escreva um 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 quadrado do raio 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 esse motivo, você deve usar valores double em vez de decimal para esse desafio.

Você deve obter uma resposta entre 19 e 20. Confira sua resposta analisando o código de exemplo finalizado no GitHub.

Experimente outras fórmulas, se quiser.

Você concluiu o início rápido "Números em C#". Continue com o início rápido Branches e loops em seu próprio ambiente de desenvolvimento.

Saiba mais sobre os números em C# nos artigos a seguir: