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:

/* Programa que fornece a parte fracionária de um número dado */
#include <stdio.h>
main()
{ float Num, Frac;
int Inteiro;
printf("Digite um numero ");
scanf("%f", &Num);
Inteiro = Num;
Frac = Num - Inteiro;
printf("A parte fracionaria de %f e' %f ", Num, Frac);
}

Exemplo 3:

#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 \202  %d\n\n\n", ftemp);
}    

Resultado:

Digite a temperatura em graus Celsius: 21
Temperatura em graus Fahrenheit é 69

Exemplo 4:

#include <stdio.h>
int main ()
{
   int Dias; /* Declaracao de Variaveis */
   float Anos;
   printf ("Entre com o n\xA3mero de dias: "); /* Entrada de Dados
   */
   scanf ("%d",&Dias);
   Anos=Dias/365.25; /* Conversao Dias->Anos */
   printf ("\n\n%d dias equivalem a %.3f anos.\n",Dias,Anos);
   return(0);
}

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:

1. 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:
   1. X AND Y;
   2. X (OU-EXC bit-a-bit) Y;
   3. 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".

Exemplos:

  int  x=5;
  float y = 2.4;
    ...         
  soma = x + y;        /* Nesta linha o inteiro x é convertido para o valor real 5.0 */

/**********************************************************************/
/*** Programa Exemplo de Conversão Automática                   **/
/**********************************************************************/
#include <stdio.h>
void main(void)
{      
  char ch;
  int i;
  float fl;
  fl = i = ch = 'A';                                           // o caractere 'A' é armazenado 
  printf("ch = %c, i = %d, fl = %2.2f \n", ch, i, fl);         // como 65 (em i) e 65.00 (em fl)
  ch = ch + 1;                                                // converte ch para int, soma 1 e reconverte para char
  i = fl + 2 * ch;      // converte ch para int, multiplica 2, transforma em float, soma a fl e  converte para int 
  fl = 2.0 * ch + i;                               // converte ch em float, multiplica por 2.0, i é convertido em float  e
  printf("ch = %c, i = %d, fl = %2.2f \n", ch, i, fl);          //somado a ch, o resultado é armazenado em fl
  ch = 5212205.17;                                            // o valor excede 8 bits, portanto é truncado e o código 
  printf ("Agora ch = %c\n", ch);                                     //ASCII é armazenado em ch
}

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.

Exemplos:

 float r = 3.5;
 int i;
       ....     
 i = (int) r;        /* Nesta linha o valor 3 (truncamento do real r) foi atribuído a i */"

/**********************************************************************/
/*** Programa para Demonstrar Conversão Forçada de Dados  (Cast)******/
/**********************************************************************/
#include <stdio.h>
void main(void)
{  int valor1, valor2;
   valor1 = 1.6 + 1.7;
   valor2 = (int) 1.6 + (int) 1.7;
   printf("valor1 = %d\n", valor1);
   printf("valor2 = %d\n", valor2);
}

---

<< Página do curso

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