AULA 9 - Microcontroladores - Técnico
OPERADORES
A linguagem C é rica em operadores, em torno de 40.
Alguns são mais usados que outros, como é o caso dos operadores aritméticos que executam operações aritméticas.
Os tipos de operadores são: Aritméticos, Relacionais, Lógicos, Bit a Bit, de Atribuição, de Atribuição Reduzida, Pré e Pós-Fixados e Condicionais.
Operadores Aritméticos
Representam as operações aritméticas básicas de soma, subtração, divisão e multiplicação; além dos operadores unários (operam apenas sobre um operando) de sinal negativo e positivo. São eles:
Binários
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Módulo (devolve o resto da divisão inteira)
Unário
- Menos unário
+ Mais unário
Exemplo:
Expressão Tem o valor 5 + i 5 somado ao valor da variável i
22.3 * f 22,3 multiplicado pelo valor da variável f
k/3 o valor de k dividido por 3 *
x-y o valor de x menos o valor de y
22/3 7 ( como é divisão de inteiros o resultado é truncado)
22%3 1 ( este operador devolve o resto da divisão inteira)
-a -1 multiplicado ao valor da variável a
Exemplo 2:
#include <stdio.h>
void main(void)
{
int ftemp, ctemp;
printf("Digite a temperatura em graus Celsius: ");
scanf("%d", &ctemp);
ftemp = 9./5 * ctemp + 32; // porque este ponto aqui???
printf("Temperatura em graus Fahrenheit é %d", ftemp);
}
Resultado:
Digite a temperatura em graus Celsius: 21 Temperatura em graus Fahrenheit é 69
Operadores Relacionais
São assim chamados porque são utilizados para comparar, relacionar dois operandos. São eles:
> Maior >= Maior ou Igual < Menor <= Menor ou Igual == Igualdade != Diferença
O resultado da comparação será sempre igual a 0 (Falso) ou 1 (Verdadeiro).
Exemplo:
Expressão Tem o valor 5< 3 0 3 < 5 1 5 == 5 1 3 == 5 0 i <= 3 0, se i>3 e 1, caso contrário
Exemplo 2:
#include <stdio.h>
void main(void)
{ int verdadeiro, falso;
verdadeiro = (15 < 20);
falso = (15 == 20);
printf("Verdadeiro= %d, falso= %d \n", verdad, falso);
}
Note que o operador relacional "Igual a" é representado por dois sinais de igual. Se for usado apenas um sinal, o compilador entenderá como uma atribuição e não como comparação.
Exemplo:
x = = 2 está comparando se x é ou não igual a 2 x=2 está atribuindo o valor 2 à variável x (expressão verdadeira, por definição)
Operadores Lógicos
São chamados de "lógicos" porque seguem a Lógica Booleana de operação com bits. A diferença básica é que a rigor, a Álgebra Booleana só utiliza dois algarismos: o "0" e o "1", o "não" e o "sim", o "falso" e o "verdadeiro", o "espaço" e a "marca", etc.
E em C, considera-se o número 0 como "falso" e todos os outros números como "verdadeiros". Os operadores lógicos são:
&& AND || OR ! NOT
A operação "E" (ou "AND") representada pelo símbolo "&&", exige que todos os operandos sejam verdadeiros para que sua saída seja verdadeira.
A operação "OU" (ou "OR") representada pelo símbolo "||", exige que ao menos um dos operandos seja verdadeiro para que sua saída seja verdadeira.
A operação "NÃO" ( ou "NOT") representada pelo símbolo "!", inverte o operando. Se for falso, sua saída é verdadeira e vice-versa.
Abaixo temos as Tabelas-Verdade da Lógica Booleana:
operando1 operando2 AND OR falso falso falso falso falso verdadeiro falso verdadeiro verdadeiro falso falso verdadeiro verdadeiro verdadeiro verdadeiro verdadeiro
operando NOT falso verdadeiro verdadeiro falso
Ex: Expressão Tem o valor 5 || 3 1 5 || 0 1 5 && 3 1 5 && 0 0 0 || 0 0 i || j 0, se i e j forem 0 e 1, caso contrário !5 0 !0 1
Operadores Bit a Bit - Realizam as mesmas operações que os lógicos, só que bit a bit do número. Operam apenas em números inteiros, em sua forma binária (tal como estão armazenados na memória), casa binária, por cada binária, por isto o nome.
São eles:
& AND | OR ^ XOR << deslocamento à esquerda >> deslocamento à direita ~ complemento de um (unário)
A operação "OU-EXCLUSIVO" (ou "XOR") representada pelo símbolo "^", exige que ou um ou outro dos operandos seja verdadeiro para que sua saída seja verdadeira, nunca todos ao mesmo tempo. A operação de "deslocamento à esquerda" de bits x<<y literalmente desloca os bits do número binário x, y vezes para a esquerda. Isto equivale a multiplicar um número binário x por 2, a cada deslocamento. Ou, em outras palavras: x 2y. Os espaços criados no deslocamento são preenchidos com 0's. A operação de "deslocamento à direita" de bits x>>y literalmente desloca os bits do número binário x, y vezes para a direita. Isto equivale a dividir um número binário x por 2, a cada deslocamento. Ou, em outras palavras: x / 2y. Os espaços criados no deslocamento são preenchidos com 0's. A operação de "complemento de um" inverte todos os bits do número binário. Os que são "0" passam a ser "1" e vice-versa, e o correspondente valor binário é utilizado.
operando1 operando2 XOR falso falso falso falso verdadeiro verdadeiro verdadeiro falso verdadeiro verdadeiro verdadeiro falso Ex: Expressão Em binários Tem o valor . 1 | 2 0000.0001 | 0000.0010 0000.0011 = 3 0xFF & 0x0F 1111.1111 & 0000.1111 0000.1111 = 0x0F 0x0D << 2 0000.1101 << 2 00110100 = 0x34 0x1C >> 1 0001.1100 >> 1 0000.1110 = 0x0E ~0x03 compl(0000.0011) 1111.1100 = 0xFC 3 ^ 2 0000.0011 ^ 0000.0010 0000.0001 = 1
Operador de Atribuição - Em C, o sinal de igual não tem a interpretação dada em matemática. O que acontece é que o resultado ou valor do operando do lado direito é copiado, atribuído para a variável ou endereço, o operando do lado esquerdo. O operador de atribuição é:
= Igual a
Ex:
Expressão Operação
i = 3 coloca o valor 3 em i
i = 3 + 4 coloca o valor 7 em i
i = (k=4) coloca o valor 4 em k e depois de k para i
i =(k=4) + 3 coloca o valor 4 em k,a adição é feita e o valor 7 é colocado em i
3 = i operação inválida! a variável deve estar do lado esquerdo
Operadores de Atribuição Reduzida - Compactam operações quaisquer seguidas de operação de atribuição e tornam o código mais rápido pois a variável utilizada só é procurada uma vez na memória.
Formato: operação =
Ex: Expressão É equivalente a .
a += 2 a = a+2 j <<= 3 j = j << 3 q/= 7 + 2 q = q / (7+2)
Operadores Pré e Pós-Fixados - Realizam incremento ou decremento do valor de uma variável antes de seu valor ser utilizado, no caso de operador pré-fixado, ou depois de seu valor ser utilizado, no caso de operador pós-fixado. A vantagem de se utilizar estes operadores, e não o tradicional "variável = variável + 1;" é que além da praticidade e da compactação do código, torna o programa muito mais rápido.
++ incrementa de 1 seu operando
-- decrementa de 1 seu operando
Ex: Suponhamos a variável i = 5: Expressão Valor expressão Valor de i depois .
5 + i++ = 10 6 5 + i-- = 10 4 --i + 5 = 9 4
++i + 5 = 11 6
Operador Condicional - Substitui com vantagens o loop: "Se expressão1 é verdadeira Então expressão2, Senão expressão3". Sua sintaxe é:
exp1 ? exp2 : exp3
Ex:
Expressão Valor .
5? 1 : 2 1
i? i+j : k+j valor de i+j, se i não é zero e k+j, caso contrário
(m>7)? 3:4 3, se m maior que 7 e 4, caso contrário
c=(a>b)? a: b devolve o maior valor, entre a e b, à variável c d=(a>b)? ((a>c)? a:c): ((b>c)? b:c)) devolve o maior valor, o maior entre a, b e c, para d e=(a>b)?((a>c)?((a>d)?a:d):((c>d)?c:d)):((b>c)?((b>d)?b:d):((c>d)?c:d)); maior entre a,b,c e d
Exemplos: /*****************************************************/ /**** EXEMPLO 1: Programa que mistura tipos int e char **/ /*****************************************************/
- include <stdio.h>
void main(void) { char c = 'a', ans;
printf("O valor de c+3 = %c", c + 3);
ans = c % 3;
printf( “\n\nResto da divisão inteira = %d\n”, ans);
} /*******************************************************/ /*** EXEMPLO 2: Programa sobre o operador aritmético % */ /******************************************************/
- include <stdio.h>
void main(void) { printf( "\n13 resto 3 = %d", 13 % 3);
printf("\n-13 resto 3 = %d", -13 % 3);
printf("\n13 resto -3 = %d", 13 % -3);
printf("\n-13 resto -3 = %d", -13 % -3);
}
/********************************************************/ /**** EXEMPLO 3: Programa para demonstrar operadores ****/ /**** relacionais - Números primos ****/ /*******************************************************/
- include <stdio.h>
- include <math.h>
void gera_primos(int limite);
void main(void) { int maximo;
printf("\n Gerar numeros primos ate ?");
scanf( "%d", &maximo);
gera_primos (maximo);
printf("\n");
} void gera_primos (int limite) { int divisor;
int candidato;
int r=1;
if (limite >=7)
{ if (limite%2 == 0) /* O limite superior é par */
limite--;
for(candidato = 3; candidato <= limite; candidato +=2)
{ divisor = 3;
while (divisor <= sqrt(candidato) && (r=candidato % divisor)!= 0)
divisor +=2;
if (r !=0)
printf("%8d", candidato); /* numeros primos */
}
}
}
/***********************************************************/
/****** EXEMPLO 4: Programa para exibir o padrao de bits de um */
/***** inteiro sem sinal */
/**********************************************************/
- include <stdio.h>
void mostra_bits( unsigned especimen);
void main(void) { unsigned valor; mostra_bits (0); mostra_bits (5); mostra_bits (13); mostra_bits (117);
mostra_bits (132);
printf("\n\n Entre um numero: ");
scanf("%u", &valor); printf("\n"); mostra_bits(valor); }
void mostra_bits(unsigned especimen) { const int pos_max = 15; int posicao_bit;
printf("\n\b O número %d na base binária \202: \n", especimen);
for (posicao_bit = pos_max; posicao_bit >=0; posicao_bit--)
printf("%d", especimen >> posicao_bit & 1);
}
Exercícios:
Implemente o programa que lê valores para duas variáveis inteiras, X e Y, e depois, dependendo da escolha do usuário, implementa uma das operações a seguir e imprime a resposta: (a) X AND Y; (b) X (OU-EXC bit-a-bit) Y; (c) X deslocado Y vezes para a direita.
| << Aula 8 - Introdução | AULA 9 - Operadores | Aula 10 - Instruções IF, IF-ELSE e WHILE >> |
|---|