Objetivos
        
    
    
    
        
Expressões e operadores
    
    
        
            
                Para declararmos expressões em qualquer linguagem de programação precisamos utilizar os operadores. 
                Os conceitos de expressões e operadores foram vistos em 
                Portugol: Expressões e Operadores e 
                C. 
                Em caso de dúvida é recomendada a leitura.
            
            
                A linguagem C# utiliza os mesmos operadores básicos da linguagem C/C++, com exceções, para 
                criarmos expressões dos tipos aritméticas, lógicas e relacionais e bit-a-bit e outras. Nesta 
                seção vamos discutir sobre esses operadores.
            
            
                Em P.O.O: Sobrescrita de operadores, vamos aprender a 
                sobrescrever alguns desses operadores para terem comportamento específico em nossas classes.
            
            
                Os operadores relacionais que podem ser utilizados como os comandos de repetição e decisão
                podem ser vistos em C# : Comandos.
            
         
     
    
    
        
            
                Para atribuirmos valores à variáveis e constantes, C# utiliza a tabela de operadores de 
                atribuição abaixo:
            
            
                Tab. 1: Operadores de Atribuição
                
                    
                        | Operador | 
                        Descrição | 
                    
                
                
                    
                        | = | 
                        Atribuição | 
                    
                    
                        | += | 
                        Atribuição acumulativa de adição | 
                    
                    
                        | -= | 
                        Atribuição acumulativa de subtração | 
                    
                    
                        | *= | 
                        Atribuição acumulativa de multiplicação | 
                    
                    
                        | %= | 
                        Atribuição acumulativa de Módulo | 
                    
                    
                        | /= | 
                        Acumulação de divisão | 
                    
                    
                        | |= | 
                        Acumulação de OU bit-a-bit | 
                    
                    
                        | &= | 
                        Acumulação de E bit-a-bit | 
                    
                    
                        | ^= | 
                        Acumulação de Ou-Exclusivo bit-a-bit | 
                    
                    
                        | <<= | 
                        Acumulação de deslocamento | 
                    
                    
                        | >>= | 
                        Acumulação de deslocamento | 
                    
                
            
            Sintaxe
            variavel1 operador= valor | expressão
variavel = valor | expressão
            Exemplo 1
            
using System;
public class Program
{
	public static void Main()
	{
		int valor = 8;
		int valor2 = 2;
		valor += valor2;
		Console.WriteLine(valor);
		valor -= valor2;
		Console.WriteLine(valor);
		valor *= valor2;
		Console.WriteLine(valor);
		valor /= valor2;
		Console.WriteLine(valor);
		valor %= valor2;
		Console.WriteLine(valor);
		valor |= valor2;
		Console.WriteLine(valor);
		valor &= valor2;
		Console.WriteLine(valor);
		valor ^= valor2;
		Console.WriteLine(valor);
		valor >>= valor2;
		Console.WriteLine(valor);
		valor <<= valor2;
		Console.WriteLine(valor);
	}
}
            Saída
            
10
8
16
8
0
2
2
0
0
0
         
     
    
    
        
            
                Para declaração de expressões aritméticas, utilizamos os operadores abaixo fornecidos 
                pela linguagem C#:
            
         
     
    
        
            
                Tab. 2: Operadores Aritméticos
                
                    
                        | Operador | 
                        Descrição | 
                    
                
                
                    
                        | + | 
                        Adição | 
                    
                    
                        | - | 
                        Subtração | 
                    
                    
                        | * | 
                        Multiplicação | 
                    
                    
                        | / | 
                        Divisão | 
                    
                    
                        | % | 
                        Módulo | 
                    
                    
                        | ++ | 
                        Incremento | 
                    
                    
                        | -- | 
                        Decremento | 
                    
                
            
            
                Os operadores -- e ++ utilizados antes ou depois da variável são chamados pré incrementado e pós 
                incrementado. O funcionamento desses, foi visto em 
                Portugol: Operadores Aritméticos.
            
            Sintaxe
            valor1 operador valor2
++variavel
variavel++
--variavel
variavel--
            Exemplo 2
            
using System;
public class Program
{
	public static void Main()
	{
		int valor1 = 1;
		int valor2 = 2;
		int valor = valor1 + valor2;
		Console.WriteLine(valor);
		valor = valor1  - valor2;
		Console.WriteLine(valor);
		valor = valor1 * valor2;
		Console.WriteLine(valor);
		valor = valor1 / valor2;
		Console.WriteLine(valor);
		valor = valor1++;
		Console.WriteLine(valor);
		valor = --valor2;
		Console.WriteLine(valor);
		valor = ++valor1;
		Console.WriteLine(valor);
		valor = valor2--;
		Console.WriteLine(valor);
	}
}
            Saída
            
3
-1
2
0
1
1
3
1
         
     
    
    
        
            
                Para ajudar na tomada de decisões, a 
                linguagem C# fornece os operadores relacionais listados abaixo. Estes operadores retorna true ou 
                false.
            
            
                Tab. 3: Operadores Relacionais
                
                    
                        | Operador | 
                        Descrição | 
                    
                
                
                    
                        | == | 
                        Igual | 
                    
                    
                        | >= | 
                        Maior ou igual | 
                    
                    
                        | <= | 
                        Menor ou igual | 
                    
                    
                        | != | 
                        Diferente | 
                    
                    
                        | > | 
                        Maior | 
                    
                    
                        | < | 
                        Menor | 
                    
                
            
            Sintaxe
            valor1 operador valor2
            Exemplo 3
            
using System;
public class Program
{
	public static void Main()
	{
		int valor1 = 1;
		int valor2 = 2;
		bool valor = valor1 == valor2;
		Console.WriteLine(valor);
		valor = valor1  > valor2;
		Console.WriteLine(valor);
		valor = valor1 < valor2;
		Console.WriteLine(valor);
		valor = valor1 >= valor2;
		Console.WriteLine(valor);
		valor = valor1 <= valor2;
		Console.WriteLine(valor);
		valor = valor1 != valor2;
		Console.WriteLine(valor);
	}
}
            Saída
            False
False
True
False
True
True
         
     
    
    
        
            
                Para entendermos sobre a aplicação dos operadores lógicos é importante entender sobre tabela verdade 
                que foi explicado em 
                Portugol: Operadore Lógicos e 
                Tutorial C: Operadores Lógicos.
            
            
                Tab. 4: Operadores Lógicos
                
                    
                        | Operador | 
                        Significado | 
                    
                
                
                    
                        | && | 
                        E lógico | 
                    
                    
                        | ! | 
                        Não lógico | 
                    
                    
                        | || | 
                        OR lógico | 
                    
                
            
            Sintaxe
            valor1 operador valor2
            Exemplo 4
            
using System;
public class Program
{
	public static void Main()
	{
		bool valor1 = false;
		bool valor2 = true;
		bool valor = valor1 && valor2;
		Console.WriteLine(valor);
		valor = valor1 || valor2;
		Console.WriteLine(valor);
		valor = !valor1;
		Console.WriteLine(valor);
	}
}
            Saída
            False
True
True
            
            
         
     
    
        Operadores bit-a-bit/bitwise
        
     
    
        
            
                Os operadores bitwise são operadores que realizam operações lógicas em todos os bits 
                de um variável ou expressão para manipulação de bits e bytes.
            
            
                O uso dos operadores bit-a-bit já foi estudado em  
                Tutorial C: Operadores bit-a-bit . É importante entender sobre a 
                tabela verdade que foi explicada em Portugol: Operadores Lógicos e 
                Tutorial C: Operadores Lógicos.
            
            
                Tab. 5: Operadores Bit-a-bit/Bitwise
                
                    
                        | Operador | 
                        Descrição | 
                    
                
                
                    
                        | & | 
                        E bit-a-bit | 
                    
                    
                        | | | 
                        OR bit-a-bit | 
                    
                    
                        | ^ | 
                        Ou Exclusivo | 
                    
                    
                        | ~ | 
                        Não bit-a-bit | 
                    
                    
                        | >> | 
                        Desloca N bits à direita | 
                    
                    
                        | << | 
                        Desloca N bits à esquerda | 
                    
                
            
            Sintaxe
            valor1 operador valor2
~valor
            Exemplo 5
            
using System;
public class Program
{
	public static void Main()
	{
		int valor = 8,	valor2;
		valor = valor >> 1;
		Console.WriteLine(valor);
		valor = valor << 1;
		Console.WriteLine(valor);
		valor = valor & 2 ;
		Console.WriteLine(valor);
		valor = valor | 2;
		Console.WriteLine(valor);
		valor = valor ^ 4;
		Console.WriteLine(valor);
		valor = ~valor;
		Console.WriteLine(valor);
	}
}
            Saída
            4
8
0
2
6
-7
         
     
    
    
        
            
                Além dos operadores listados acima, a linguagem C# possui um outro conjunto de operadores 
                que podem ser conferidos abaixo. Em futuras atualizações atualizações cada um deles estarão
                em alguma seção do tutorial.
            
            
                Tab.: Em construção
                
                    
                        | Operador | 
                        Descrição | 
                    
                
                
                    
                        | ?? | 
                        null-coalescing | 
                    
                    
                        | ? | 
                        Nullable | 
                    
                    
                        | as | 
                        Casting | 
                    
                    
                        | is | 
                        Checagem de tipo | 
                    
                    
                        | => | 
                        Expressão lambda | 
                    
                    
                        | :: | 
                        Namespace | 
                    
                    
                        | .. | 
                        Intervalo | 
                    
                    
                        | ?: | 
                        if ternário | 
                    
                    
                        | ?. | 
                        - | 
                    
                    
                        | [] | 
                        Indexador | 
                    
                    
                        | ?[] | 
                        - | 
                    
                    
                        | () | 
                        - | 
                    
                    
                        | ^ | 
                        - | 
                    
                    
                        | . | 
                        acesso de membro | 
                    
                    
                        | * | 
                        Ponteiro | 
                    
                    
                        | -> | 
                        Ponteiro | 
                    
                    
                        | typeof | 
                        Tipo de dado | 
                    
                    
                        | sizeof | 
                        Tamanho do tipo de dado | 
                    
                    
                        | stackalloc | 
                        - | 
                    
                    
                        | with | 
                        - | 
                    
                    
                        | delegate | 
                        - | 
                    
                    
                        | ??= | 
                        - | 
                    
                
            
            Sintaxe
            -
            Exemplo 6
            
using System;
public class Program
{
	public static void Main()
	{
		int? valor = null; //nullable
		Console.WriteLine(valor is null); //is
		Console.WriteLine(typeof(UInt32));
		Console.WriteLine(valor ??= 0);
		Func<int,int,int> soma = (x,y) => (x + y); 
		Console.WriteLine(soma(10,10));
	}
}
            Saída
            True
System.UInt32
0
20
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 05/08/2025 - revisão 2 - Ajustes: target de links internos, intro, 'Objetivos' e sintaxes
 
                - 15/10/2024 - revisão 1 - Correção: links portugol, exemplos; Correções gramaticais pontuais 
 
                - 06/03/2024 - versão inicial
 
            
         
     
    
            
            
                
                    
                    Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
                em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.