Partilhar via

Operadores aritméticos (referência C#)

Os operadores a seguir executam operações aritméticas com operandos de tipos numéricos:

  • Operadores unários ++ (mais) e -- (menos)
  • Operadores binários (multiplicação), *

Todos os tipos numéricos integrais e de vírgula flutuante suportam estes operadores.

Os inttipos , uint, long, e ulong definem todos esses operadores. Os outros tipos integrais (sbyte, byte, short, ushort, e char) definem apenas os operadores ++ e --. Para os outros operadores, se usar os tipos sbyteinteiros , byte, short, ushort, ou char como operandos, os valores são convertidos para o int tipo e o tipo de resultado é int. Se os operandos forem tipos diferentes de integral ou ponto flutuante, os seus valores são convertidos para o tipo contendo mais próximo, caso tal tipo exista. Para obter mais informações, consulte a seção Promoções numéricas da especificação da linguagem C#. Os ++ operadores e -- são definidos para todos os tipos numéricos integrais e de vírgula flutuante e o tipo char . O tipo de resultado de uma expressão de atribuição composta é o tipo do operando esquerdo.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em versões preliminares públicas para a próxima versão da linguagem.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

Operador de incremento ++

O operador ++ de incremento unário incrementa seu operando em 1. O operando deve ser uma variável, um acesso de propriedade ou um acesso de indexador .

O operador de incremento é suportado de duas formas: o operador de incremento postfix, x++e o operador de incremento de prefixo, ++x.

Operador de incremento Postfix

O resultado de é o valor de antesx++operação, como mostra o exemplo a x seguir:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i);   // output: 4

Operador de incremento de prefixo

O resultado de ++x é o valor de após a operação, como mostra o exemplo a xseguir:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a);   // output: 2.5

Operador de decréscimo --

O operador -- de decréscimo unário diminui seu operando em 1. O operando deve ser uma variável, um acesso de propriedade ou um acesso de indexador .

O operador de decremento está disponível em duas formas: o operador de decremento pós-fixo, x--, e o operador decremento prefixo, --x.

Operador de decréscimo Postfix

O resultado de é o valor de antesx--operação, como mostra o exemplo a x seguir:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i);   // output: 2

Operador de decréscimo de prefixo

O resultado de --x é o valor de após a operação, como mostra o exemplo a xseguir:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a);   // output: 0.5

Unary mais e menos operadores

O operador unário + retorna o valor de seu operando. O operador unário - calcula a negação numérica de seu operando.

Console.WriteLine(+4);     // output: 4

Console.WriteLine(-4);     // output: -4
Console.WriteLine(-(-4));  // output: 4

uint a = 5;
var b = -a;
Console.WriteLine(b);            // output: -5
Console.WriteLine(b.GetType());  // output: System.Int64

Console.WriteLine(-double.NaN);  // output: NaN

O tipo ulong não suporta o operador unário - .

Operador de multiplicação *

O operador * de multiplicação calcula o produto de seus operandos:

Console.WriteLine(5 * 2);         // output: 10
Console.WriteLine(0.5 * 2.5);     // output: 1.25
Console.WriteLine(0.1m * 23.4m);  // output: 2.34

O operador unário * é o operador indirection do ponteiro.

Operador de divisão /

O operador / de divisão divide seu operando esquerdo pelo operando direito.

Divisão inteira

Para os operandos de tipos inteiros, o resultado do / operador é de tipo inteiro e é igual ao quociente dos dois operandos arredondados para zero:

Console.WriteLine(13 / 5);    // output: 2
Console.WriteLine(-13 / 5);   // output: -2
Console.WriteLine(13 / -5);   // output: -2
Console.WriteLine(-13 / -5);  // output: 2

Para obter o quociente dos dois operandos como número de ponto flutuante, use o float, double, ou decimal tipo:

Console.WriteLine(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Console.WriteLine((double)a / b);  // output: 2.6

Divisão de vírgula flutuante

Para os float, , e decimal tipos, o / operador devolve o quociente dos dois doubleoperandos:

Console.WriteLine(16.8f / 4.1f);   // output: 4.097561
Console.WriteLine(16.8d / 4.1d);   // output: 4.09756097560976
Console.WriteLine(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Se um operando for decimal, o outro operando não pode ser float ou double, porque nem float nem double tem uma conversão implícita para decimal. Você deve converter explicitamente o float operando ou double para o decimal tipo. Para obter mais informações sobre conversões entre tipos numéricos, consulte Conversões numéricas internas.

Operador remanescente %

O operador % restante calcula o restante depois de dividir seu operando esquerdo por seu operando direito.

Inteiro restante

Para operandos de tipos inteiros, o resultado de a % b é o valor produzido por $a - \frac{a}{b} \vezes b$. O sinal do resto não nulo corresponde ao sinal do operando da esquerda, como mostra o seguinte exemplo:

Console.WriteLine(5 % 4);   // output: 1
Console.WriteLine(5 % -4);  // output: 1
Console.WriteLine(-5 % 4);  // output: -1
Console.WriteLine(-5 % -4); // output: -1

Use o método para calcular a divisão inteira e os Math.DivRem resultados restantes.

Remanescente de vírgula flutuante

Para os float e double operandos, o resultado de x % y para o finito x e y é o valor z tal que

  • O sinal de z, se não nulo, corresponde ao sinal de x.
  • O valor absoluto de z provém do cálculo $|x| - n \vezes |y|$, onde n é o maior inteiro menor ou igual a $\frac{|x|}{|y|}$. Aqui, $|x|$ e $|y|$ representam os valores absolutos de x e y, respetivamente.

Nota

Este método de cálculo do resto é semelhante ao método usado para operandos inteiros, mas difere da especificação IEEE 754. Se você precisar da operação restante que esteja em conformidade com a especificação IEEE 754, use o Math.IEEERemainder método.

Para obter informações sobre o % comportamento do operador com operandos não finitos, consulte a seção Operador restante da especificação da linguagem C#.

Para decimal operandos, o operador % do resto funciona da mesma forma que o operador do resto do System.Decimal tipo.

O exemplo seguinte demonstra como o operador do resto se comporta com operandos de ponto flutuante:

Console.WriteLine(-5.2f % 2.0f); // output: -1.2
Console.WriteLine(5.9 % 3.1);    // output: 2.8
Console.WriteLine(5.9m % 3.1m);  // output: 2.8

Operador de adição +

O operador + de adição calcula a soma de seus operandos:

Console.WriteLine(5 + 4);       // output: 9
Console.WriteLine(5 + 4.3);     // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3

Você também pode usar o + operador para concatenação de cadeia de caracteres e combinação de delegação. Para obter mais informações, consulte o + artigo e += operadores .

Operador de subtração -

O operador - de subtração subtrai o operando da direita do operando da esquerda:

Console.WriteLine(47 - 3);      // output: 44
Console.WriteLine(5 - 4.3);     // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2

Também pode usar o - operador para remover um delegado. Para mais informações, consulte os- operadores e -=.

Atribuição composta

Para um operador opbinário , uma expressão de atribuição composta do formulário

x op= y

É equivalente a

x = x op y

Só que x só é avaliada uma vez.

O exemplo a seguir demonstra o uso de atribuição composta com operadores aritméticos:

int a = 5;
a += 9;
Console.WriteLine(a);  // output: 14

a -= 4;
Console.WriteLine(a);  // output: 10

a *= 2;
Console.WriteLine(a);  // output: 20

a /= 4;
Console.WriteLine(a);  // output: 5

a %= 3;
Console.WriteLine(a);  // output: 2

Devido a promoções numéricas, o resultado da op operação pode não ser implicitamente convertível para o tipo T de x. Nesse caso, se op for um operador predefinido e o resultado da operação for explicitamente conversível para o tipo T de , uma expressão de xatribuição composta do formulário x op= y é equivalente a x = (T)(x op y), exceto que x é avaliada apenas uma vez. O exemplo a seguir demonstra esse comportamento:

byte a = 200;
byte b = 100;

var c = a + b;
Console.WriteLine(c.GetType());  // output: System.Int32
Console.WriteLine(c);  // output: 300

a += b;
Console.WriteLine(a);  // output: 44

No exemplo anterior, value 44 é o resultado da conversão de value 300 para o byte tipo.

Nota

No contexto de verificação de estouro verificado, o exemplo anterior lança um OverflowExceptionarquivo . Para obter mais informações, consulte a seção Estouro aritmético de inteiros.

Você também usa os += operadores e -= para se inscrever e cancelar a assinatura de um evento, respectivamente. Para obter mais informações, consulte Como se inscrever e cancelar a assinatura de eventos.

Precedência e associatividade do operador

A lista seguinte ordena os operadores aritméticos da precedência mais alta para a precedência mais baixa:

  • Operadores de incremento e decréscimo x++x-- Postfix
  • Operadores de prefixo incremento ++x e decrement--x, e operadores unários -+ e operadores
  • Multiplicativo *, /e % operadores
  • + Aditivos e - operadores

Os operadores aritméticos binários são associados à esquerda. Ou seja, o compilador avalia operadores com o mesmo nível de precedência da esquerda para a direita.

Use parênteses, (), para alterar a ordem de avaliação imposta pela precedência do operador e associatividade.

Console.WriteLine(2 + 2 * 2);   // output: 6
Console.WriteLine((2 + 2) * 2); // output: 8

Console.WriteLine(9 / 5 / 2);   // output: 0
Console.WriteLine(9 / (5 / 2)); // output: 4

Para obter a lista completa de operadores C# ordenados por nível de precedência, consulte a seção Precedência do operador do artigo Operadores C#.

Estouro aritmético e divisão por zero

Quando o resultado de uma operação aritmética está fora do intervalo de possíveis valores finitos do tipo numérico envolvido, o comportamento de um operador aritmético depende do tipo de seus operandos.

Estouro aritmético inteiro

A divisão inteira por zero sempre lança um DivideByZeroException.

Se ocorrer estouro aritmético de inteiros, o contexto de verificação de estouro, que pode ser verificado ou desmarcado, controla o comportamento resultante:

  • Em um contexto verificado, se o estouro acontecer em uma expressão constante, ocorrerá um erro em tempo de compilação. Caso contrário, quando a operação é executada em tempo de execução, um OverflowException é lançado.
  • Em um contexto não verificado, o resultado é truncado descartando quaisquer bits de ordem alta que não se encaixam no tipo de destino.

Nota

A divisão inteira tem um caso especial em que um ArithmeticException pode ser lançado mesmo num contexto não controlado. Quando o operando esquerdo é o valor mínimo de um tipo inteiro assinado (int.MinValue ou long.MinValue) e o operando direito é -1, o resultado não pode ser representado no tipo de destino. O runtime .NET lança um ArithmeticException neste caso, como mostrado no exemplo seguinte:

int a = int.MinValue;
int b = -1;
try
{
    int c = unchecked(a / b);
}
catch (ArithmeticException)
{
    Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}

Junto com as instruções verificadas e não verificadas , você pode usar os checked operadores e unchecked para controlar o contexto de verificação de estouro, no qual uma expressão é avaliada:

int a = int.MaxValue;
int b = 3;

Console.WriteLine(unchecked(a + b));  // output: -2147483646
try
{
    int d = checked(a + b);
}
catch(OverflowException)
{
    Console.WriteLine($"Overflow occurred when adding {a} to {b}.");
}

Por padrão, as operações aritméticas ocorrem em um contexto não verificado .

Estouro aritmético de vírgula flutuante

As operações aritméticas usando os float tipos e double nunca lançam uma exceção. O resultado das operações aritméticas usando esses tipos pode ser um dos valores especiais que representam o infinito e o não-número:

double a = 1.0 / 0.0;
Console.WriteLine(a);                    // output: Infinity
Console.WriteLine(double.IsInfinity(a)); // output: True

Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity

double b = 0.0 / 0.0;
Console.WriteLine(b);                // output: NaN
Console.WriteLine(double.IsNaN(b));  // output: True

Para os operandos do tipo, o decimal estouro aritmético sempre lança um OverflowException. Divisão por zero sempre lança um DivideByZeroException.

Erros de arredondamento

Devido às limitações gerais na representação em vírgula flutuante de números reais e na aritmética em vírgula flutuante, podem ocorrer erros de arredondamento em cálculos que utilizam tipos de vírgula flutuante. O resultado de uma expressão pode diferir do resultado matemático esperado. O exemplo a seguir demonstra vários desses casos:

Console.WriteLine(.41f % .2f); // output: 0.00999999

double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3);   // output: False
Console.WriteLine(b - 0.3);    // output: 5.55111512312578E-17

decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m);  // output: False
Console.WriteLine(d);          // output: 0.9999999999999999999999999999

Para mais informações, consulte as observações nas páginas de referência System.Double, System.Single ou System.Decimal .

Capacidade de sobrecarga do operador

Pode sobrecarregar os operadores aritméticos unários (++, --, +, , e -binários (*, /, %+, , e -) para um tipo definido pelo utilizador. Quando sobrecarregas um operador binário, também sobrecarregas implicitamente o correspondente operador de atribuição composta. A partir de C# 14, um tipo definido pelo utilizador pode explicitamente sobrecarregar os operadores de atribuição composta (op=) para proporcionar uma implementação mais eficiente. Normalmente, um tipo sobrecarrega esses operadores porque o valor pode ser atualizado no local, em vez de alocar uma nova instância para armazenar o resultado da operação. Se um tipo não fornecer uma sobrecarga explícita, o compilador gerará a sobrecarga implícita.

Operadores verificados definidos pelo usuário

Quando sobrecarregas um operador aritmético, podes usar a checked palavra-chave para definir a versão verificada desse operador. O exemplo a seguir mostra como fazer isso:

public record struct Point(int X, int Y)
{
    public static Point operator checked +(Point left, Point right)
    {
        checked
        {
            return new Point(left.X + right.X, left.Y + right.Y);
        }
    }
    
    public static Point operator +(Point left, Point right)
    {
        return new Point(left.X + right.X, left.Y + right.Y);
    }
}

Ao definir um operador verificado, você também deve definir o operador correspondente sem o checked modificador. Um contexto verificado chama o operador verificado, e um contexto não verificado chama o operador sem o checked modificador.

Quando se definem ambas as versões de um operador, o seu comportamento só difere quando o resultado de uma operação é demasiado grande para ser representado no tipo de resultado da seguinte forma:

  • Um operador verificado lança um OverflowExceptionarquivo .
  • Um operador sem o checked modificador retorna uma instância que representa um resultado truncado .

Para obter informações sobre a diferença no comportamento dos operadores aritméticos internos, consulte a seção Estouro aritmético e divisão por zero .

Você pode usar o checked modificador somente quando sobrecarregar qualquer um dos seguintes operadores:

Nota

O checked modificador não afeta o contexto de verificação de overflow dentro do seu corpo. O contexto padrão é definido pelo valor da opção de compilador CheckForOverflowUnderflow. Use as checked and unchecked para especificar explicitamente o contexto de verificação de estouro, como demonstra o exemplo no início desta seção.

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

Consulte também

  • Last updated on