Escolha a opção com a afirmação incorreta sobre a operação lógica de negação: A A operação lógica de negação funciona com qualquer tipo de variável. B Com as variáveis booleanas, trata-se da negação do valor da mesma variável. Isso significa que se o valor da variável for true, a negação será false e vice-versa. C Para variáveis numéricas, dependemos do número atribuído a elas. Se o valor for maior que 0, a variável é considerada falsa e, por isso, o resultado da negação é verdadeiro (true). D Para variáveis numéricas com um valor maior que 0, a negação terá o valor falso, ou false. E A negação de uma variável do tipo texto dependerá do que ela está armazenando. Se a variável é um texto vazio, então é considerada como falsa e sua negação tem um resultado verdadeiro, ou true.
Soluções para a tarefa
Resposta: 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
\begin{table}\centering\begin{displaymath}
\begin{array}{\vert c\vert c\vert c\...
...so & falso & falso & falso \\ \hline
\end{array} \end{displaymath}
\end{table}
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
() 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
Explicação passo a passo: