3 - Operadores

3.1 Operador de Atribuição

Em C/C++, o sinal de igual não tem a interpretação dada em matemática, pois representa a atribuição da expressão a sua direita à variável a sua esquerda, conforme a Figura a seguir.

operador_atribuicao.png

Um comando:

x = 0;

atribui o valor zero à variável de nome x. A ação é executada da direita para a esquerda. Lê-se: "x recebe o valor zero".

Mesmo em expressões mais complexas, como em $delta = b*b-4*a*c$, primeiro é realizado o cálculo da expressão à direita do operador de atribuição para depois atribuir o resultado à variável delta.

3.2 Operadores Aritméticos

Em C++ são oferecidos cinco operadores aritméticos binários (que operam sobre dois operandos) e um operador aritmético unário (que opera sobre um operando). São eles:

Binários
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo
Unário
- Menos Unário

O operador % (Módulo) opera somente com operandos inteiros e dá como resultado o resto inteiro da divisão à sua esquerda pelo inteiro à sua direita.

x = 17 % 5; // x recebe o valor do resto inteiro da divisão que é 2

O operador menos unário é usado somente para indicar a troca do sinal algébrico do valor. Pode também ser pensado como o operador que multiplica seu operando por $-1$.

x = -8;  // x recebe o valor -8
x = -x; // x recebe -(-8) = 8

3.2.1 Precedência entre os operadores aritméticos

Prioridade Operador(es)
1a - (Menos unário), parênteses mais internos
2a *, /, %
3a +, -

Os operadores que possuem a mesma prioridade devem ser executados da esquerda para a direita. Para alterar a prioridade da tabela devem-se utilizar parênteses mais internos.

3.2.2 Exemplos

Exemplo 1

Suponha que se deseje calcular o valor final de uma compra de acordo com a fórmula a seguir. Os valores dos produtos e do desconto são, respectivamente, $23.50$, $14.00$, $5.00$ e $2.00$. Como existem apenas os operadores de soma e de subtração, que possuem a mesma precedência, a execução começará da esquerda para a direita.

$valor\_final\_compra = valor\_produto1 + valor\_produto2 + valor\_produto3 - desconto;$

$valor\_final\_compra = \underbrace{23.50 + 14.00}_{37.50} + 5.00 - 2.00;$

$valor\_final\_compra = \underbrace{37.50 + 5.00}_{42.50} - 2.00;$

$valor\_final\_compra = \underbrace{42.50 - 2.00}_{40.50};$

$valor\_final\_compra = 40.50;$

Exemplo 2

Sejam 1, 6 e 8 os valores de a, b e c, respectivamente. Na fórmula de $delta$ existem os operadores de subtração e de multiplicação, este último tendo precedência sobre o primeiro. Assim, a última operação a ser realizada é a subtração, e todas as multiplicações são resolvidas da esquerda para a direita.

$delta = b*b-4*a*c;$

$delta = \underbrace{-6*-6}_{36}-4*1*8;$

$delta = 36-\underbrace{4*1}_{4}*8;$

$delta = 36-\underbrace{4*8}_{32};$

$delta = 4;$

Exemplo 3

Seja a seguinte fórmula que calcula a nota que um aluno deverá tirar no exame, onde $M_a$ é a média anual. Suponha que $M_a$ seja $4.0$. Verifique que os operadores com maior precedência são o da multiplicação e o da divisão. Note ainda que há parênteses, o que indica que o que está em seu interior deve ser resolvido primeiro.

$E = (50 - 6*Ma) / 4;$

$E = (50 - \underbrace{6*4.0}_{24.0}) / 4;$

$E = (\underbrace{50 - 24.0}_{26.0}) / 4;$

$E = \underbrace{26.0 / 4}_{6.5};$

$E = 6.5;$

3.3 Operadores de incremento e de decremento

O operador de incremento ++, é um operador unário que incrementa 1 à variável operando. O operador de incremento pode ser usado de duas formas: pré-fixado quando aparece antes do nome da variável e pós-fixado quando aparece em seguida ao nome da variável. A instrução:

x = x + 1;
++x;  // equivalente à instrução da linha anterior
x++;  // equivalente à instrução x = x + 1

A diferença entre as operações executadas pelo operador pré-fixado e pós-fixado aparece em instruções que fazem mais do que somente incrementar a variável operando. Por exemplo:

n = 5;
x = ++n;
cout << "O valor de n eh: " << n << endl;
cout << "O valor de x eh: " << x << endl;

A saída será:

O valor de n eh: 6
O valor de x eh: 6

O operador de incremento pré-fixado incrementa a variável operando antes de executar a instrução em que ele aparece. Desta forma, $n$ terá seu valor incrementado de 1 antes de ser atribuído a $x$.

n = 5;
x = n++;
cout << "O valor de n eh: " << n << endl;
cout << "O valor de x eh: " << x << endl;

A saída será:

O valor de n eh: 6
O valor de x eh: 5

O operador de incremento pós-fixado incrementa a variável operando logo após a instrução em que ele aparece. Desta forma, $n$ é atribuído a $x$ e depois seu valor é incrementado de 1. Quando o operador de incremento aparece sozinho em uma instrução não faz diferença o uso pré-fixado ou pós-fixado. A sintaxe e modo de uso do operador de decremento --, pré-fixado e pós-fixado é idêntica à do operador de incremento, exceto porque a variável é decrementada de 1.

3.4 Operadores Aritméticos de Atribuição

Esses operadores são binários e combinam as operações aritméticas com atribuição. O operando da esquerda é sempre o nome de uma variável e o da direita, uma expressão qualquer. A operação consiste em atribuir um novo valor à variável que dependerá do operador e da expressão à direita. Os usos desses operadores aritméticos de atribuição pode ser observados na Figura a seguir.

As expressões com estes operadores são mais compactas e normalmente muito usadas em C/C++.

Operador Aritmético de Atribuição Operadores equivalentes
i += 2; i = i + 2;
x *= y + 1; x = x * (y+1);
t /= 2.5; t = t / 2.5;
p %= 5; p = p % 5;
d -= 3; d = d - 3;

3.5 Operadores Relacionais

Operadores relacionais são utilizados para fazer comparações conforme as relações existentes entre dois operandos. Os usos dos operadores relacionais podem ser observados na Figura a seguir.

Os operadores e seus significados podem ser observados na Tabela a seguir.

Operador relacional com operandos Significado
$operando_1 == operando_2$ $operando_1$ é igual ao $operando_2$?
$operando_1 != operando_2$ $operando_1$ é diferente de $operando_2$?
$operando_1 > operando_2$ $operando_1$ é maior que $operando_2$?
$operando_1 < operando_2$ $operando_1$ é menor que $operando_2$?
$operando_1 >= operando_2$ $operando_1$ é maior ou igual que $operando_2$?
$operando_1 <= operando_2$ $operando_1$ é menor ou igual que $operando_2$?

Atenção: Os operadores aritméticos têm precedência sobre os operadores relacionais.

3.5.1 Exemplo: Um caso de uso do operador maior ou igual que (>=)

Suponha que seja de interesse verificar se a média final $M_f$ é no mínimo $7,0$. Isso significa que $M_f$ deve ser igual ou maior que $7,0$. Sejam três situações com os seguintes valores para $M_f$: 7.0, 8.5 e 6.8.

Expressão Teste Resultado
$M_f >= 7.0$ $7.0 >= 7.0$ True (Verdadeiro)
$M_f >= 7.0$ $8.5 >= 7.0$ True (Verdadeiro)
$M_f >= 7.0$ $6.8 >= 7.0$ False (Falso)

3.5.2 Exemplo: Precedência de operador aritmético sobre relacional

Suponha duas situações em que os valores para $n$ sejam 13 e 8. Deseja-se checar se $n$ é um número par. Verifique que primeiro é feito o cálculo do resto e depois a checagem de igualdade.

Expressão Teste Aritmético Teste Relacional Resultado
$n \% 2 == 0$ $13 \% 2 == 0$ $1 == 0$ False (Falso)
$n \% 2 == 0$ $8 \% 2 == 0$ $0 == 0$ True (Verdadeiro)

3.6 Operadores Lógicos

Operadores lógicos também fazem comparações. A diferença entre comparações lógicas e relacionais está na forma como os operadores avaliam seus operandos. Operandos lógicos são avaliados como lógicos (falso (False) ou verdadeiro (True)) e não como numéricos. Na linguagem C/C++, um valor 0 denota um valor falso; e tudo que é diferente de 0 é considerado verdadeiro.

A linguagem C/C++ oferece três operadores lógicos:

O uso desses operadores segue a idéia de Lógica Proposicional adotada em várias linguagens.

3.6.1 Operador Lógico &&

Suponha que $e_1$ e $e_2$ sejam duas expressões que serão testadas, então: uma expressão $e_1$ && $e_2$ retorna um valor verdadeiro (True), se e somente se as duas expressões possuem um valor verdadeiro, conforme a Tabela a seguir.

e1 e2 Resultado
Falso Falso Falso
Falso Verdadeiro Falso
Verdadeiro Falso Falso
Verdadeiro Verdadeiro Verdadeiro

Para exemplificar o uso desse operador considere o enunciado: "Um professor deseja verificar se a nota de um aluno é maior ou igual a 7,0 mas abaixo de 8,0." e os seguintes valores de entrada: 8,0; 7,0 e 6,5.

Expressão Teste Relacional Teste Lógico Resultado
nota >= 7.0 && nota < 8.0 8.0 >= 7.0 && 8.0 < 8.0 Verdadeiro && Falso Falso
nota >= 7.0 && nota < 8.0 7.0 >= 7.0 && 7.0 < 8.0 Verdadeiro && Verdadeiro Verdadeiro
nota >= 7.0 && nota < 8.0 6.5 >= 7.0 && 6.5 < 8.0 Falso && Verdadeiro Falso

3.6.2 Operador Lógico ||

Suponha que $e_1$ e $e_2$ sejam duas expressões que serão testadas, então uma expressão $e_1$ || $e_2$ retorna um valor falso se e somente se as expressões tiverem um valor Falso.

e1 e2 Resultado
Falso Falso Falso
Falso Verdadeiro Verdadeiro
Verdadeiro Falso Verdadeiro
Verdadeiro Verdadeiro Verdadeiro

Para exemplificar o uso do operador || considere o enunciado: "Suponha que se deseje verificar se o tipo do sexo (m ou f), digitado pelo usuário, é válido. Ou seja, um tipo de sexo é válido se é igual a 'f' (feminino) ou 'm' (masculino)". Considere os seguintes valores digitados como entrada: 'f', 'm' e 'p'.

Expressão Teste Relacional Teste Lógico Resultado
sexo == 'f' $\|$ sexo == 'm' 'f' == 'f' $\|$ 'f' == 'm' Verdadeiro $\|$ Falso Verdadeiro
sexo == 'f' $\|$ sexo == 'm' 'm' == 'f' $\|$ 'm' == 'm' Falso $\|$ Verdadeiro Verdadeiro
sexo == 'f' $\|$ sexo == 'm' 'p' == 'f' $\|$ 'p' == 'm' Falso $\|$ Falso Falso

3.6.3 Operador Lógico !

Suponha que se deseje fazer um algoritmo/programa para encontrar o nome de uma pessoa em uma lista telefônica e que exista uma variável denominada achou que possa ter os valores 0 ou 1. O primeiro valor (0) indica que não encontrou a pessoa e o segundo (valor 1) indica que a encontrou. Considere também que interessa saber se a pessoa não foi encontrada.

Expressão achou Resultado
!achou !0 Verdadeiro
!achou !1 Falso

3.6.4 Precedência de Operadores Lógicos

Prioridade Operador(es)
1a ! (NÃO)
2a && (E)
3a $\|$ (OU)

3.7 Precedências entre os Operadores Aritméticos, Relacionais e Lógicos

Prioridade Operador(es)
1a Parênteses (internos)
2a Operador lógico ! (NÃO)
3a Operadores aritméticos
4a Operadores relacionais
5a Operadores lógicos: && (E) e $\|$ (OU)

3.8 Exercícios

  1. Seja a seguinte expressão: $n = z + y * x;$. Se desejarmos somar $z$ com $y$ e depois multiplicar seu resultado com $x$, o que devemos acrescentar na expressão acima?
  2. Escreva e verifique expressões genéricas utilizando variáveis que representem as seguintes situações:
    • idade inválida, ou seja, negativa ou igual a zero. Resposta: expressão $idade <= 0$. Teste-a com os seguintes valores para idade: 0, -1 e 1
    • idade válida;
    • sexo inválido, ou seja, diferente de 'f' e de 'm';
    • sexo válido;
    • idade ou sexo inválidos;
    • idade e sexo válidos;
    • idade a partir de 18;
    • idade de 20 a 30 anos;
    • número par;
    • número ímpar;
    • número divisível por 9;
    • número divisível por 5.
  3. Idade e sexo válidos são representados em C/C++ como: (idade > 0 && (sexo == 'F' || sexo == 'M')). Por que essa expressão não é equivalente à (idade > 0 && sexo == 'F' || sexo == 'M')? Dê um contra-exemplo.
  4. Qual a diferença entre as instruções a seguir: a = 7 e a == 7?
  5. Deseja-se verificar se $x$ está no intervalo $-5 \le x \le 5$. Por que em C/C++ a expressão -5 <= x <= 5 está incorreta? Qual expressão seria correta?
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License