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:
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.
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
Armando Luiz Nicolini Delgado