(2107 total de palavras neste texto)
(4510 vizualização(ões))   

Curso de C - 4. Operadores em C

Então, pé na tábua!

4.1. O Operador de Atribuição

É um operador binário, ou seja, trabalha com dois operandos. Exemplos:

Atribuição de uma constante a uma variável:

  n= 10;

  ch= 'a';

  fp= 2.51;

Atribuição do valor de uma variável a outra variável:

  n= num;

Atribuição do valor de uma expressão a uma variável:

  n= (5+2)/4;

Atribuições múltiplas:

  x = y = z = 20;

Em uma atribuição, primeiro é processado o lado direito. Depois de processado, então, o valor é atribuído a variável.

Como você viu no último exemplo acima, C também permite atribuições múltiplas (como x = y = z = 20;). Neste caso, todas as variáveis da atribuição (x, y e z) recebem o valor mais à direita (20).

4.2. Os Operadores Aritméticos

Operador	Descrição	Exemplo
- unário	Inverte o sinal de uma expressão	-10, -n, -(5*3+8)
*	Multiplicação	3*5, num*i
/	Divisão	2/6, n/(2+5)
%	Módulo da divisão inteira (resto)	5%2, n%k
+	Adição	8+10, exp+num
-	Subtração	3-6, n-p

A precedência dos operadores aritméticos é a seguinte:

Mais alta

- unário

* / %

+ -

Mais baixa

Uma expressão deste tipo:

  5 + 2 * 3 - 8 / 4

É avaliada assim: primeiro a multiplicação (2*3), depois a divisão (8/4). Os resultados obtidos destas duas operações são utilizados para resolver as duas últimas operações:

  5 + 6 - 2

adição e subtração. Igualzinho à matemática aprendida no primário...

Tudo isso porque as operações de multiplicação e divisão têm maior precedência e são resolvidas primeiro em uma expressão. Para mudar a ordem de operação, deve-se usar parênteses. Deve-se tomar cuidado ao construir expressões, pois a falta de parênteses pode causar erros no resultado.

O Operador % é equivalente ao mod em Pascal, e é útil em várias situações. Ele dá como resultado o resto da divisão inteira de dois operandos. Assim, fica fácil, por exemplo, saber se um número é múltiplo de outro:

  if ((num%3)==0)   /* se o resto da divisão entre num e 3 for igual a 0 ... */
  	printf("Múltiplo de 3\n");

Este é apenas um de vários problemas que podem ser resolvidos com o uso do operador %.

4.3. Operadores Relacionais e Lógicos

Para entender melhor esses operadores, temos que entender o conceito de verdadeiro e falso. Em C, verdadeiro é qualquer valor diferente de zero, e falso é zero. As expressões que usam operadores relacionais e lógicos retornam 0 para falso e 1 para verdadeiro.

Os operadores relacionais são 6:

Operador	Ação
<	Menor que
<=	Menor que ou igual
>	Maior que
>=	Maior que ou igual
==	Igual
!=	Diferente

Veja um exemplo do uso de operadores relacionais:

  #include <stdio.h> 				/* Inclusão de stdio.h (necessário para printf e scanf) */
  
  int main()
  {
  	int n;					/* Declaração de uma variável inteira */
  	
  	printf("Digite um número: ");          
  	scanf("%d", &n);                        /* Lê o número e armazena na variável n */
  	if (n < 0)                              /* Se n for MENOR QUE 0... */
  		printf("Número negativo\n");    /* ... escreve isto. */
  	else                                    /* Senão... */
  		printf("Número positivo\n");    /* ... escreve isto. */ 
  	return 0;                               /* Retorna 0 para o sistema (sucesso) */  
  }

Tente fazer alguns testes com os outros operadores relacionais. Sei lá, seja criativo! Você é o programador... :)

Os operadores lógicos são 3:

Operador	Ação	Formato da expressão
&&	and (e lógico)	p && q
||	or (ou lógico)	p || q
!	not (não lógico)	!p

Veja um exemplo, só do bloco if:

  if ((n > 0) && (n < 100)) 				/* se n for maior que 0 E n for menor que 100... */
  	printf("Número positivo menor que 100\n");	/* ... imprime isto */

Outro exemplo:

  if ((n == 0) || (n == 1))			/* se n for IGUAL a 0 OU n for igual a 1 ... */
  	printf("zero ou um\n");                 /* ... imprime isto. */

A tabela seguinte mostra a precedência dos operadores relacionais e lógicos:

  Maior
  !
  >, >=, <, <=
  ==, !=
  &&
  ||
  Menor

Os parênteses também podem ser usados para mudar a ordem de avaliação das expressões, como no caso das expressões aritméticas.

4.4. Operadores de Incremento e Decremento

O operador ++ soma 1 ao seu operando, similar a operação de variavel= variavel+1;, mas muito mais resumido.

O operador -- subtrai 1 de seu operando, também similar a variavel= variavel-1;.

Estes operadores são unários, e podem ser usados antes da variável:

  ++n;

ou depois da variável:

  n++;

A diferença é que, se o operador precede o operando (++n), o incremento ou decremento é realizado antes do valor da variável ser usado. E se o operador vem depois do operando (n++), o valor da variável poderá ser usado antes de acontecer a operação de incremento ou decremento. Veja estes dois exemplos:

Exemplo 1:

  n= 5;
  p= ++n;
  printf("%d ",p);	/* imprime na tela: 6 */

Exemplo 2:

  n= 5;
  p= n++;
  printf("%d ",p);	/* imprime na tela: 5 */

No exemplo 1, a variável n é incrementada de 1 ANTES de seu valor ser atribuído a p. No exemplo 2, o valor de n é atribuído a p antes de acontecer a operação de incremento. Essa é a diferença de se colocar esses operadores antes ou depois da variável.

4.5. Operadores Aritméticos de Atribuição

  x= x+10;

pode ser escrita:

  x+=10;

A forma geral desse tipo de atribuição é:

  variável [operador]= [expressão];

que é igual a:

  variável= variável [operador] [expressão]

Veja essa tabela com exemplos:

Forma longa	Forma resumida
x= x+10	x+=10
x= x-10	x-=10
x= x*10	x*=10
x= x/10	x/=10
x= x%10	x%=10

Se familiarize com essa notação, pois é um estilo largamente adotado pelos profissionais que trabalham com C.

4.6. Operadores Bit a Bit

As operações bit a bit manipulam diretamente os bits de um byte ou uma palavra, e essas operações só podem ser feitas em variáveis int e char (e suas variantes). Os tipos void, float, double e long double NÃO podem ser usados.

Esses operadores são usados com mais frequência em drivers de dispositivo, como rotinas de impressoras, modems, operações com arquivos em disco, rotinas da porta serial e paralela, etc.

Veja os operadores bit a bit:

  Operador	Ação
     &		and ("e" lógico)
     |		or ("ou" lógico)
     ^		exclusive or ("ou exclusivo")
     ~		complemento de 1
     >>		deslocamento à direita
     <<		deslocamento à esquerda

Obs: Não confunda os operadores bit a bit com os operadores lógicos.

Para saber como se comportam os operadores bit a bit, segue abaixo uma tabela verdade dos operadores, com excessão dos operadores de deslocamento:

p	q	p&q	p|q	p^q	~p
0	0	0	0	0	1
0	1	0	1	1	1
1	0	0	1	1	0
1	1	1	1	0	0

O operador & compara os dois operandos bit a bit e cada bit do resultado é 1 somente quando os dois bits do operando for 1. Caso contrário, 0.

O bits do resultado de uma operação | bit a bit só será 1 quando um dos dois bits, ou os dois, forem 1. Na operação ^ só será 1 quando os bits dos operandos forem diferentes. Se forem iguais (0^0 ou 1^1) será 0.

O operador de complemento (~) é um operador unário que inverte os bits do operando. 1 vira 0 e 0 vira 1.

Vejamos um exemplo mais claro. Digamos que as variáveis inteiras x e y recebem os valores 8 e 9, respectivamente:

  x= 8;    /* 8 em binário é 1000 */
  y= 9;    /* 9 em binário é 1001 */

Vamos fazer algumas operações bit a bit nesses números:

  x & y:
  	1000
  	1001
  	----
  	1000	=> O resultado desta operação é 8 (1000).
  	
  x | y:
  	1000
  	1001
  	----
  	1001	=> O resultado desta operação é 9 (1001).
  	
  x ^ y:
  	1000
  	1001
  	----
  	0001	=> O resultado desta operação é 1.
  	
  ~x:	1000
    	----
  	0111	=> O resultado desta operação é 7 (111).
  	
  ~y:	1001
      	----
  	0110	=> O resultado desta operação é 6 (110).

Aí você me pergunta: e os operadores de deslocamento? Esses operadores deslocam n bits para a esquerda ou direita:

  x>>1	0100	=> resultado: 4 
  x>>2	0010	=> resultado: 2 
  
  y<<1	10010	=> resultado: 18
  x<<1	10000	=> resultado: 16

Você deve ter notado que deslocar um bit à direita é o mesmo que dividir o número por 2. Deslocar 2 bits à direita é o mesmo que dividir o número por 4, e assim por diante.

Deslocar um bit à esquerda, porém, é o mesmo que multiplicar o número por 2. Deslocar 2 bits à esquerda significa multiplicar por 4, e assim por diante.

Em um determinado ponto do curso, criaremos uma calculadora bit a bit, onde vocês poderão estudar melhor essas operações.

4.7. O Operador Ternário ?

  a>34 ? printf("Certo!\n") : printf("Errado!\n");

O comando acima primeiro avalia se a expressão a>34 é verdadeira. Se for, executa o comando após o ?; senão, executa o comando após o :. É a mesma coisa que fazer:

  if (a>34)
  	printf("Certo!\n");
  else
  	printf("Errado!\n");

Pessoal, na próxima aula estudaremos entrada e saída pelo console:

• vamos dissecar a função printf();
• conhecer os caracteres especiais (\n, \t, etc.);
• aprender a ler dados com scanf();
• ver as funções de impressão e leitura de caracteres getchar() e putchar();
• saber como ler e imprimir strings com gets(), puts() e fgets();
• s aber as vantagens, desvantagens e macetes de cada função;

Estudem bastante e façam os exercícios.

Exercícios:

1) Para que serve o operador de atribuição?

2) Assinale a expressão aritmética com resultado CORRETO:

  	a) 2+3*5 = 30
  	b) 5*2/2 = 5
  	c) 4+6-8/2 = 6
  	d) (-3)*4 = 12

3) As expressões a seguir têm como resultado VERDADEIRO (1) ou FALSO (0)?

  	a) 1 > 2
  	b) 2 >= 1
  	c) 3 != 3
  	d) 'c' == 'c'

4) Crie a seguinte expressão no programa a seguir:

  #include <stdio.h>
  
  int main()
  {
  	int x, y, z, media;
  	x= 8;
  	y= 15;
  	z= 37;
  	
  	/* CRIE NESTA LINHA UMA EXPRESSÃO QUE CALCULE A MÉDIA ENTRE x, y e z E RETORNE O RESULTADO PARA A VARIÁVEL media */
  	
  	printf("Média: %d\n", media);
  	return 0;
  }

Powered by txt2tags