Operadores (Guia de Programação em C#)
Em C#, um operador é um elemento de programa aplicado a um ou mais operandos em uma expressão ou instrução. Os operadores que usam um operando, como o operador de incremento (++) ou new, são referidos como operadores unários. Os operadores que usam dois operandos, como operadores aritméticos (+,-,*,/), são referidos como operadores binários. Um operador, o operador condicional (?:), usa três operandos e é o único operador ternário em C#.
A seguinte instrução de C# contém um único operador unário e um operando único. O operador de incremento, ++, modifica o valor do operando y.
y++;
A seguinte instrução de C# contém dois operadores binários, cada um com dois operandos. O operador de atribuição, =, contém a variável inteira y e a expressão 2 + 3 como operandos. A expressão 2 + 3 em si consiste no operador de adição e dois operandos, 2 e 3.
y = 2 + 3;
Operadores, avaliação e precedência de operadores
Um operando pode ser uma expressão válida composta por qualquer comprimento de código e pode incluir qualquer número de subexpressões. Em uma expressão que contém vários operadores, a ordem em que os operadores são aplicados é determinada pela precedência de operadores, associatividade e parênteses.
Cada operador possui uma precedência definida. Em uma expressão com vários operadores e diferentes níveis de precedência, a precedência dos operadores determina a ordem em que os operadores são avaliados. Por exemplo, a seguinte instrução atribui 3 a n1.
n1 = 11 - 2 * 4;
A multiplicação é executada primeiro porque ela tem precedência sobre a subtração.
A tabela a seguir separa os operadores em categorias com base no tipo de operação que eles executam. As categorias são listadas em ordem de precedência.
Operadores primários
Expressão |
Descrição |
|---|---|
x.y |
Acesso de membros |
f(x) |
Invocação de método e delegado |
a[x] |
Acesso de matriz e indexador |
x++ |
Pós-incremento |
x-- |
Pós-decremento |
novo T (...) |
Criação de objeto e delegado |
new T(...){...} |
Criação de objeto com inicializador. Consulte Inicializadores de objeto e coleção (Guia de Programação em C#). |
new {...} |
Inicializador de objeto anônimo. Consulte Tipos anônimos (Guia de Programação em C#). |
new T[...] |
Criação de matriz. Consulte Matrizes (Guia de Programação em C#). |
typeof(T) |
Obtém objeto System.Type para T |
selecionado(x) |
Avalia expressão no contexto selecionado |
desmarcado(x) |
Avalia expressão no contexto desmarcado |
padrão (T) |
Obtém valor padrão do tipo T |
delegado {} |
Função anônima (método anônimo) |
Operadores unários
Expressão |
Descrição |
|---|---|
+x |
Identidade |
-x |
Negação |
!x |
Negação lógica |
~x |
Negação bit a bit |
++x |
Pré-incremento |
--x |
Pré-decremento |
(T)x |
Converte explicitamente x no tipo T |
Operadores de multiplicação
Expressão |
Descrição |
|---|---|
Multiplicação |
|
Divisão |
|
Restante |
Operadores aditivos
Expressão |
Descrição |
|---|---|
x + y |
Adição, concatenação de cadeia de caracteres, combinação de delegados |
x - y |
Subtração, remoção de delegado |
Operadores Shift
Expressão |
Descrição |
|---|---|
x << y |
Shift esquerdo |
x >> y |
Shift direito |
Operadores de tipo e relacionais
Expressão |
Descrição |
|---|---|
x < y |
Menor que |
x > y |
Maior que |
x <= y |
Menor que ou igual a |
x >= y |
Maior que ou igual a |
x é T |
Retorna true se x for T, caso contrário, false |
x como T |
Retorna x digitado como T ou nulo se x não for T |
Operadores de igualdade
Expressão |
Descrição |
|---|---|
x == y |
Igual |
x != y |
Não é igual a |
Operadores lógicos, condicionais e nulos
Categoria |
Expressão |
Descrição |
|---|---|---|
AND lógico |
x & y |
AND bit a bit inteiro, AND lógico booliano |
XOR lógico |
x ^ y |
XOR bit a bit inteiro, XOR lógico booliano |
OR lógico |
x | y |
OR bit a bit inteiro, OR lógico booliano |
AND condicional |
x & & y |
Avalia y somente se x for true |
OR condicional |
x || y |
Avalia y somente se x for false |
Coalescência nula |
x ?? y |
Avalia como y se x for nulo, caso contrário, como x |
Condicional |
x ?: y : z |
Avalia como y se x for true, z se x for false |
Operadores de atribuição e anônimos
Expressão |
Descrição |
|---|---|
Atribuição |
|
x op= y |
Atribuição composta. Supports these operators: +=, -=, *=, /=, %=, &=, |=, !=, <<=, >>= |
(T x) => y |
Função anônima (expressão lambda) |
Associatividade
Quando dois ou mais operadores com a mesma precedência estiverem presentes em uma expressão, eles serão avaliados com base em associatividade. Os operadores associativos esquerdos são avaliados em ordem da esquerda para a direita. Por exemplo, x * y / z é avaliado como (x * y) / z. Os operadores associativos direitos são avaliados em ordem da direita para a esquerda. Por exemplo, o operador de atribuição é associativo direito. Se ele não fosse, o código a seguir resultaria em um erro.
int a, b, c;
c = 1;
// The following two lines are equivalent.
a = b = c;
a = (b = c);
// The following line, which forces left associativity, causes an error.
//(a = b) = c;
Como outro exemplo do operador ternário (?:) é associativo direito. A maioria dos operadores binários permanecem associativos.
Se os operadores em uma expressão forem associativos direitos ou esquerdos, os operandos de cada expressão serão avaliados primeiro, da esquerda para a direita. Os exemplos a seguir ilustram a ordem de avaliação de operadores e operandos.
Instrução |
Ordem de avaliação |
|---|---|
a = b |
a, b, = |
a = b + c |
a, b, c, +, = |
a = b + c * d |
a, b, c, d, *, +, = |
a = b * c + d |
a, b, c, *, d, +, = |
a = b - c + d |
a, b, c, -, d, +, = |
a += b -= c |
a, b, c, -=, += |
Adicionando parênteses
Você pode alterar a ordem imposta pela precedência de operadores e a associatividade ao usar parênteses. Por exemplo, 2 + 3 * 2 resulta normalmente em 8, pois operadores multiplicativos têm precedência sobre operadores aditivos. No entanto, se você escrever a expressão como (2 + 3) * 2, a adição será avaliada antes da multiplicação e o resultado será 10. Os exemplos a seguir ilustram a ordem de avaliação em expressões com parênteses. Como nos exemplos anteriores, os operandos são avaliados antes que o operador seja aplicado.
Instrução |
Ordem de avaliação |
|---|---|
a = (b + c) * d |
a, b, c, +, d, *, = |
a = b - (c + d) |
a, b, c, d, +, -, = |
a = (b + c) * (d - e) |
a, b, c, +, d, e, -, *, = |
Sobrecarga de operador
Você pode alterar o comportamento dos operadores para classes e structs personalizados. Esse processo é chamado sobrecarga de operador. Para obter mais informações, consulte Operadores sobrecarregáveis (Guia de Programação em C#).
Seções relacionadas
Para obter mais informações, consulte Palavras-chave de operador (Referência de C#) e Operadores em C#.
Consulte também
Referência
Instruções, expressões e operadores (Guia de Programação em C#)