ECT1203 - Aula04 - Operadores e expressões

Prévia do material em texto

ECT1203 Linguagem de Programação 
 
Prof. Luiz Eduardo Cunha Leite 
 
 
Aula 04 – Operadores e expressões 
Universidade Federal do Rio Grande do Norte 
Escola de Ciências e Tecnologia 
Hora de silenciar o celular 
• Manter o celular sempre desligado/silencioso quando 
estiver em sala de aula 
• Nunca atender o celular em sala de aula 
Objetivo da aula 
Apresentar os seguintes conceitos na Linguagem 
C++: 
▫ Operador de atribuição 
▫ Operadores aritméticos 
▫ Operadores relacionais e lógicos 
▫ Operador * unário sobre ponteiros 
▫ Conversão de tipos 
O operador de atribuição 
nome_da_variável = expressão; 
x = 2 + 4; 
variável operador de atribuição 
Uma atribuição é uma expressão cujo valor resultante 
corresponde ao valor atribuído. 
Atribuição 
• A declaração de variáveis somente reserva espaço na 
memória para ser utilizado pelo programa. 
• O comando de atribuição é responsável por 
armazenar uma informação em uma variável. 
 variável = informação; idade = 35; 
peso = 98.54; 
letra = ‘d’; 
Atribuindo valores a variáveis 
• É possível declarar e atribuir valores às variáveis em 
uma única instrução (inicialização) 
int a; 
float b; 
 
a = 5; 
b = 4.3; 
int a = 5; 
float b = 4.3; 
Efeito 
Equivalente 
Se uma variável é declarada e não inicializada, ela conterá 
um valor inicial aleatório (“Lixo”) 
Atribuições múltiplas 
• O mesmo valor pode ser atribuído a múltiplas variáveis. 
 
 
 
 
• A ordem de avaliação é da direita para a esquerda. 
1º ) z = 0 
2º) y = 0 
3º ) x = 0 
 
x = y = z = 0; 
Conversão de tipos em atribuições 
 
 
• Perde-se a informação contida nos bits mais significativos 
quando se converte de: 
▫ inteiros para caracteres 
▫ inteiros longos para inteiros 
▫ inteiros para inteiros curtos 
• Quando se faz conversão envolvendo números em ponto 
flutuante, pode se perder precisão. 
 
Regra: O valor do lado direito de uma atribuição é 
convertido no tipo do lado esquerdo. 
Atribuindo valores a variáveis 
O que acontece se fizermos a seguinte instrução? 
int a = 4.999; 
Como a variável a é do tipo inteiro, apenas a 
parte inteira do valor 4.999 é atribuído à variável 
a. Ou seja, a será igual a 4. 
Operadores aritméticos 
Operador Ação 
- Subtração, menos unário 
+ Adição 
* Multiplicação 
/ Divisão 
% Módulo da divisão 
As operações são feitas na precisão dos operandos. 
Ex.: O resultado da divisão entre dois números 
inteiros é um número inteiro. 
Operador de Incremento e Decremento 
Operador Ação 
++ Soma 1 ao seu operando 
-- Subtrai 1 ao seu operando 
Há uma diferença entre x++ e ++x quando usados 
em uma expressão. 
++x; x = x + 1; é o mesmo que 
x--; x = x - 1; é o mesmo que 
Operadores aritméticos de atribuição 
• Pode ser aplicado a todo operador binário. 
variável = variável operador expressão; 
variável operador= expressão; 
é o mesmo que 
i = i + 10; 
x = x * (y + 1); 
a = a – 120; 
i += 10; 
x *= y + 1; 
a -= 120; 
Se mais de um operador estiver presente em uma 
expressão, qual deve ser avaliado primeiro? 
Precedência dos operadores 
aritméticos 
Mais alta ++ -- 
- (menos unário) 
* / % 
Mais baixa + - 
• Operadores do mesmo nível de precedência são avaliados 
da esquerda para a direita. 
• Parânteses podem ser usados para forçar uma (ou mais) 
operação a ter precedência maior. 
Conversão de tipos em expressões 
Quando operandos de tipos diferentes são 
utilizados em uma expressão, os valores são 
convertidos no tipo do maior operando. 
double 
float 
int 
char 
prioridade de 
conversão 
Conversão de tipos em expressões 
Cast (operador de molde) 
Cast é uma conversão explícita de tipo. 
(tipo) expressão 
int x = 13; 
float y = (float) x/2; 
Operadores lógicos e relacionais 
• São baseados na idéia de verdadeiro e falso. 
▫ VERDADEIRO = qualquer valor diferente de zero 
▫ FALSO = zero 
• As expressões que usam operdores relacionais ou 
lógicos devolvem zero para falso e 1 para verdadeiro. 
 
Relacional refere-se às relações entre os valores. 
Lógico refere-se a como essas relações podem ser 
conectadas. 
Operadores lógicos e relacionais 
Operador Ação 
> Maior que 
>= Maior ou igual que 
< Menor que 
<= Menor ou igual que 
== Igual 
!= Diferente 
Operador Ação 
&& AND 
|| OR 
! NOT 
Relacionais 
Lógicos 
Operadores lógicos 
• Operador AND = Resultará verdadeiro quando TODOS 
os operandos forem verdadeiros. 
• Operador OR = Será verdadeiro quando pelo menos UM 
operando for verdadeiro. 
• Operador NOT = Resultará verdadeiro quando seu 
operando for falso e falso quando seu operando for 
verdadeiro 
Operador AND Operador NOT Operador OR 
0 && 0 = 0 ! 1 = 0 0 || 0 = 0 
0 && 1 = 0 ! 0 = 1 0 || 1 = 1 
1 && 0 = 0 1 || 0 = 1 
1 && 1 = 1 1 || 1 = 1 
Precedência dos operadores lógicos 
e relacionais 
• São menores em precedência que os operadores 
aritméticos. 
 
10 > 1 + 12 10 > (1 + 12) é avaliado como 
Mais alta ! 
> >= < <= 
== != 
&& 
Mais baixa || 
Operador Ternário ? : 
O operador ternário ? : utiliza três operandos. A sua 
sintaxe é: 
Operando1 ? Operando2 : Operando3 
O Operando1 é interpretado como valor lógico e os 
operandos Operando2 e Operando3 são interpretados como 
numéricos. 
O resultado produzido pelo operador será o valor do 
Operando2 se o valor do Operando1 for verdadeiro ou o 
valor do Operando3 em caso contrário. 
O valor da seguinte expressão será 8. 
1 > 2 ? 4 : 8 
Pois o primeiro operando possui valor falso. 
Portanto, o valor produzido pelo operador será o 
do terceiro operando ( 8 ). 
Operadores bit a bit 
• São aplicados aos bits individuais dos operandos. 
Operação bit a bit refere-se a testar, atribuir ou 
deslocar os bits de tipos de dados char e int. 
Operador Ação 
& AND 
| OR 
^ XOR (OR exclusivo) 
~ Complemento de um 
>> Deslocamento à esquerda 
<< Deslocamento à direita 
Operador sizeof 
• Para calcular o tamanho de um tipo, deve-se usar 
parênteses. 
É um operador que retorna o tamanho (em bytes) 
de uma variável ou especificados de tipo. 
float f; 
 
cout << sizeof f << ‘\n’; 
cout << sizeof(int) << ‘\n’; 
Operador * Unário Sobre Ponteiros 
O operador * unário, quando aplicado a um ponteiro, 
resulta no valor armazenado na variável apontada pelo 
ponteiro em questão. 
int x = 3; //Atribui o valor 3 à variável x 
 
int * pt; //Declara pt como um ponteiro para int 
 
pt = & x; //Faz pt apontar para x (pt armazena o 
 //endereço de x) 
 
cout << * pt //A expressão *pt resulta no valor da 
 //variável apontada por pt (valor de x)