====== Operadores em C ======

Um operador é um símbolo que indica a realização de uma operação sobre uma ou mais variáveis ou valores. Há uma grande diversidade de operadores em C, sendo os principais apresentados nesta seção.

===== Operadores aritméticos =====

Os principais operadores aritméticos são descritos abaixo, considerando ''A = 10'' e ''B = 20'':

^ Operador ^ Descrição ^ Exemplo ^ Resultado ^
| ''+'' | soma | ''A + B'' | 30 |
| ''-'' | subtração | ''A - B'' | -10 |
| ''*'' | multiplicação | ''A * B'' | 200 |
| ''/'' | divisão | ''B / A'' | 2 |
| ''%'' | resto da divisão inteira | ''B % A'' | 0 |
| ''++'' | incrementa variável | ''A++'' | A vale 11 |
| ''--'' | decrementa variável | ''A--'' | A vale 9 |

===== Operadores relacionais =====

^ Operador ^ Descrição ^ Exemplo ^ Resultado ^
| ''=='' | igual | ''A == B'' | falso |
| ''!='' | diferente | ''A != B'' | verdade | 
| ''>'' | maior | ''A > B'' | falso |
| ''<'' | menor | ''A < B'' | verdade |
| ''>='' | maior ou igual | ''A >= B'' | falso |
| ''<='' | menor ou igual | ''A <= B'' | verdade |

===== Operadores lógicos =====

^ Operador ^ Descrição ^ Exemplo ^
| ''&&'' | AND lógico | ''A && B'' |
| ''%%||%%'' | OR lógico | ''A %%||%% B'' |
| ''!'' | NOT lógico | ''!A'' |

===== Operadores de atribuição =====

^ Operador ^ Descrição ^ Exemplo ^ Equivale a ^
| ''='' | atribuição simples de valor a variável | ''A = B + 17'' |
| ''+='' | atribuição com soma | ''A += 3'' | ''A = A + 3'' |
| ''-='' | atribuição com subtração | ''A -= B - 7'' | ''A = A - (B - 7)'' |
| ''*='' | atribuição com produto | ''C *= A'' | ''C = C * A'' |
| ''/='' | atribuição com divisão | ''C /= A'' | ''C = C / A'' |
| ''%='' | atribuição com módulo | ''C %= A'' | ''C = C % A'' |

<note important>
Muito cuidado para não confundir a atribuição ( ''='' ) com o teste de igualdade ( ''=='' ). Por exemplo, a expressão ''if (x = 3)'' será **sempre verdade**, independente do valor de ''x''.
</note>

===== Operadores binários =====

Considerando duas variáveis inteiras de 8 bits sem sinal:

  * A = 0001 0001 (17)
  * B = 0110 0011 (99) 

^ Operador ^ Descrição ^ Exemplo ^ Resultado ^
| ''&'' | AND bit-a-bit | ''A & B'' | 0000 0001 (1) | 
| ''%%|%%'' | OR binário | ''A %%|%% B'' | 0111 0011 (115) |
| ''%%^%%'' | XOR binário | ''A %%^%% B'' | 0111 0010 (114) |
| ''~'' | complemento de 1 | ''~A'' | 1110 1110 (238) |
| ''<<'' | desloca à esquerda N bits | ''A << 2'' | 0100 0100 (68) | 
| ''>>'' | desloca à direita N bits | ''A >> 2'' | 0000 0100 (4) | 
| ''&='' | atribuição com AND binário | ''C &= 2'' | ''C = C & 2'' |
| ''%%|%%='' | atribuição com OR binário | ''C %%|%%= 2'' | ''C = C %%|%% 2'' |
| ''%%^%%='' | atribuição com XOR binário | ''C %%^%%= 2'' | ''C = C %%^%% 2'' |
| ''<<='' | atribuição com deslocamento à esquerda | ''C <<= 2'' | ''C = C << 2'' |
| ''>>='' | atribuição com deslocamento à direita | ''C >>= 2'' | ''C = C >> 2'' |

===== Operadores diversos =====

^ Operador ^ Descrição ^ Exemplo ^
| ''sizeof()'' | tamanho da variável em bytes | ''sizeof(A)'' |
| ''&'' | endereço de variável | ''&A'' |
| ''*'' | ponteiro para uma posição de memória | ''*x'' |
| ''? :'' | condicional ternária: //if X then Y else Z// |  ''X ? Y : Z'' |

===== Ordem de precedência =====

A ordem de precedência dos operadores vistos acima define a sequência em que os operadores serão aplicados. A ordem de precedência pode ter forte influência sobre o resultado da avaliação de expressões complexas.

A tabela a seguir indica a ordem de precedência dos principais operadores em C, da maior para a menor:

^ Ordem ^ Operadores ^ Descrição ^
| 1 | ''() [] . %%->%%'' | chamadas de função, escopos, acesso a vetores e estruturas |
| 2 | ''!   ~   -   +   *   &   sizeof   //type cast//   ++   --'' | operadores unários |
| 3 | ''*   /   %'' | multiplicação, divisão, módulo |
| 4 | ''+   -'' | adição, subtração |
| 5 | ''<<   >>'' | deslocamentos binários |
| 6 | ''<   <=   >   >='' | relacionais | 
| 7 | ''==   !='' | relacionais |
| 8 | ''&'' | AND binário |
| 9 | ''%%^%%'' | XOR binário |
| 10 | ''%%|%%'' | OR binário |
| 11 | ''&&'' | AND lógico |
| 12 | ''%%||%%'' | OR lógico | 
| 13 | ''? :'' | expressão condicional ternária |
| 14 | ''=   +=   -=   *=   /=   %=   &=   %%|%%=   %%^%%=   <<=   >>='' | atribuições |
| 15 | '','' | sequência (operador "vírgula") |

===== Avaliação de expressões =====

O tipo do resultado de uma expressão numérica depende dos valores e variáveis envolvidos. Por exemplo, uma expressão contendo somente tipos ''int'' terá um resultado inteiro. Como regra geral, o tipo do resultado de uma expressão será o **tipo mais forte** presente na expressão, onde a "força" dos tipos numéricos é definida como: 

''int'' < ''unsigned int'' < ''long'' < ''unsigned long'' < ''float'' < ''double'' < ''long double''

Elementos de tipos ''short'' e ''char'' em expressões numéricas são avaliados como ''int''.

Essa regra de avaliação pode induzir a erros:

<code c media-errado.c>
// Cálculo da média simples de dois valores
#include <stdio.h>

int main ()
{
  int a = 2, b = 5;
  float media;

  media = (a + b) / 2;
  printf("a media de %d e %d vale %f\n", a, b, media) ;
  return (0) ;
}
</code>

No código acima, a expressão ''(a + b) / 2'' somente envolve inteiros, por isso sua avaliação irá gerar um resultado inteiro, independente do tipo da variável ''media'' (a atribuição é o último operador avaliado):

<code>
a media de 2 e 5 vale 3.000000         // erro!
</code>

Para forçar a avaliação da expressão com reais, basta incluir um valor real:

<code c>
media = (a + b) / 2.0 ;
</code>

Agora temos o resultado correto:

<code>
a media de 2 e 5 vale 3.500000
</code>