Aula por Samyra Almeida

Comumente utilizamos diferentes tipos de operadores na matemática, como os aritmético. Eles nos ajudam a representar as famosas equações, fórmulas e etc. Na programação não é diferente, nessa aula iremos aprender como utilizar os tipos de operadores, mas antes vamos dividi-los nos seguintes grupos:

  1. Aritméticos
  2. Comparativos
  3. Bitwise (bit a bit)
  4. Lógicos
  5. Atribuição
  6. Incremento e Decremento
  7. Mistos

Operadores Aritméticos

Os operadores aritméticos são utilizados quando queremos escrever expressões aritméticas, como somas, subtrações, etc. Abaixo temos uma tabela com os principais operadores.

Símbolo Operação Uso Explicação
$+$ Adição $x+y$ Adiciona o valor da direita ao da esquerda (ou vise-versa).
$-$ Subtração $x-y$ Subtrai o valor da direta do valor da esquerda.
$*$ Multiplicação $x*y$ Multiplica um valor pelo outro.
$/$ Divisão $x/y$ Divide o valor da esquerda pelo da direita.
$\%$ Módulo $x\%y$ Retorna o resto da divisão de x por y.

Exemplos:

int mod = a%b; // declaro uma nova variável que contém o resto da divisão de a por b.
view raw Operador_Modulo.cpp hosted with ❤ by GitHub
int soma = a + b; // declaro uma nova variável que contém a soma de a e b.
view raw Operador_Soma.cpp hosted with ❤ by GitHub

Os exemplos acima, demonstram como utilizar dois dos operadores citados. A lógica de utilização é a mesma para os outros operadores.

Operadores Comparativos

Esses operadores são comumente utilizados para testarmos igualdades, desigualdades, diferença entre números/expressões matemáticas.  Na programação, os operadores comparativos retornam true (verdadeiro) se a comparação for verdade ou false caso contrário. Na tabela abaixo temos os principais operadores comparativos.

    Símbolo Operação Uso Explicação
$==$ Igualdade $x==y$ Checa se os valores são iguais.
$!$$=$ Diferença $x$ $!$$=y$ Checa se os valores são diferentes.
$<$ Menor que $x<y$ Checa se o valor da esquerda é menor que o da direita.
$>$ Maior que $x>y$ Checa se o valor da esquerda é maior que o da direita.
$<=$ Menor ou igual à $x<=y$ Checa se o valor da esquerda é menor ou igual ao valor da direita.
$>=$ Maior ou igual à $x>=y$ Checa se o valor da esquerda é maior ou igual ao valor da direita.

Geralmente utilizamos esses operadores no interior de estruturas condicionais como if, else if, while e for.

Exemplos:

if(a + b != c) // Se a soma de a + b for diferente de c
{
// comandos
}
view raw Operador_Diferente.cpp hosted with ❤ by GitHub
if(a < b) // Se o valor de a é menor que o valor de b
{
// comandos
}
view raw Operador_Menor.cpp hosted with ❤ by GitHub

No primeiro exemplo usamos operadores aritméticos e comparação, já no segundo usamos somente um operador de comparação, note que as variáveis a, b e c podem  ser substituídas por números, caracteres, etc.

Operadores bitwise (bit a bit)

Esses operadores são muito utilizados e com eles conseguimos realizar operações nos bits (representação binária) de um número.

Símbolo Operação Uso Explicação
$\&$ bitwise AND $x\&y$ Essa operação seta (torna) um bit do resultado como 1 se o mesmo bit de ambos os valores forem iguais a 1 ou como 0 caso contrário.
$|$ bitwise OR $x|y$ Essa operação seta um bit do resultado como 1 se o mesmo bit de de qualquer um dos valores for igual a 1 e como 0 caso os ambos os bits dos valores forem iguais a 0.
$\wedge$ bitwise XOR $x \wedge y$ Essa operação seta um bit do resultado como 1 se o mesmo bit em um dos valores for igual a 1 e o outro igual a 0.
$\sim$ bitwise NOT $\sim x$ Essa operação troca todos os bits do valor, ou seja, se um bit for igual a 1 será 0 e vice-versa.
$>>$ right shift  $x>>y$ Essa operação move para a direita os bits do valor da esquerda o número de vezes do valor da direita, ou seja, desloca os bits de x y vezes para a direita. E é a mesma coisa que dividir x por $2^y$
$<<$ left shift  $x<<y$ Essa operação move para a esquerda os bits do valor da esquerda o número de vezes do valor da direita, ou seja, desloca os bits de x y vezes para a esquerda. E é a mesma coisa que multiplicar $x$ por $2^y$

Exemplos:

int a = 12; // 1100 na representação binária.
int b = 3; // 0011 na representação binária.
int c = a&b; // faço c receber o a and b, ou seja, 1100
// & 0011
// --------
// 0000 (0 na representação decimal)
// ao realizar a operação and entre os bits de a e b e armazenar o valor em c, temos como resultado o número 0.
cout << c << "\n"; // imprimo o valor de c (na representação decimal), no caso, imprimo o valor 0.
view raw Operador_bitwise_AND.cpp hosted with ❤ by GitHub
int a = 12; // 1100 na representação binária.
int b = 3; // 0011 na representação binária.
int c = a|b; // faço c receber o a or b, ou seja, 1100
// | 0011
// --------
// 1111 (15 na representação decimal)
// ao realizar a operação or entre os bits de a e b e armazenar o valor em c, temos como resultado o número 15.
cout << c << "\n"; // imprimo o valor de c (na representação decimal), no caso, imprimo o valor 15.
view raw Operador_bitwise_OR.cpp hosted with ❤ by GitHub
int a = 10; // declaro a variavel a com o valor 10 na representação decimal e 001010 na representação binária.
a << 2; // desloco os bits de a 2 casas para a esquerda, alterando o valor de a para 101000 na representação
// binária e para 40 na representação binária.
cout << a << "\n"; // imprimo o valor de a (na representação decimal), ou seja, o número 40.
view raw Operador_left_shift.cpp hosted with ❤ by GitHub

A mesma lógica deve ser utilizada para os operadores XOR, NOT e right shift, sugerimos que você faça um código que utilize esses operadores afim de treinar sua utilização e ver como funciona na prática :).

Operadores Lógicos

Esse operadores recebem valores booleanos (true ou false) e retornam valores booleanos como saída. Vale lembrar que em c/c++ o número 0 é compreendido com false e qualquer número diferente de 0 como true. Esses operadores são comumente utilizados em estruturas condicionais como if, else if, while e for, para checar uma sequência de condições que  realizaram os mesmos comandos, caso forem verdadeiras. Tome cuidado para não confundir alguns dos operadores lógicos com os de bitwise. Os lógicos recebem booleanos como entrada e retornam valores booleanos como saída, já os de bitwise realizam operações nos bits dos números.

Símbolo Operação Uso Explicação
$\&\&$ logical AND (e) $x\&\&y$ Retorna true se x e y forem verdeiros e false quando qualquer um for falso.
$||$ logical OR (ou) $x||y$ Retorna true se x ou y forem verdeiros e false quando os forem falsos.
$!$ logical NOT (não, negação) $!x$ Retorna verdadeiro se x for falso e falso se x for verdadeiro.

Exemplos:

/*
Problema: Imprima sim se um determinado número X for par e multiplo de 5. Caso contrário, imprima não
*/
#include <bits/stdc++.h>
using namespace std;
int x; // declaro x
int main()
{
cin >> x;
if((x%2 == 0) && (x%5 == 0)) // checo se x é par e multiplo de 5
{
cout << "sim\n"; // se for, imprimo sim
}
else // se não, imprimo não
{
cout << "nao\n";
}
}
/*
Nota sobre o problema:
- Observe que para a saída desse código ser igual a "sim" é necessário que as DUAS condições sejam verdadeiras, ou seja,
se o número for par e não for multiplo de 5 a resposta é "nao" e se o número não for par mas for multiplo de 5 a resposta
também é "nao".
*/
view raw Operador_Logico_AND.cpp hosted with ❤ by GitHub
/*
Problema: Imprima 1 se um número X for 0, ou 0 se ele for igual a 1.
*/
#include <bits/stdc++.h>
using namespace std;
int x; // declaro x
int main()
{
cin >> x;
cout << !x << "\n"; // se x for 1 !x será igual a 0 e se x for 0 !x será igual a 1, então basta imprimir o que a operação
// !x retornar.
}
view raw Operador_Logico_NOT.cpp hosted with ❤ by GitHub
/*
Problema: Imprima sim se um determinado número X for par ou multiplo de 5. Caso contrário, imprima não
*/
#include <bits/stdc++.h>
using namespace std;
int x; // declaro x
int main()
{
cin >> x;
if((x%2 == 0) || (x%5 == 0)) // checo se x é par ou multiplo de 5
{
cout << "sim\n"; // se for, imprimo sim
}
else // se não, imprimo não
{
cout << "nao\n";
}
}
/*
Nota sobre o problema:
- Observe que para a saída desse código ser igual a "sim" é necessário que pelo ao menor UMA das condições sejam verdadeiras,
ou seja, se o número for par e não for multiplo de 5 a resposta é "sim" e se o número não for par mas for multiplo de 5 a
resposta é "sim", se as duas condições forem verdadeiras a resposta também é "sim". Somente se as duas condições forem
falsas que a resposta é "nao".
*/
view raw Operador_Logico_OR.cpp hosted with ❤ by GitHub

Operadores de Atribuição

Esses operadores realizam algumas das operações que já foram mostradas anteriormente e atribuem o resultado no valor da direita.

Símbolo Operação Uso Equivalência  Explicação
$=$ Atribuição $x = y$ $x = y$ Atribui o valor da direita ao valor da esquerda
$+=$ Soma e atribuição $x \ += y$ $x = x + y$ Atribui a soma dos dois valores a $x$
$-=$ Subtração e atribuição $x \ -=y$ $x = x – y$ Atribui a diferença dos dois valores à $x$
$*=$ Multiplicação e atribuição $x \ *=y$ $x = x*y$ Atribui o produto dos dois valores à $x$
$/=$ Divisão e atribuição $x \ /=y$ $x = x/y$ Atribui o quociente da divisão dos dois valores à $x$
$\%=$ Módulo e atribuição $x \ \%= y$ $x = x\%y$ Atribui o resto da divisão dos dois valores à $x$
$\&=$ bitwise AND e atribuição $x \ \&= y$ $x = x\&y$ Atribui o valor da operação $x\&y$ à $x$
$|=$ bitwise OR e atribuição $x \ |= y$ $x = x|y$ Atribui o valor da operação $x|y$ à $x$
$\wedge=$ bitwise XOR e atribuição $x \ \wedge =y$ $x = x \wedge y$ Atribui o valor da operação $x$ ^$=y$ à $x$
$>>=$ right shift e atribuição $x >>= y$ $x = x >> y$ Movimenta os bits de x por y vezes para a direita e atribui o resultado em $x$
$<<=$ left shift e atribuição $x <<= y$ $x = x << y$ Movimenta os bits de x por y vezes para a esquerda e atribui o resultado em $x$

Exemplos:

int a = 9, b = 7; // declaro a e b com, respectivamente, os valores 9 e 7.
a *= b; // faço a receber o valor de a*b.
cout << a << " " << b << "\n"; // imprimo a e b, ou seja, a saída vai ser igual a 63 7.
view raw Operador_Multiplicação_e_Recebe.cpp hosted with ❤ by GitHub
int a = 9, b = 1000; // declaro a e b com, respectivamente, os valores 9 e 1000.
a = b; // faço a receber o valor de b.
cout << a << " " << b << "\n"; // imprimo a e b, ou seja, a saída vai ser igual a 1000 1000.
view raw Operador_Recebe.cpp hosted with ❤ by GitHub

Os outros operadores seguem a mesma lógica dos exemplos acima.

Operadores de Incremento/Decremento

Símbolo Operação Uso Explicação
$++$ Pré-incremento $++x$ Incrementa o valor de x em 1 unidade antes de usar seu valor.
$-$$-$ Pré-decremento $-$$-x$ Decrementa o valor de x em 1 unidade antes de usar seu valor.
$++$ Pós-incremento $x++$ Incrementa o valor de x em 1 unidade depois de usar seu valor.
$-$$-$ Pós-decremento $x-$$-$ Decrementa o valor de x em 1 unidade depois de usar seu valor.

Exemplos:

int a = 49; // declaro a com o valor 49.
cout << ++a << " " << a << "\n"; // imprimo o valor da operação ++a, primeiro aumento o valor de a em 1 unidade e depois imprimo
// seu valor. Ao lado disso imprimo o valor de a. Assim, a saída é 50 50.
view raw Operador_Pre-Incremento.cpp hosted with ❤ by GitHub
int a = 49; // declaro a com o valor 49.
cout << a++ << " " << a << "\n"; // imprimo o valor da operação a++, imprimo o valor de a e depois aumento seu valor em 1
// unidade. Ao lado imprimo o valor de a. Assim, a saída é 49 50.
view raw Operador_Pro-Incremento.cpp hosted with ❤ by GitHub

Os operadores de decremento seguem a mesma lógica dos de incremento.

Operadores Mistos

Símbolo Operação Uso Explicação
sizeof Tamanho
(condition) ? x : y Condicional
$,$
.(ponto) and ->(seta)
Cast
*
&

Nossa missão é oferecer uma educação olímpica gratuita e de alta qualidade para qualquer pessoa, em qualquer lugar.


A Ampulheta do Saber  é uma organização sem fins lucrativos.

Fale conosco!