Como utilizar números inteiros e de vírgula flutuante em C#

Artigo
06/21/2023

Este tutorial explica-lhe os tipos numéricos em C#. Irá escrever pequenas quantidades de código e, em seguida, 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-lhe as noções básicas da linguagem C#.

Dica

Para colar um fragmento de código no modo de detalhe , deve utilizar o atalho de teclado (Ctrl + v ou cmd + v).

Pré-requisitos

O tutorial espera que tenha uma máquina configurada para desenvolvimento local. Veja Configurar o ambiente local para obter instruções de instalação e uma descrição geral do desenvolvimento de aplicações no .NET.

Se não quiser configurar um ambiente local, veja a versão interativa no browser deste tutorial.

Explorar operações matemáticas com números inteiros

Crie um diretório com o nome numbers-quickstart. Torne-o no diretório atual e execute o seguinte comando:

dotnet new console -n NumbersInCSharp -o .

Importante

Os modelos C# para .NET 6 utilizam instruções de nível superior. A aplicação poderá não corresponder ao código neste artigo, se já tiver atualizado para o .NET 6. Para obter mais informações, veja o artigo sobre Novos modelos C# para gerar instruções de nível superior

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

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

Estas diretivas implícitas global using incluem os espaços de nomes mais comuns para o tipo de projeto.

Para obter mais informações, veja o artigo sobre Diretivas de utilização implícita

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

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

Execute este código ao escrever dotnet run na janela de comandos.

Viu uma das operações matemáticas fundamentais com números inteiros. O int tipo representa um número inteiro, zero, positivo ou negativo. Utilize o símbolo + para a soma. Outras operações matemáticas comuns com números inteiros incluem:

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

Comece por explorar as várias 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);

Execute este código ao escrever dotnet run na janela de comandos.

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

Dica

À medida que explora o C# (ou qualquer linguagem de programação), irá cometer erros quando escreve código. O compilador irá encontrar esses erros e comunicá-los a si. Quando o resultado contiver mensagens de erro, observe atentamente o código de exemplo e o código na janela para ver o que corrigir. Esse exercício irá ajudá-lo a aprender a estrutura do código C#.

Terminou o primeiro passo. Antes de começar a secção seguinte, vamos mover o código atual para um método separado. Um método é uma série de instruções agrupadas e é atribuído um nome. Chama um método ao escrever o nome do método seguido de (). Organizar o código em métodos torna mais fácil começar a trabalhar com um novo exemplo. Quando terminar, o código deverá ter o seguinte aspeto:

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 seguinte declara o método e define-o.

Explorar a ordem das operações

Comente a chamada para WorkingWithIntegers(). Irá tornar o resultado menos desordenado à medida que trabalha nesta secção:

//WorkWithIntegers();

O // inicia um comentário em C#. Os comentários são qualquer texto que pretenda 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. Uma WorkWithIntegers() vez que é um método, só tem de comentar uma linha.

A linguagem C# define a precedência das várias operações matemáticas com regras que são idênticas às que aprendeu nas aulas de matemática. A multiplicação e a divisão têm precedência sobre a soma e a subtração. Explore-o ao adicionar o seguinte código após a chamada para WorkWithIntegers()e ao executar 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 é feita antes da soma.

Pode forçar uma ordem de operação diferente ao adicionar parênteses à volta da operação ou operações que pretende que sejam executadas primeiro. Adicione as seguintes linhas e execute novamente:

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

Junte muitas operações diferentes para explorar mais. Adicione algo semelhante às seguintes linhas. Tente dotnet run novamente.

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

Poderá ter reparado que ocorreu um comportamento interessante relativamente aos números inteiros. A divisão de números inteiros produz sempre um resultado inteiro, mesmo se fosse de esperar que o resultado incluísse uma casa decimal ou uma fração.

Se ainda 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);

Escreva dotnet run novamente para ver os resultados.

Antes de seguir em frente, vamos pegar em todo o código que escreveu nesta secção e colocá-lo num novo método. Chame a esse novo método OrderPrecedence. O seu código deverá ter um aspeto semelhante ao seguinte:

// 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 dos números inteiros

O último exemplo mostrou que a divisão do número inteiro trunca o resultado. Pode obter o resto com o operador modulo , o % caráter . 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 de número inteiro de C# tem ainda outra diferença face aos números inteiros matemáticos - o tipo int tem limites mínimos e máximos. 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 exceda esses limites, terá uma condição de underflow ou overflow. A resposta parece ajustar-se de um limite ao outro. Adicione estas duas linhas para ver um exemplo:

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

Repare que a resposta está muito próxima do número inteiro mínimo (negativo). É o mesmo que min + 2. A operação de soma excedeu (overflow) os valores permitidos para os números inteiros. A resposta é um número negativo muito grande, porque um “overflow” ajustou desde o valor de número inteiro maior possível para o mais pequeno.

Existem outros tipos numéricos com limites diferente e precisão que poderá utilizar se o tipo int não satisfizer as suas necessidades. Vamos explorar esses outros tipos a seguir. Antes de começar a secção seguinte, mova o código que escreveu nesta secção para um método separado. Dê-lhe o nome TestLimits.

Trabalhar com o tipo duplo

O tipo numérico double representa um número de vírgula flutuante de precisão dupla. Poderá ainda não ter ouvido falar destes termos. Os números de vírgula flutuante são úteis para representar números fracionários cuja magnitude pode ser muito grande ou pequena. Precisão dupla é um termo relativo que descreve o número de dígitos binários utilizados para armazenar o valor. Os números de precisão dupla têm o dobro do número de dígitos binários como precisão única. Nos computadores modernos, é mais comum utilizar precisão dupla do que números de precisão simples. Os números de precisão únicos são declarados com 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);

Repare que a resposta inclui a parte decimal do quociente. Experimente uma expressão ligeiramente mais complicada com tipo duplo:

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

A amplitude dos valores duplos é muito superior à dos valores de números inteiros. Experimente o seguinte código abaixo do 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 na notação científica. O número à esquerda de E é a mantissa. O número à direita é o expoente, à potência de 10. Tal como os números decimais na matemática, os tipos duplos em C# têm erros de arredondamento. Experimente este código:

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

Sabe que 0.3 repetir o número finito de vezes não é exatamente o mesmo 1/3que .

Desafio

Experimente outros cálculos com números grandes, números pequenos, multiplicação e divisão com o double tipo . Experimente cálculos mais complexos. Depois de ter passado algum tempo com o desafio, pegue no código que escreveu e coloque-o num novo método. Atribua um nome ao novo método WorkWithDoubles.

Trabalhar com tipos decimais

Viu os tipos numéricos básicos em C#, os números inteiros e duplos. Existe outro tipo para aprender: o decimal tipo. O tipo decimal tem uma amplitude mais pequena, mas uma precisão superior a double. Vamos ver:

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

Repare que a amplitude é inferior à do tipo double. Pode experimentar o código abaixo para ver a precisão melhor com o tipo decimal:

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

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

É com o sufixo M nos números que indicamos que uma constante deverá utilizar o tipo decimal. Caso contrário, o compilador assume o double tipo.

Nota

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

Repare que a expressão matemática que utiliza o tipo decimal tem mais dígitos à direita da casa decimal.

Desafio

Agora que já viu os diferentes tipos numéricos, escreva um código que calcule a área de um círculo cujo raio são 2,50 centímetros. Lembre-se de que a área de um círculo é igual ao raio elevado ao quadrado a multiplicar por PI. Uma sugestão: .NET contém uma constante para PI, Math.PI, que pode utilizar nesse valor. Math.PI, como todas as constantes declaradas no System.Math espaço de nomes, é um double valor. Por esse motivo, deve utilizar double em vez de decimal valores para este desafio.

Deverá obter uma resposta entre 19 e 20. Pode verificar a sua resposta ao ver o código de exemplo concluído no GitHub.

Experimente outras fórmulas, se quiser.

Concluiu o início rápido "Números em C#". Pode continuar com o início rápido Ramos e ciclos no seu próprio ambiente de desenvolvimento.

Pode saber mais sobre números em C# nos seguintes artigos:

Partilhar via