Objetivos
        
    
    
    
        
Expressões e operadores
    
    
        
            
                Para declararmos expressões em qualquer linguagem de programação precisamos utilizar os operadores. 
                O conceito de expressões e operadores foram vistos em 
                Portugol: Expressões e Operadores.
                Em caso de dúvida é recomendado a leitura.
            
            
                A linguagem C++ utiliza os mesmos operadores da linguagem C para criarmos expressões dos 
                tipos aritméticas, lógicas e relacionais e bit-a-bit/bitwise. Nesta seção vamos discutir 
                sobre esses operadores.
            
         
     
    
    
        
            
                Para atribuirmos valores ou expressões a variáveis, C++ fornece os operadores mostrados na 
                tabela abaixo:
            
            
                Tab. 1: Operadores de Atribuição
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | = | 
                        Atribuição | 
                        a=b | 
                    
                    
                        | += | 
                        Atribuição acumulativa de adição | 
                        a+=b | 
                    
                    
                        | -= | 
                        Atribuição acumulativa de subtração | 
                        a-=b | 
                    
                    
                        | *= | 
                        Atribuição acumulativa de multiplicação | 
                        a*=b | 
                    
                    
                        | %= | 
                        Atribuição acumulativa de Módulo | 
                        a%=b | 
                    
                    
                        | /= | 
                        Acumulação de divisão | 
                        a%=b | 
                    
                    
                        | |= | 
                        Acumulação de OU bit-a-bit | 
                        a|=b | 
                    
                    
                        | &= | 
                        Acumulação de E bit-a-bit | 
                        a&=b | 
                    
                    
                        | ^= | 
                        Acumulação de Ou-Exclusivo bit-a-bit | 
                        a^=b | 
                    
                    
                        | <<= | 
                        Acumulação de deslocamento | 
                        a<<=b | 
                    
                    
                        | >>= | 
                        Acumulação de deslocamento | 
                        a>>=b | 
                    
                
            
            Sintaxe
            valor1 | expressão1 operador valor2 | expressão2
variavel1 operador= expressão
            Exemplo 1
            
#include <iostream>
using namespace std;
int main()
{
    int a=1,
        b=2;
        
    cout << (a += b) << endl;
    cout << (a -= b) << endl;
    cout << (a *= b) << endl;
    cout << (a /= b) << endl;
    cout << (a %= b) << endl;
    cout << (a |= b) << endl;
    cout << (a &= b) << endl;
    cout << (a ^= b) << endl;
    cout << (a >>= b) << endl;
    cout << (a <<= b) << endl;
    return 0;
}
            Saída
            
3
1
2
1
1
3
2
0
0
0
         
     
    
    
        
            
                Para criação de expressões aritméticas utilizamos os operadores abaixo suportados 
                pela linguagem C++:
            
         
     
    
        
            
                Tab. 2: Operadores Aritméticos
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | + | 
                        Adição | 
                        a+b | 
                    
                    
                        | - | 
                        Subtração | 
                        a-b | 
                    
                    
                        | * | 
                        Multiplicação | 
                        a*b | 
                    
                    
                        | / | 
                        Divisão | 
                        a/b | 
                    
                    
                        | % | 
                        Módulo | 
                        a%b | 
                    
                    
                        | ++ | 
                        Incremento | 
                        ++a , a++ | 
                    
                    
                        | -- | 
                        Decremento | 
                        --a, a-- | 
                    
                
            
            
                Os operadores -- e ++ utilizados antes ou depois da variável são chamados pré-incremento e pós 
                incremento. O funcionamento desses operadores foi dicutidos em 
                Portugol: Operadores Aritméticos.
            
            Sintaxe
            valor1 | expressão1 operador valor2 | expressão2
variavel++
++variavel
variavel--
--variavel
            Exemplo 2
            
#include <iostream>
using namespace std;
int main()
{
    int a=1,
        b=2;
        
    cout << a+b;
    cout <<"\n"<< a-b;
    cout <<"\n"<< a*b;
    cout <<"\n"<< a/b;
    cout <<"\n"<< a+b;
    cout <<"\n"<< ++a;
    cout <<"\n"<< --a;
    return 0;
}
            Saída
            
3
-1
2
0
3
2
1
         
     
    
    
        
            
                Como em C, a linguagem C++ utiliza os mesmos operadores para que possamos usá-lo quando 
                nossos programas precisam tomar decisões baseadas na comparação de expressões ou variáveis.
            
            
                Tab. 2: Operadores relacionais
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | == | 
                        Igual | 
                        a == b | 
                    
                    
                        | >= | 
                        Maior ou igual | 
                        a >= b | 
                    
                    
                        | <= | 
                        Menor ou igual | 
                        a <= b | 
                    
                    
                        | != | 
                        Diferente | 
                        a != b | 
                    
                    
                        | > | 
                        Maior | 
                        a>b | 
                    
                
            
            Sintaxe
            valor1 | expressão1 operador valor2 | expressão2
            Exemplo 3
            
#include <iostream>
using namespace std;
int main()
{
    int a = 1,b = 3;
    bool r = false; 
    cout << (a ==b);
    cout << "\n" << (a !=b);
    cout << "\n" << (a > b);
    cout << "\n" << (a < b);
    cout << "\n" << (a <=b);
    cout << "\n" << (a >=b);
    return 0;
}
            Saída
            0
1
0
1
1
0
         
     
    
    
        
            
                Para entendermos sobre a aplicação dos operadores lógicos é importante entender sobre a tabela verdade 
                que foi explicado em Portugol: Operadores Lógicos
                e Tutorial C: Operadores Lógicos.
            
            
                Tab. 4: Operadores Lógicos
                
                    
                        | Operador | 
                        Significado | 
                        Exemplo | 
                    
                
                
                    
                        | && | 
                        E lógico | 
                        a && b | 
                    
                    
                        | ! | 
                        Não lógico | 
                        !a | 
                    
                    
                        | || | 
                        OR lógico | 
                        a || b | 
                    
                
            
            
                Os operadores lógicos retornam um valor booleano true ou false. Esse tipo de operador é 
                muito utilizado para tomadas de decisões.
            
            Sintaxe
            valor1 | expressão1 operador valor2 | expressão2
            Exemplo 4
            
#include <iostream>
using namespace std;
int main()
{
    bool a = false, 
        b = true;
    cout << "\n" << (a||b) ;
    cout << "\n" << (a&&b);
    cout << "\n" << (!a);
    return 0;
}
            Saída
            1
0
1
            
                Como o exemplo acima não utiliza formatação de dados, os valores true e false 
                são exibidos com 0(false) e 1(true).
            
            
                A linguagem C++ não suporta os operadores de atribuição ||= e &&= utilizando os operadores || e && 
                mostrados na tabela 4 acima.
            
         
     
    
        Operadores bit-a-bit/bitwise
        
     
    
        
            
                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 explicado em 
                Portugol: Operadores Lógicos e 
                Tutorial C: Operadores Lógicos.
            
            
                Esse operadores bitwise realizam operações sobre os bits de variáveis ou expressões podendo 
                resultar em 0 ou 1 de acordo com cada operador. Abaixo, os operadores suportados por C++:
            
            
                Tab. 5: Operadores bitwise
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | & | 
                        E bit-a-bit | 
                        a & b | 
                    
                    
                        | | | 
                        OU bit-a-bit | 
                        a | b | 
                    
                    
                        | ~ | 
                        Não bit-a-bit | 
                        ~a | 
                    
                    
                        | >> | 
                        Desloca N bits à direita | 
                        a>>b | 
                    
                    
                        | << | 
                        Desloca N bits à esquerda | 
                        a<<b | 
                    
                    
                        | ^ | 
                        OU Exclusivo | 
                        a^b | 
                    
                
            
            Sintaxe
            valor1 | expressão1 operador valor2 | expressão2
~valor1 | expressão1
            Exemplo 5
            
#include <iostream>
using namespace std;
int main()
{
    
    unsigned char a = 1, 
                  b = 2;
    cout << "\n" << (a&b) ;
    cout << "\n" << (a|b);
    cout << "\n" << (~a);
    cout << "\n" << (a<<1);
    cout << "\n" << (b>>1);
    return 0;
}
            Saída
            0
3
-3
2
4
         
     
    
    
        
            
                Todos os outros operadores listados na tabela abaixo estão entre os mais comuns operadores 
                não categorizados como os estudados acima. Mais operadores serão adicionados nas 
                próximas atualizações.
            
            
                Tab. 6: Outros Operadores
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | sizeof | 
                        Retorna tamanho de uma variável | 
                        sizeof(a) | 
                    
                    
                        | & | 
                        Endereço de uma variável, função e outro | 
                        &a | 
                    
                    
                        | * | 
                        Ponteiro | 
                        *ponteiro | 
                    
                    
                        | :: | 
                        Acesso a escopo | 
                        std::nome_metodo | 
                    
                    
                        | . | 
                        Acesso a membro de enum, struct, método | 
                        objeto.nome_metodo | 
                    
                    
                        | [] | 
                        Indexador | 
                        objeto.nome_metodo | 
                    
                
            
            Sintaxe
            sizeof(nome_variavel)
operadornome_variavel;
objeto.nome_membro;
objeto|array[];
namespace::nome_recurso;
            Exemplo 5
            
#include <iostream>
using namespace std;
struct mstruct
{
   int cod;
};
int main()
{
  struct mstruct _struct;  
  _struct.cod = 777;
  int vet[3] = {1,2,3};
  int *pint = &_struct.cod;
  
  std::cout << _struct.cod << endl;
  std::cout << vet[1] << endl;
  std::cout << *pint << endl;
  return 0;
}
            Saída
            0
3
-3
2
4
         
     
    
        Precedência de operadores
        
     
    
        
            
                O validação do uso dos operadores estudados acima seguem uma ordem ou precedência.
A tabela abaixo resume essa precedência da mais alta até a mais baixa.
            
            
                Tab. 7: Precedência
                
                    
                        | # | 
                        Operador | 
                        Descrição | 
                    
                
                
                    
                        | 1 | 
                        :: | 
                        Escopo | 
                    
                    
                        | 2 | 
                        x++ x-- | 
                        Incremento/Decremento | 
                    
                    
                         | 
                        . -> | 
                        Acesso a membros | 
                    
                    
                        | 3 | 
                        ++x --x | 
                        Incremento / Decremento | 
                    
                    
                        | - | 
                        +x -x | 
                        Unário | 
                    
                    
                        | - | 
                        ! ~ | 
                        Não lógico / bit-a-bit | 
                    
                    
                        | - | 
                        *x | 
                        Contéudo de  | 
                    
                    
                        | - | 
                        &x | 
                        Endereço de | 
                    
                    
                        | - | 
                        sizeof | 
                        Tamanho de | 
                    
                    
                        | 4 | 
                        .* ->* | 
                        Acesso a ponteiro de membros | 
                    
                    
                        | 5 | 
                        * / % | 
                        Multiplicação, divição e módulo | 
                    
                    
                        | 6 | 
                        + - | 
                        Soma e subtração | 
                    
                    
                        | 7 | 
                        << >> | 
                        Deslocamento | 
                    
                    
                        | 8 | 
                        < <= => > | 
                        Comparação | 
                    
                    
                        | 9 | 
                        == != | 
                        Comparação | 
                    
                    
                        | 10 | 
                        & | 
                        E lógico | 
                    
                    
                        | 11 | 
                        ^ | 
                        Ou-Exclusivo | 
                    
                    
                        | 12 | 
                        | | 
                        Ou bit-a-bit | 
                    
                    
                        | 13 | 
                        && | 
                        E lógico | 
                    
                    
                        | 14 | 
                        || | 
                        Ou lógico | 
                    
                    
                        | 15 | 
                        x?y:z | 
                        if ternário | 
                    
                    
                        | - | 
                        = | 
                        Atribuição | 
                    
                    
                        | - | 
                        += -= | 
                        Atribuição | 
                    
                    
                        | - | 
                        *= /= %= | 
                        Atribuição | 
                    
                    
                        | - | 
                        <<= >>= | 
                        Atribuição | 
                    
                    
                        | - | 
                        &= ^= |= | 
                        Atribuição | 
                    
                    
                        | - | 
                        , | 
                        Vírgula | 
                    
                
            
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 28/07/2025 - revisão 3 - Ajustes em sintaxes, target de links; Correção Ex. 1, Sintaxe 'Outros operadores'
 
                - 30/09/2024 - revisão 2 - Correção: links portugol, Ex. 5; ajustes pontuais
 
                - 09/02/2024 - revisão 1 - correção em navegação, exemplos e erros gramaticais
 
                - 30/06/2023 - 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.