Operadores C#

Neste artigo, aprenderemos tudo sobre os diferentes tipos de operadores na linguagem de programação C# e como usá-los.

Operadores são símbolos usados para realizar operações em operandos. Os operandos podem ser variáveis e/ou constantes.

Por exemplo , em 2+3 , + é um operador que é usado para realizar operações de adição, enquanto 2 e 3 são operandos.

Os operadores são usados para manipular variáveis e valores em um programa. C# oferece suporte a vários operadores que são classificados com base no tipo de operações que eles executam.

1. Operador de Atribuição Básica

O operador de atribuição básico (=) é usado para atribuir valores a variáveis. Por exemplo,

double x;
x = 50.05;

Aqui, 50,05 é atribuído a x.

Exemplo 1:Operador de Atribuição Básica

using System;

namespace Operator
{
	class AssignmentOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber, secondNumber;
			// Assigning a constant to variable
			firstNumber = 10;
			Console.WriteLine("First Number = {0}", firstNumber);

			// Assigning a variable to another variable
			secondNumber = firstNumber;
			Console.WriteLine("Second Number = {0}", secondNumber);
		}
	}
}

Ao executarmos o programa, a saída será:

First Number = 10
Second Number = 10

Este é um exemplo simples que demonstra o uso do operador de atribuição.

Você deve ter notado o uso de chaves { } no exemplo. Discutiremos sobre eles em formatação de string . Por enquanto, lembre-se de que {0} é substituído pela primeira variável que segue a string, {1} é substituído pela segunda variável e assim por diante.

2. Operadores aritméticos

Os operadores aritméticos são usados para realizar operações aritméticas como adição, subtração, multiplicação, divisão, etc.

Por exemplo,

int x = 5;
int y = 10;
int z = x + y;// z = 15

Operadores aritméticos C#
Operador	Nome do Operador	Exemplo
+	Operador de adição	6 + 3 avalia como 9
-	Operador de subtração	10 - 6 avalia para 4
*	Operador de multiplicação	4 * 2 avalia como 8
/	Operador de divisão	10/5 avalia como 2
%	Operador de módulo (restante)	16 % 3 avalia para 1

Exemplo 2:operadores aritméticos

using System;
 
namespace Operator
{
	class ArithmeticOperator
	{
		public static void Main(string[] args)
		{
			double firstNumber = 14.40, secondNumber = 4.60, result;
			int num1 = 26, num2 = 4, rem;

			// Addition operator
			result = firstNumber + secondNumber;
			Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

			// Subtraction operator
			result = firstNumber - secondNumber;
			Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

			// Multiplication operator
			result = firstNumber * secondNumber;
			Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

			// Division operator
			result = firstNumber / secondNumber;
			Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

			// Modulo operator
			rem = num1 % num2;
			Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
		}
	}
}

Ao executarmos o programa, a saída será:

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

As operações aritméticas são realizadas no exemplo acima. As variáveis podem ser substituídas por constantes nas instruções. Por exemplo,

result = 4.5 + 2.7 ; // result will hold 7.2
result = firstNumber - 3.2; // result will hold 11.2

3. Operadores Relacionais

Operadores relacionais são usados para verificar a relação entre dois operandos. Se a relação for verdadeira, o resultado será true , caso contrário resultará em false .

Operadores relacionais são usados na tomada de decisão e loops.

Operadores Relacionais C#
Operador	Nome do Operador	Exemplo
==	Igual a	6 ==4 avalia como falso
>	Maior que	3> -1 é avaliado como verdadeiro
	Menor que	5 <3 é avaliado como falso
>=	Maior ou igual a	4>=4 é avaliado como verdadeiro
<=	Menor ou igual a	5 <=3 é avaliado como falso
!=	Não é igual a	10 !=2 é avaliado como verdadeiro

Exemplo 3:Operadores Relacionais

using System;
 
namespace Operator
{
	class RelationalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			result = (firstNumber==secondNumber);
			Console.WriteLine("{0} == {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber > secondNumber);
			Console.WriteLine("{0} > {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber < secondNumber);
			Console.WriteLine("{0} < {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber >= secondNumber);
			Console.WriteLine("{0} >= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber <= secondNumber);
			Console.WriteLine("{0} <= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber != secondNumber);
			Console.WriteLine("{0} != {1} returns {2}",firstNumber, secondNumber, result);
		}
	}
}

Ao executarmos o programa, a saída será:

10 == 20 returns False
10 > 20 returns False
10 < 20 returns True
10 >= 20 returns False
10 <= 20 returns True
10 != 20 returns True

4. Operadores lógicos

Operadores lógicos são usados para realizar operações lógicas como and , or . Operadores lógicos operam em expressões booleanas (true e false ) e retorna valores booleanos. Operadores lógicos são usados na tomada de decisão e loops.

Aqui está como o resultado é avaliado para lógica AND e OR operadores.

Operadores lógicos C#
Operando 1	Operando 2	OU (\|\|)	AND (&&)
verdadeiro	verdadeiro	verdadeiro	verdadeiro
verdadeiro	falso	verdadeiro	falso
falso	verdadeiro	verdadeiro	falso
falso	falso	falso	falso

Em palavras simples, a tabela pode ser resumida como:

Se um dos operandos for verdadeiro, o OR operador irá avaliá-lo para true .
Se um dos operandos for falso, o AND operador irá avaliá-lo para false .

Exemplo 4:operadores lógicos

using System;
 
namespace Operator
{
	class LogicalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			// OR operator
			result = (firstNumber == secondNumber) || (firstNumber > 5);
			Console.WriteLine(result);

			// AND operator
			result = (firstNumber == secondNumber) && (firstNumber > 5);
			Console.WriteLine(result);
		}
	}
}

Ao executarmos o programa, a saída será:

True
False

5. Operadores Unários

Ao contrário de outros operadores, os operadores unários operam em um único operando.

Operadores unários C#
Operador	Nome do Operador	Descrição
+	Unário Plus	Deixa o sinal do operando como está
-	Menos Unário	Inverte o sinal do operando
++	Incrementar	Incrementar o valor em 1
--	Diminuir	Diminuir o valor em 1
!	Negação lógica (não)	Inverte o valor de um booleano

Exemplo 5:Operadores Unários

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10, result;
			bool flag = true;

			result = +number;
			Console.WriteLine("+number = " + result);

			result = -number;
			Console.WriteLine("-number = " + result);

			result = ++number;
			Console.WriteLine("++number = " + result);

			result = --number;
			Console.WriteLine("--number = " + result);

			Console.WriteLine("!flag = " + (!flag));
		}
	}
}

Ao executarmos o programa, a saída será:

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

O incremento (++) e decrementar (--) operadores podem ser usados como prefixo e postfix. Se usado como prefixo, a mudança no valor da variável é vista na mesma linha e se usado como postfix, a mudança no valor da variável é vista na próxima linha. Isso ficará claro pelo exemplo abaixo.

Exemplo 6:operadores Post e Pre Increment em C#

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			Console.WriteLine((number++));
			Console.WriteLine((number));

			Console.WriteLine((++number));
			Console.WriteLine((number));
		}
	}
}

Ao executarmos o programa, a saída será:

Podemos ver o efeito de usar ++ como prefixo e posfixo. Quando ++ é usado após o operando, o valor é avaliado primeiro e depois é incrementado por 1 . Daí a afirmação

Console.WriteLine((number++));

imprime 10 em vez de 11 . Depois que o valor é impresso, o valor do número é incrementado em 1 .

O processo é oposto quando ++ é usado como prefixo. O valor é incrementado antes da impressão. Daí a afirmação

Console.WriteLine((++number));

imprime 12 .

O caso é o mesmo para o operador de decremento (--) .

6. Operador Ternário

O operador ternário ? : opera em três operandos. É um atalho para if-then-else declaração. O operador ternário pode ser usado da seguinte forma:

variable = Condition? Expression1 : Expression2;

O operador ternário funciona da seguinte forma:

Se a expressão indicada por Condição for true , o resultado de Expressão1 é atribuído à variável.
Se for false , o resultado de Expressão2 é atribuído à variável.

Exemplo 7:Operador Ternário

using System;
 
namespace Operator
{
	class TernaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;
			string result;

			result = (number % 2 == 0)? "Even Number" : "Odd Number";
			Console.WriteLine("{0} is {1}", number, result);
		}
	}
}

Ao executarmos o programa, a saída será:

10 is Even Number

Para saber mais, visite C# operador ternário .

7. Operadores de deslocamento bit a bit

Os operadores bit a bit e bit shift são usados para realizar operações de manipulação de bits.

Operadores C# Bitwise e Bit Shift
Operador	Nome do Operador
~	Complemento bit a bit
&	Bit a bit E
\|	OU bit a bit
^	Exclusivo bit a bit OU
<<	Deslocamento à esquerda bit a bit
>>	Deslocamento à direita bit a bit

Exemplo 8:Operador Bitwise e Bit Shift

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber = 10;
			int secondNumber = 20;
			int result;

			result = ~firstNumber;
			Console.WriteLine("~{0} = {1}", firstNumber, result);

			result = firstNumber & secondNumber;
			Console.WriteLine("{0} & {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber | secondNumber;
			Console.WriteLine("{0} | {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber ^ secondNumber;
			Console.WriteLine("{0} ^ {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber << 2;
			Console.WriteLine("{0} << 2 = {1}", firstNumber, result);

			result = firstNumber >> 2;
			Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
		}
	}
}

Ao executarmos o programa, a saída será:

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

Para saber mais, visite Operador C# Bitwise e Bit Shift .

8. Operadores de atribuição composta

Operadores de atribuição composta C#
Operador	Nome do Operador	Exemplo	Equivalente a
+=	Atribuição de Adição	`x += 5`	`x = x + 5`
-=	Atribuição de Subtração	`x -= 5`	`x = x - 5`
*=	Atribuição de Multiplicação	`x *= 5`	`x = x * 5`
/=	Atribuição de Divisão	`x /= 5`	`x = x / 5`
%=	Atribuição do módulo	`x %= 5`	`x = x % 5`
&=	Atribuição E bit a bit	`x &= 5`	`x = x & 5`
\|=	Atribuição OU bit a bit	`x \|= 5`	`x = x \| 5`
^=	Atribuição XOR bit a bit	`x ^= 5`	`x = x ^ 5`
<<=	Atribuição de turno à esquerda	`x <<= 5`	`x = x << 5`
>>=	Atribuição de turno à direita	`x >>= 5`	`x = x >> 5`
=>	Operador Lambda	`x => x*x`	`Returns x*x`

Exemplo 9:Operador de Atribuição Composto

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			number += 5;
			Console.WriteLine(number);

			number -= 3;
			Console.WriteLine(number);

			number *= 2;
			Console.WriteLine(number);

			number /= 3;
			Console.WriteLine(number);

			number %= 3;
			Console.WriteLine(number);

			number &= 10;
			Console.WriteLine(number);

			number |= 14;
			Console.WriteLine(number);

			number ^= 12;
			Console.WriteLine(number);

			number <<= 2;
			Console.WriteLine(number);

			number >>= 3;
			Console.WriteLine(number);
		}
	}
}

Ao executarmos o programa, a saída será:

Discutiremos sobre operadores Lambda em tutorial posterior.

Variáveis C# e tipos de dados (primitivos) Precedência e associatividade do operador C#

Linguagem C