====== Operadores ======

===== Operadores Aritméticos =====


^ Operador ^ Operação ^
|  +  | Adição |
|  -  | Subtração |
|  *  | Multiplicação |
|  /  | Divisão |
|  %  | Módulo (resto da divisão) |

Todas estas operações exigem 2 operandos (números).

===== Operadores Unários =====


^ Operador ^ Operação ^
|  ++  | Incremento |
|  --  | Decremento |

A posição relativa destes operadores em relação a variável influencia o seu funcionamento. Se os operadores forem colocados antes da variável em uma expressão, inicialmente será efetuado o incremento e depois será utilizado este novo valor na expressão.
Se os operadores forem colocados após a variável, primeiro será utilizado o valor atual da variável na expressão, e após, será realizado o incremento ou decremento.

<code c>
#include <stdio.h>
int main (void)
{
   int iValor_01 = 10, iValor_02 = 5, iValor_03 = 8;
   int iResultado;

   iResultado = iValor_01++ + 9;         /* Retorna 10 para iValor_01 
                                            iResultador = 10 + 9
                                            iValor_01 = iValor_01 + 1 */
   printf("Resultado 1 %d\n", iResultado);

   iResultado = --iValor_02 + 10;        /* iValor_02 = iValor_02 - 1
                                            iValor_02 fica com o valor 4
                                            iResultado = 4 + 10 */
   printf("Resultado 2 %d\n", iResultado);

   iResultado = ++iValor_03 * ++iValor_03; /* iValor_03 = iValor_03 + 1
                                              Retorna 9 para iValor_03 
                                              iValor_03 = iValor_03 + 1
                                              Retorna 10 para iValor_03
                                              iResultado = 9 * 10 */
   printf("Resultado 3 %d\n", iResultado);

   iResultado = iValor_01++ * iValor_01++;   /* Retorna 11 para iValor_01
                                                iValor_01 = iValor_01 + 1
                                                Retorna 12 para iValor_01
                                                iResultado = 11 * 12 
                                                iValor_01 = iValor_01 + 1 */
   printf("Resultado 4 %d\n", iResultado);

   return 0;
}
</code>

===== Operadores de Atribuição =====


^ Operador ^ Operação ^
|  +=  | Adição |
|  -=  | Subtração |
|  *=  | Multiplicação |
|  /=  | Divisão |
|  %=  | Módulo |

Como é comum a atribuição aonde uma variável é somada ou diminuída de um valor e o resultado é atribuído à mesma variável, a Linguagem C disponibiliza uma maneira curta de realizar este tipo de operação.

<code c>
#include <stdio.h>

int main(void)
{
   int iValor_01, iValor_02, iValor_03, iValor_04;

   iValor_01 = 5;
   iValor_02 = 9;
   iValor_03 = -2;
   iValor_04 = 24;

   iValor_01 += 7; /* equivale a iValor_01 = iValor_01 + 7 */

   iValor_02 -= (iValor_03*8); /* equivale a iValor_02 = iValor_02 - (iValor_03 *8) */

   iValor_03 *= 4; /* equivale a iValor_03 = iValor_03 * 4 */

   iValor_04 /= 6; /* equivale a iValor_01 = iValor_01 / 6 */

   printf("\nValor 01 = %d", iValor_01); 
   printf("\nValor 02 = %d", iValor_02); 
   printf("\nValor 03 = %d", iValor_03); 
   printf("\nValor 04 = %d", iValor_04); 
   return 0;
} 
</code>

===== Operadores Relacionais =====

^ Operador ^ Operação ^
|  <  | Menor que |
|  >  | Maior que |
|  %%<=%%  | Menor ou igual a |
|  >=  | Maior ou igual a |
|  ==  | Igual |
|  !=  | Diferente |

Os operadores relacionais servem para realizar a comparação de dois valores distintos. A implementação da Linguagem C retorna como resultado destas operações os seguintes valores:
   * 0 - Operação obteve o resultado falso;
   * 1 - Operação obteve o resultado verdadeiro.

<code c>
#include <stdio.h>

int main(void)
{
   printf("\n 5 > 7 ? A resposta é: %d", 5 > 7);
   printf("\n 5 > 4 ? A resposta é: %d", 5 > 4);

   printf("\n 7 < 1 ? A resposta é: %d", 7 < 1);
   printf("\n 4 < 7 ? A resposta é: %d", 4 < 7);
  
   printf("\n 13 == 13 ? A resposta é: %d", 13 == 13 );
   printf("\n 24 == 22 ? A resposta é: %d", 24 == 22 );

   printf("\n 13 != 13 ? A resposta é: %d", 13 != 13 );
   printf("\n 24 != 22 ? A resposta é: %d", 24 != 22 );

   return 0;
}
</code>

===== Prioridade de Avaliação =====

^ Operadores ^ Prioridade ^
|  ++ --  | Prioridade mais alta |
|  * / %  | Prioridade média |
|  + -  | Prioridade baixa |

Quando é utilizada uma série de operadores em uma expressão, deve-se sempre ter em mente a prioridade em que o compilador irá realizar estas operações.

Os operadores unários têm a maior prioridade e serão executados por primeiro. Depois serão executadas todas as operações multiplicativas (*, / e %). Por último serão executadas as operações aditivas (+ e -).

<code c>
#include <stdio.h>
int main(void)
{
   int iValor_01   = 10;
   int iResultado;

   iResultado = 10 - 5 * 8; /* Ocorre a multiplicação (5*8=40) e depois subtrai  (10-40) = 30 */
   printf("Resultado 1 %d\n", iResultado);

   iResultado = 7 * --iValor_01 - 4; /* Retorna 9 para iValor_01
                                        Realiza a multiplicação (7*9=63)
                                        Subtrai 4 (63-4 = 59) */

   printf("Resultado 2 %d\n", iResultado);
   return 0;
}
</code>

===== Operadores Lógicos =====

^ Operadores ^ Prioridade ^
|  &&  | Operação lógica E |
|  %%||%%  | Operação lógica OU |
|  !  | Operação lógica negação |

Os operadores lógicos consideram dois operandos como valores lógicos (verdadeiro e falso) e realizam a operação binária correspondente. A linguagem C considera como valor verdadeiro qualquer valor diferente de zero. O valor falso será indicado pelo valor zero.
Estas operações quando aplicadas irão retornar 1 ou zero, conforme o resultado seja verdadeiro ou falso.

<code c>
#include <stdio.h>
int main(void)
{
   int iValor_01   = 10;
   int iResultado;

   /* iValor_01 > 8 retorna verdadeiro ou seja 1
      iValor_01 != 6 retorna verdadeiro ou seja 1 */
   iResultado = (iValor_01 > 8) && (iValor_01 != 6); /* A expressão lógica 1 e 1 retorna 1. Lembrando que 0 representa o valor lógico falso 
                                                        e diferente de zero (1,2,3,etc..) representa o valor lógico verdadeiro. */

   printf("Resultado: %d\n", iResultado);
   return 0;
}
</code>

===== Assinalamento de Variáveis =====

Para a linguagem C o assinalamento é considerado um operador. Isto significa que podem ser colocados assinalamentos dentro de qualquer comando que exija um valor qualquer.
Sempre que um assinalamento é efetuado, a Linguagem C retorna como resultado do assinalamento o valor que foi colocado em variáveis. Por isso pode-se utilizar este valor retornado pelo operador **''=''** e colocar como se fosse um novo assinalamento, concatenando os mesmos. Veja também [[variavel_definicao|definição de variáveis]].

<code c>
#include <stdio.h>
int main(void)
{
   int  i,j,k,w;

   i = j = k = 20;

   printf ("Variavel i: %d\n", i );
   printf ("Variavel j: %d\n", j );
   printf ("Variavel k: %d\n", k );

   printf ("Resultado da expressao: %d\n", w = 90);
   printf ("Variavel w: %d\n", w );

   return 0;
}
</code>

===== Parênteses e Colchetes como Operadores =====
Em C, parênteses são operadores que aumentam a precedência das operações dentro deles.
Colchetes realizam a indexação de [[vetor_matriz|matrizes]]. Dada uma matriz, a expressão dentro de colchetes provê um índice dentro dessa matriz.

===== A precedência dos operadores em C =====

^  ^ Operador ^
| Maior |  ( ) [ ] %%->%%  |
| |  ! ~ ++ -- -(tipo) * & sizeof  |
| |  * / %  |
| |  + -  |
| |  %%<< >>%%  |
| |  %%<<= >>=%%  |
| |  == !=  |
| |  &  |
| |  %%^%%  |
| |  %%|%%  |
| |  &&   |
| |  %%||%%  |
| |  ?  |
| |  = += -= *= /=  |
| Menor | , |


<code c>
/* operadores_parenteses.c */

#include <stdio.h>
int main(void)
{
   int iVlr_a,iVlr_b;
   int iResultado;

   /* Atribui 90 a variavel iVlr_a; 
      Realiza a multiplicacao (9*90=810); 
      Imprime o resultado (810) */
   printf("Resultado da expressao 1: %d\n", 9*(iVlr_a = 90));
   printf("Variavel iVlr_a: %d\n", iVlr_a );

   /* Atribui 50 a variável iVlr_b.
      Realiza a multiplicação (20*50=1000).
      Atribui 1000 a variável resultado.
      Imprime o conteúdo da variável iResultado (1000). */
   printf("Resultado da expressao 2: %d\n", iResultado = (20*(iVlr_b=50)));
   printf("Variavel iVlr_b: %d\n", iVlr_b );
   printf("Variavel resultado: %d\n", iResultado );
   return 0;
}
</code>

**Observação**: Embora a Linguagem C permita o assinalamento de variáveis no meio de expressões, seu uso não é recomendado pois dificulta o entendimento do programa.

===== Operador & e * para Ponteiros =====
O primeiro operador de [[ponteiros|ponteiro]] é **''&''**. Ele é um operador unário que devolve o endereço na memória de seu operando. Por Exemplo:

<code c>
m = &count;
</code>

põe o endereço na memória da variável ''count'' em ''m''. Esse endereço é a posição interna da variável no computador e não tem nenhuma relação com o valor de ''count''. Você pode imaginar ''&'' como significando o **endereço de**.

O segundo operador é **''*''**, que é o complemento de ''&''. O ''*'' é um operador unário que devolve o valor da variável localizada no endereço que o segue. Por exemplo, se ''m'' contém o endereço da variável ''count'':

<code c>
q = *m;
</code>

coloca o valor de ''count'' em ''q''. Pense no ''*'' como significando no **endereço de**.

Observações:
   * Cuidado para não confundir ''*'' como multiplicação na utilização de ponteiros e vice-versa;
   * Cuidado para não confundir ''&'' como o operador relacional ''&&'' e vice-versa. 

Veja também [[ponteiros|ponteiros em C]]

 --- //[[marcos@laureano.eti.br|Marcos Laureano]] 2009/05/08 11:22//