6 Operadores Lógicos

Todos os programas até agora consideraram if com condições de teste simples. Alguns exemplos de testes simples: b != 0, contador <= 5. Estas expressões testam uma condição. Portanto, quando mais de uma condição precisa ser testada, precisamos usar sentenças if e if-else aninhadas.

A linguagem C , assim como a maioria das linguagens de programação de alto nível suportam operadores lógicos que podem ser usados para criar operações lógicas mais complexas, combinando condições simples. O valor de uma expressão lógica é ou VERDADEIRO ou FALSO. Lembre que não há constantes lógicas VERDADEIRO e FALSO em C ; em expressões lógicas 0 é interpretado como FALSO, e qualquer valor diferente de zero é interpretado como VERDADEIRO.

Os operadores lógicos são

! NÃO lógico, operação de negação (operador unário)

&& E lógico, conjunção (operador binário)

|| OU lógico, disjunção (operador binário).

Por exemplo, se quisermos testar se um número num é positivo e par, e imprimir uma mensagem como no exemplo anterior, podemos escrever:

      if (num >= 0)
         if (num % 2 == 0)
            printf("Numero par nao negativo.\n");

Com os operadores lógicos isso pode ser simplificado:

      if ((num>=0) && (num%2 == 0))
          printf("Numero par nao negativo.\n");

A operação de negação, !, pode ser usado da seguinte forma:

!expressão lógica: O valor é a negação lógica da expressão dada. Por exemplo:

!0 é 1

!1 é 0

Nós podemos usar o operador de negação lógica e escrever o exemplo acima como:

      if (num>0 && !(num%2))
            printf("Numero par nao negativo.\n");

Os dois operadores binários operam sobre duas expressões lógicas e tem o valor 1 (verdadeiro) or 0 (falso). Os exemplos abaixo mostram o seu uso:

a==0 && b==0 (verdadeiro se ambos a == 0 e b == 0, portanto se a e b são 0)

a==0 || b==0 (verdadeiro se pelo menos uma das variáveis a or b for 0)

Uma expressão usando && é verdadeira somente se ambos os operadores forem verdadeiros (não zero).

Uma expressão usando || é falsa somente se ambos os operadores forem falsos (zero).

Verifique na Tabela 2 o resultado do uso de operadores lógicos:

Tabela 2: Resultado de uso de Operadores Lógicos

A precedência do operador de negação lógica é a mais alta (no mesmo nível que o ``-'' unário). A precedência dos operadores lógicos binários é menor que a dos operadores relacionais, e mais alta que a operação de atribuição. O && tem precedência mais alta que o ||, e ambos associam da esquerda para a direita (como os operadores aritméticos).

Como a precedência dos operadores lógicos é menor que a dos operadores relacionais, não é necessário usar parênteses em expressões como:

x >= 3 && x <= 50

x == 1 || x == 2 || x == 3

A Tabela 3 mostra o quadro completo de precedência de operadores aritméticos, relacionais e lógicos.

Tabela 3: Precedência e associatividade de operadores

Operador	Associatividade
()	esquerda para direita
! - ++ -- (cast) & (unários)	direita para esquerda
* / %	esquerda para direita
+ -	esquerda para direita
< <= > >=	esquerda para direita
== !=	esquerda para direita
&&	esquerda para direita
||	esquerda para direita
= += -= *= /= %=	direita para esquerda

No próximo exemplo, o programa verifica se as três variáveis lado1, lado2, e lado3, podem ser lados de um triângulo reto. Nós usamos o fato que os três valores devem ser positivos, e que o quadrado de um dos lados deve ser igual a soma dos quadrados dos outros lados (Teorema de Pitágoras) para determinar se o triângulo é reto.

#include <stdio.h>

main() {
  
  int lado1, lado2, lado3;
  int s1, s2, s3;
  
  printf(``Entre com o tamanho dos lados do triangulo: ``);
  scanf(``%d %d %d'', &lado1, &lado2, &lado3);
  
  /* calcula o quadrado dos lados */
  s1 = lado1*lado1;
  s2 = lado2*lado2;
  s3 = lado3*lado3;
  
  /* testa a condicao para um triangulo reto */
  
  if ( lado1>0 && lado2>0 && lado3 > 0 ) {
    if (s1==s2+s3 || s2==s1+s2 || s2==s1+s3) ) {
    printf("Triangulo reto!\n");
  }
  else {
    printf("Nao pode ser um triangulo!\n");
  }
} 

Na utilização de expressões lógicas, as seguintes identidades são úteis. Elas são chamadas de Lei de DeMorgan:

!(x && y) é equivalente a !x || !y

e

!(x || y) é equivalente a !x && !y