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

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 **/ /*****************************************************/

1. 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 % */ /******************************************************/

1. 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 ****/ /*******************************************************/

1. include <stdio.h>
2. 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 */ /**********************************************************/

1. 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.

---

<< Página do curso

<< Aula 8 - Introdução	AULA 9 - Operadores	Aula 10 - Instruções IF, IF-ELSE e WHILE >>