Operadores C++

Neste tutorial, aprenderemos sobre os diferentes tipos de operadores em C++ com a ajuda de exemplos. Na programação, um operador é um símbolo que opera sobre um valor ou uma variável.

Operadores são símbolos que realizam operações em variáveis e valores. Por exemplo, + é um operador usado para adição, enquanto - é um operador usado para subtração.

Os operadores em C++ podem ser classificados em 6 tipos:

Operadores aritméticos
Operadores de atribuição
Operadores Relacionais
Operadores lógicos
Operadores bit a bit
Outros operadores

1. Operadores aritméticos C++

Os operadores aritméticos são usados para realizar operações aritméticas em variáveis e dados. Por exemplo,

a + b;

Aqui, o + operador é usado para adicionar duas variáveis a e b . Da mesma forma, existem vários outros operadores aritméticos em C++.

Operador	Operação
`+`	Adição
`-`	Subtração
`*`	Multiplicação
`/`	Divisão
`%`	Operação do módulo (resto após divisão)

Exemplo 1:operadores aritméticos

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 7;
    b = 2;

    // printing the sum of a and b
    cout << "a + b = " << (a + b) << endl;

    // printing the difference of a and b
    cout << "a - b = " << (a - b) << endl;

    // printing the product of a and b
    cout << "a * b = " << (a * b) << endl;

    // printing the division of a by b
    cout << "a / b = " << (a / b) << endl;

    // printing the modulo of a by b
    cout << "a % b = " << (a % b) << endl;

    return 0;
}

Saída

a + b = 9
a - b = 5
a * b = 14
a / b = 3
a % b = 1

Aqui, os operadores + , - e * calcular adição, subtração e multiplicação, respectivamente, como poderíamos ter esperado.

/ Operador de Divisão

Observe a operação (a / b) em nosso programa. O / operador é o operador de divisão.

Como podemos ver no exemplo acima, se um inteiro for dividido por outro inteiro, obteremos o quociente. No entanto, se o divisor ou o dividendo for um número de ponto flutuante, obteremos o resultado em decimais.

In C++,

7/2 is 3
7.0 / 2 is 3.5
7 / 2.0 is 3.5
7.0 / 2.0 is 3.5

Operador de % Módulo

O operador de módulo % calcula o restante. Quando a = 9 é dividido por b = 4 , o restante é 1 .

Observação: O % operador só pode ser usado com números inteiros.

Operadores de incremento e decremento

C++ também fornece operadores de incremento e decremento:++ e -- respectivamente.

++ aumenta o valor do operando em 1
-- diminui em 1

Por exemplo,

int num = 5;

// increment operator
++num;  // 6

Aqui, o código ++num; aumenta o valor de num por 1 .

Exemplo 2:operadores de incremento e decremento

// Working of increment and decrement operators

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 100, result_a, result_b;

    // incrementing a by 1 and storing the result in result_a
    result_a = ++a;
    cout << "result_a = " << result_a << endl;


    // decrementing b by 1 and storing the result in result_b   
    result_b = --b;
    cout << "result_b = " << result_b << endl;

    return 0;
}

Saída

result_a = 11
result_b = 99

No programa acima, usamos o ++ e -- operadores como prefixos (++a e --b) . No entanto, também podemos usar esses operadores como postfix (a++ e b--) .

Para saber mais, visite operadores de incremento e decremento.

2. Operadores de atribuição C++

Em C++, os operadores de atribuição são usados para atribuir valores a variáveis. Por exemplo,

// assign 5 to a
a = 5;

Aqui, atribuímos um valor de 5 para a variável a .

Operador	Exemplo	Equivalente a
`=`	`a = b;`	`a = b;`
`+=`	`a += b;`	`a = a + b;`
`-=`	`a -= b;`	`a = a - b;`
`*=`	`a *= b;`	`a = a * b;`
`/=`	`a /= b;`	`a = a / b;`
`%=`	`a %= b;`	`a = a % b;`

Exemplo 3:Operadores de Atribuição

#include <iostream>
using namespace std;

int main() {
    int a, b;

    // 2 is assigned to a
    a = 2;

    // 7 is assigned to b
    b = 7;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "\nAfter a += b;" << endl;

    // assigning the sum of a and b to a
    a += b;  // a = a +b
    cout << "a = " << a << endl;

    return 0;
}

Saída

a = 2
b = 7

After a += b;
a = 9

3. Operadores Relacionais C++

Um operador relacional é usado para verificar a relação entre dois operandos. Por exemplo,

// checks if a is greater than b
a > b;

Aqui, > é um operador relacional. Ele verifica se a é maior que b ou não.

Se a relação for verdadeira , ele retorna 1 enquanto que se a relação for falsa , ele retorna 0 .

Operador	Significado	Exemplo
`==`	É igual a	`3 == 5` nos dá falso
`!=`	Diferente de	`3 != 5` nos dá verdadeiro
`>`	Maior que	`3 > 5` nos dá falso
`<`	Menor que	`3 < 5` nos dá verdadeiro
`>=`	Maior ou igual a	`3 >= 5` dê-nos falso
`<=`	Menor ou igual a	`3 <= 5` nos dá verdadeiro

Exemplo 4:Operadores Relacionais

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 3;
    b = 5;
    bool result;

    result = (a == b);   // false
    cout << "3 == 5 is " << result << endl;

    result = (a != b);  // true
    cout << "3 != 5 is " << result << endl;

    result = a > b;   // false
    cout << "3 > 5 is " << result << endl;

    result = a < b;   // true
    cout << "3 < 5 is " << result << endl;

    result = a >= b;  // false
    cout << "3 >= 5 is " << result << endl;

    result = a <= b;  // true
    cout << "3 <= 5 is " << result << endl;

    return 0;
}

Saída

3 == 5 is 0
3 != 5 is 1
3 > 5 is 0
3 < 5 is 1
3 >= 5 is 0
3 <= 5 is 1

Observação :Os operadores relacionais são usados na tomada de decisões e loops.

4. Operadores lógicos C++

Operadores lógicos são usados para verificar se uma expressão é verdadeira ou falso . Se a expressão for verdadeira , ele retorna 1 enquanto que se a expressão for falsa , ele retorna 0 .

Operador	Exemplo	Significado
`&&`	expressão1 && expressão2	E lógico. True somente se todos os operandos forem true.
`\|\|`	expressão1 \|\| expressão2	OU lógico. Verdadeiro se pelo menos um dos operandos for verdadeiro.
`!`	! expressão	NÃO Lógico. Verdadeiro somente se o operando for falso.

Em C++, os operadores lógicos são comumente usados na tomada de decisões. Para entender melhor os operadores lógicos, vamos ver os exemplos a seguir,

Suppose,
a = 5
b = 8

Then,

(a > 3) && (b > 5) evaluates to true
(a > 3)  && (b < 5) evaluates to false

(a > 3) || (b > 5) evaluates to true
(a > 3) || (b < 5) evaluates to true
(a < 3) || (b < 5) evaluates to false

!(a < 3) evaluates to true
!(a > 3) evaluates to false

Exemplo 5:operadores lógicos

#include <iostream>
using namespace std;

int main() {
    bool result;

    result = (3 != 5) && (3 < 5);     // true
    cout << "(3 != 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 < 5);    // false
    cout << "(3 == 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 > 5);    // false
    cout << "(3 == 5) && (3 > 5) is " << result << endl;

    result = (3 != 5) || (3 < 5);    // true
    cout << "(3 != 5) || (3 < 5) is " << result << endl;

    result = (3 != 5) || (3 > 5);    // true
    cout << "(3 != 5) || (3 > 5) is " << result << endl;

    result = (3 == 5) || (3 > 5);    // false
    cout << "(3 == 5) || (3 > 5) is " << result << endl;

    result = !(5 == 2);    // true
    cout << "!(5 == 2) is " << result << endl;

    result = !(5 == 5);    // false
    cout << "!(5 == 5) is " << result << endl;

    return 0;
}

Saída

(3 != 5) && (3 < 5) is 1
(3 == 5) && (3 < 5) is 0
(3 == 5) && (3 > 5) is 0
(3 != 5) || (3 < 5) is 1
(3 != 5) || (3 > 5) is 1
(3 == 5) || (3 > 5) is 0
!(5 == 2) is 1
!(5 == 5) is 0

Explicação do programa de operador lógico

(3 != 5) && (3 < 5) avalia como 1 porque ambos os operandos (3 != 5) e (3 < 5) são 1 (verdadeiro).
(3 == 5) && (3 < 5) avalia como 0 porque o operando (3 == 5) é 0 (falso).
(3 == 5) && (3 > 5) avalia como 0 porque ambos os operandos (3 == 5) e (3 > 5) são 0 (falso).
(3 != 5) || (3 < 5) avalia como 1 porque ambos os operandos (3 != 5) e (3 < 5) são 1 (verdadeiro).
(3 != 5) || (3 > 5) avalia como 1 porque o operando (3 != 5) é 1 (verdadeiro).
(3 == 5) || (3 > 5) avalia como 0 porque ambos os operandos (3 == 5) e (3 > 5) são 0 (falso).
!(5 == 2) avalia como 1 porque o operando (5 == 2) é 0 (falso).
!(5 == 5) avalia como 0 porque o operando (5 == 5) é 1 (verdadeiro).

5. Operadores Bitwise C++

Em C++, os operadores bit a bit são usados para realizar operações em bits individuais. Eles só podem ser usados com char e int tipos de dados.

Operador	Descrição
`&`	E binário
`\|`	OU binário
`^`	XOR binário
`~`	Complemento de um binário
`<<`	Deslocamento binário para a esquerda
`>>`	Deslocamento binário para a direita

Para saber mais, visite Operadores bit a bit C++.

6. Outros operadores C++

Aqui está uma lista de alguns outros operadores comuns disponíveis em C++. Vamos aprender sobre eles em tutoriais posteriores.

Operador	Descrição	Exemplo
`sizeof`	retorna o tamanho do tipo de dados	`sizeof(int); // 4`
`?:`	retorna o valor com base na condição	`string result = (5 > 0) ? "even" : "odd"; // "even"`
`&`	representa o endereço de memória do operando	`&num; // address of num`
`.`	acessa membros de variáveis struct ou objetos de classe	`s1.marks = 92;`
`->`	usado com ponteiros para acessar as variáveis de classe ou struct	`ptr->marks = 92;`
`<<`	imprime o valor de saída	`cout << 5;`
`>>`	obtém o valor de entrada	`cin >> num;`

Conversão de tipo C++ Comentários C++

Linguagem C