aula03_op_e_expr

Prévia do material em texto

ECT2303 - Linguagem de Programação
Operadores e Expressões
Prof. Bruno Marques F. da Silva
Escola de Ciências e Tecnologia
Universidade Federal do Rio Grande do Norte
1 de Agosto de 2017
Linguagem de Programação
I Aula anterior: variáveis e tipos básicos
I Aula de hoje: operadores e expressões
Operador de Atribuição
I Operador =
I Atribui um determinado valor a uma variável
I x = 0; → lê-se “xis recebe zero”
I Sempre: variável à esquerda da atribuição e qualquer outra
expressão à sua direita
I Já visto na aula anterior (inicialização de variáveis)
Operador de Atribuição
I Em sucessivas atribuições, o valor atual sobrescreve o valor
antigo
I Exemplo: o que é impresso pelo programa a seguir?
int main(){
int x; //declaracao
x = 0; //atribuicao
int y = 2, z = 3; //declaracao e inicializacao
x = y = z; //atribuicao: direita para a esquerda
cout << x << " " << y << " " << z << endl;
return 0;
}
Expressões
I Programas mais complexos fazem uso de expressões:
I Sequências de operandos e operadores que especificam uma
computação
I Em C++:
I Expressões aritméticas
I Expressões lógicas
I O valor de uma expressão é determinado pela avaliação dos
seus operandos e operadores
I Exemplos de expressões:
1. 10+10
2. x/y <= 5
3. x*y && x%y
Operadores Aritméticos
I Formam expressões aritméticas (valor resultante é um número)
I Operadores de mesma precedência são avaliados da esquerda
para a direita
Operador Funcionalidade Precedência no Grupo
() Associar operandos Primeiro a ser avaliado
+ Adição Último a ser avaliado
- Subtração Último a ser avaliado
* Multiplicação Avaliado após os parêntesis
/ Divisão Avaliado após os parêntesis
% Resto Avaliado após os parêntesis
Expressões Aritméticas
I Exemplos:
1. 1+2*3
2. 1*2+3
3. (1+2)*3
4. 1*2%3
5. ((1*2)+3)*2
I Programa com expressões:
int main(){
int x = 0;
x + 45;
x = x + 100;
cout << x << endl;
return 0;
}
I O programa compila? Qual o valor impresso?
Operadores Aritméticos de Atribuição
I Computam a expressão, aplicam o operador aritmético e
atribuem o seu valor à variável à esquerda do op. de atribuição
Operador Expressão Expresssão Equivalente
+= var += exp var = var + exp
-= var -= exp var = var - exp
*= var *= exp var = var * exp
/= var /= exp var = var / exp
%= var %= exp var = var % exp
I Ou seja, x += 5 é equivalente a x = x + 5
I Qual o valor final das variáveis a seguir, para x = 1, y = 2,
z = 3?
1. x += 2*2;
2. x += y -= z;
3. z %= y %= x;
Operações de Potência e Raíz
I Em C++, não existem operadores para potência e raíz
I Estas operações são realizadas por chamadas a funções
I pow(b,e) para potência be
I sqrt(x) para a raíz quadrada de x
I Ambas as funções estão na biblioteca cmath
#include <cmath>
Operador de Incremento/Decremento
I Operadores unários (só precisam de um operando)
Operador Expressão Expresssão Equivalente
++ (pré-fixado) ++var var = var + 1
-- (pré-fixado) --var var = var - 1
++ (pós-fixado) var++ var = var + 1
-- (pós-fixado) var-- var = var - 1
I Diferença entre ++x e x++ (o mesmo para --):
I Ambos incrementam x em uma unidade
I O op. pré-fixado incrementa e usa o novo valor na expressão
I O op. pós-fixado usa o valor na expressão e só então o incrementa
I Precedência: mais alta do que a multiplicação
I Exemplos (para x = 1, y = 2, z = 3):
1. x++;
2. x = ++z;
3. x = z--;
4. x = y++*4;
Expressões Lógicas
I Expressões que possuem como resultado os valores 0 ou 1,
equivalente aos valores lógicos falso e verdadeiro,
respectivamente
I Em C++, valores numéricos são interpretados como falso ou
verdadeiro:
I O único valor a ser interpretado como falso é o 0
I Qualquer outro é interpretado como 1 (ex. 1.000001, -10000, etc.)
I Expressões lógicas são formadas por dois tipos de operadores:
I Operadores relacionais
I Operadores lógicos
I Estas expressões são muitas vezes a parte mais importante dos
programas
Operadores Relacionais
I Possuem precedência mais alta do que o operador de atribuição
e mais baixa do que os operadores aritméticos
Operador Funcionalidade Precedência no Grupo
== Igual Último a ser avaliado
!= Diferente Último a ser avaliado
< Menor Primeiro a ser avaliado
<= Menor ou igual Primeiro a ser avaliado
> Maior Primeiro a ser avaliado
>= Maior ou igual Primeiro a ser avaliado
Expressões Lógicas
Com Operadores Relacionais
I Exemplos:
1. 1 > 2
2. 2 != 2
3. x == x
4. x = 5 > 4 == 2 > 1
5. x = 4*3 > 5+1
Operadores Lógicos
I Possuem precedência mais baixa do que os operadores
relacionais (exceto a negação, que tem precedência igual ao op.
de incremento)
Operador Funcionalidade Precedência no Grupo
! Negação (não lógico) Primeiro a ser avaliado
|| Disjunção (ou lógico) Último a ser avaliado
&& Conjunção (e lógico) Avaliado após o não lógico
I Negação: inverte o valor lógico do operando (op. unário)
I Disjunção: falso quando os dois operandos são falsos
I Conjunção: verdadeiro quando os dois operandos são
verdadeiros
Operador Lógico de Negação (Não Lógico)
Tabela Verdade
x !x
0 1
1 0
Operador Lógico de Disjunção (Ou Lógico)
Tabela Verdade
x y x || y
0 0 0
0 1 1
1 0 1
1 1 1
Operador Lógico de Conjunção (E Lógico)
Tabela Verdade
x y x && y
0 0 0
0 1 0
1 0 0
1 1 1
Expressões Lógicas
Com Todos os Operadores
I Exemplos (para x = 1, y = 2, z = 3):
1. y-x == false
2. x > 0 && x < z+10
3. z >= y || true
Precedência
I Ordem geral:
1. Parêntesis
2. Operador de incremento/não lógico
3. Operadores aritméticos
4. Operadores relacionais
5. Operadores lógicos
6. Atribuição
I Exemplo:
int i = 1, j = 2, k = 3;
i < j && 2 >= k
I Sempre que houver dúvida:
I Utilizar parêntesis
Conversão de Tipos I
I Em C++, o tipo do resultado de uma expressão aritmética é
sempre convertido no tipo do operando com maior precisão
(com mais bits para armazenamento)
I Exemplo:
char ch;
int i;
float f;
double d;
result = (ch/i) + (f*d) - (f+i);
I ch/i é uma expressão com tipo int
I f*d é uma expressão com tipo double
I f+i é uma expressão com tipo float
I (ch/i) + (f*d) é uma expressão com tipo double
I result tem tipo double
Conversão de Tipos II
I Em C++, o tipo da expressão do lado direito de uma atribuição é
convertido no tipo do lado esquerdo apenas quando este tem
menor precisão
I Exemplos:
float g = 9.8;
//valor de g e convertido para int
int x = g;
int x = 3, y = 3, z = 4;
//valor da expressao NAO e convertido para float
float media = (x + y + z)/3;
Conversão de Tipos III
I Em C++, é possível forçar uma expressão a ser interpretada
como um tipo informado
I Operador de molde ou typecast. Sintaxe:
novo_tipo(expressao);
ou
(novo_tipo) expressao;
I novo_tipo é um tipo conhecido.
Exemplos:
int x = 3, y = 3, z = 4;
float media = float(x + y + z)/3;
char ch = ‘A’;
cout << ch << " " << int(ch) << endl;
Sumário
I Na aula de hoje:
I Operador de atribuição
I Operadores aritméticos
I Operadores aritméticos de atribuição
I Operadores de incremento
I Operadores lógicos
I Operadores relacionais
I Operador de molde (typecast)
I Expressões aritméticas e lógicas
I Ordem de precedência e avaliação de expressões
Bibliografia I
MIZRAHI, V. V. Treinamento em Linguagem C++ (Módulo 1). 2.
ed. São Paulo: Pearson, 2008.
ASCENCIO, A. F. G.; CAMPOS, E. A. V. d. Fundamentos da
Programação de Computadores. 2. ed. São Paulo: Pearson,
2008.
Dúvidas:
Via SIGAA ou
bruno.silva@ect.ufrn.br
	Aula