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", verdadeiro, 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 |
Exemplo:
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 . 2^y. 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 / 2^y. 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 |
Exemplo:
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
Exemplo:
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.
Format0:
operação =
Exemplo:
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
Exemplo:
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
Exemplo:
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
Outros 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ício:
- 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:
- X AND Y;
- X (OU-EXC bit-a-bit) Y;
- X deslocado Y vezes para a direita.
CONVERSÕES DE TIPOS
Apesar do tipo de cada variável e constante ser definido no início das funções, eventualmente uma variável ou constante precisará ser convertida para outro tipo, no meio do programa.
Uma conversão pode ocorrer porque definimos um operando como sendo de um tipo e depois precisamos compará-lo ou realizar alguma operação aritmética com este e outro operando de outro tipo. Ou então porque o tipo do operando não foi suficiente para armazená-lo durante todo o correr do programa.
O fato é que conversões de tipos de variáveis e constantes acontecem e podem ser:
Conversão Automática
Ocorre quando tipos diferentes aparecem numa mesma expressão. A regra geral é converter o tipo "menor" para o tipo "maior".
Exemplo:
int x=5;
float y = 2.4;
...
soma = x + y; /* Nesta linha o inteiro x é convertido para o valor real 5.0 */
Conversão Forçada
Também conhecida como conversão "cast".
Ocorre quando um tipo específico for necessário e o operando não foi definido como tal.
A sintaxe é:
(tipo) expressão
onde tipo é o tipo para o qual será convertido o operando e expressão é uma expressão que contém a variável ou constante a ser convertida.
Exemplo:
float r = 3.5;
int i;
....
i = (int) r; /* Nesta linha o valor 3 (truncamento do real r) foi atribuído a i */"
| << Aula 8 - Introdução | AULA 9 - Operadores | Aula 10 - Instruções IF, IF-ELSE e WHILE >> |
|---|