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

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.

#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;
}

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.

#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;
} 

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.

#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;
}

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

#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;
}

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.

#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;
}

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 definição de variáveis.

#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;
}

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

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

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.

O primeiro operador de ponteiro é &. Ele é um operador unário que devolve o endereço na memória de seu operando. Por Exemplo:

m = &count;

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:

q = *m;

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 em C

— Marcos Laureano 2009/05/08 11:22