Operadores lógicos en C

Tengo problemas para tratar de comprender cómo funcionan los operadores lógicos en C. Ya entiendo cómo funcionan los operadores de nivel de bits, y también sé que los operadores lógicos tratan los argumentos distintos de cero como representando los argumentos TRUE y cero como los que representan FALSE

Pero digamos que tenemos 0x65 && 0x55. No entiendo por qué y cómo estas operaciones dan 0x01.

Traté de convertirlo a binario, pero no puedo entender cómo funciona

El && es un AND lógico (a diferencia de & , que es un AND bit ). Solo le importa que sus operandos sean valores cero / distintos de cero. Los ceros se consideran false , mientras que los que no son ceros se tratan como true .

En su caso, ambos operandos no son cero, por lo tanto, se tratan como true , lo que da como resultado un resultado que también es true . C representa true como 1 , lo que explica el resultado general de su operación.

Si cambia la operación a & , obtendría una operación bit a bit. 0x65 & 0x55 le dará un resultado de 0x45 .

operador && :

Si el operando izquierdo y el operando derecho son ambos diferentes de 0 se evalúa a 1 contrario, se evalúa como 0 .

Si el operando de la izquierda es 0 , el operando de la derecha no se evalúa y el resultado es 0 .

0x65 && 0x55 se evalúa a 1 .

&& es un operador lógico, no un operador bit a bit. Tanto 0x65 como 0x55 son verdaderos, por lo que el resultado es un número verdadero. 0x01 es un número verdadero.

Las representaciones binarias solo entran en juego para operaciones bit a bit. La expresión 0x65 & 0x55 es igual a 0x45 .

Cualquier expresión que evalúa a 0 es falsa. Y cualquier expresión que no sea cero es verdadera. Entonces ambos 0x65 y 0x55 son verdaderos.

0x65 && 0x55

=> true && true => true

Traté de convertirlo a binario

Eso podría haber obstaculizado la comprensión. Los patrones de bits exactos de 0x65 y 0x55 son completamente irrelevantes para el resultado requerido, lo único que importa es que ambos no son cero. Podría considerar a = (0x65 && 0x55) equivalente a algo así como:

 if (0x65 != 0) goto condition_false; if (0x55 != 0) goto condition_false; a = 1; goto condition_end; condition_false: a = 0; condition_end: 

Una implementación dada podría ser capaz de emitir código más eficiente que eso (aunque he visto casi ese código emitido, con cada uno if ... goto es una prueba y se ramifica en el conjunto). El código más eficiente podría implicar algunas operaciones de bits para evitar twigs. Para el caso, en este ejemplo que involucra constantes, el comstackdor probablemente solo emitiría a = 1; .

Sin embargo, el significado del operador && es en términos de ejecución condicional. Por ejemplo, si escribe f() && g() entonces se garantiza que cuando f devuelve un valor falso, g no se invoca. Si es posible obtener el mismo resultado haciendo giros de bits, es probable que sea una bonificación para el rendimiento.

C y C ++ tienen tres operadores lógicos : lógico no ( ! ), Lógico y ( && ) y lógico o ( || ). Para operadores lógicos, 0 es falso y todo lo que no sea cero es verdadero . Esta tabla de verdad ilustra cómo funciona cada operador lógico (usará 1 para true ):

 pqp && qp || q = = ====== ====== 1 1 1 1 1 0 0 1 0 1 0 1 0 0 0 0 

La tabla de verdad para ! es como sigue:

 p !p = === 1 0 0 1 

Para su caso específico:

 0x65 && 0x55 

Como ambos operandos 0x65 y 0x55 evalúan como true la expresión completa se evalúa como true y, por lo tanto, se expande a 1 , que se aplica a c99 pero otras respuestas en el hilo vinculado explican cómo se aplica antes de c99 también.

C define valores mayores que cero para ser “Verdadero”. Como ambos 0x65 y 0x55 coinciden con esta condición, el resultado también es Verdadero, que, en salida, es 1 o, en notación hexadecimal, 0x01.

Un estilo alternativo de escritura para su código sería:

return (0x65 es verdadero) y (0x55 es verdadero);

Como dijiste, los operadores lógicos tratan los argumentos distintos de cero como representativos

  (0x65 && 0x55) is equal as (0x65 > 0) && (0x55 > 0) 0x65 > 0 get true and 0x55 > 0 get true as well So (0x65 && 0x55) is equal true && true = 1