Operatori logici in C

Ho problemi a cercare di capire come funzionano gli operatori logici in C. Capisco già come funzionano gli operatori a livello di bit, e so anche che gli operatori logici considerano gli argomenti diversi da zero come rappresentativi di VERO e zero argomenti che rappresentano FALSE

Ma diciamo che abbiamo 0x65 && 0x55. Non capisco perché e come queste operazioni diano 0x01.

Ho provato a convertirlo in binario, ma non riesco a capire come funziona

Il && è un AND logico (a differenza di & , che è un AND bit a bit ). Si preoccupa solo che i suoi operandi sono zero / non zero valori. Gli zeri sono considerati false , mentre i non zero vengono considerati come true .

Nel tuo caso, entrambi gli operandi sono diversi da zero, quindi vengono considerati come true , risultando in un risultato altrettanto valido. C rappresenta true come 1 , spiegando il risultato complessivo della tua operazione.

Se si modifica l’operazione in & , si otterrà un’operazione bit a bit. 0x65 & 0x55 ti daranno un risultato di 0x45 .

&& operatore:

Se l’operando di sinistra e l’operando di destra sono entrambi diversi da 0 viene valutato 1 altrimenti viene valutato a 0 .

Se l’operando di sinistra è 0 , l’operando di destra non viene valutato e il risultato è 0 .

0x65 && 0x55 viene valutato su 1 .

&& è un operatore logico, non un operatore bit a bit. Sia 0x65 che 0x55 sono vere, quindi il risultato è un numero vero. 0x01 è un numero vero.

Le rappresentazioni binarie entrano in gioco solo per operazioni bit a bit. L’espressione 0x65 & 0x55 è uguale a 0x45 .

Qualsiasi espressione che restituisce 0 è falsa. E qualsiasi espressione che non sia zero è vera. Quindi sia 0x65 che 0x55 sono vere.

0x65 && 0x55

=> true && true => true

Ho provato a convertirlo in binario

Questo potrebbe aver impedito di capire. I pattern di bit esatti di 0x65 e 0x55 sono completamente irrilevanti per il risultato richiesto, tutto ciò che conta è che sono entrambi non zero. Potresti considerare a = (0x65 && 0x55) come equivalente a qualcosa di simile:

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

Una determinata implementazione potrebbe essere in grado di emettere un codice più efficiente di quello (anche se ho visto più o meno quel codice emesso, con ciascuno if ... goto come test e ramo nell’assembly). Il codice più efficiente potrebbe comportare alcune operazioni di bit per evitare i rami. Del resto, in questo esempio che riguarda costanti il ​​compilatore probabilmente emetterebbe a = 1; .

Il significato dell’operatore && è in termini di esecuzione condizionale, però. Ad esempio se scrivi f() && g() allora è garantito che quando f restituisce un valore falso, g non viene chiamato. Se è ansible ottenere lo stesso risultato con il bit-twiddling, è probabile che questo sia un bonus per le prestazioni.

C e C ++ ha tre operatori logici : logico non ( ! ), Logico e ( && ) e logico o ( || ). Per gli operatori logici, 0 è falso e tutto ciò che non è zero è vero . Questa tabella di verità illustra come funziona ogni operatore logico (utilizzerà 1 per true ):

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

Il tavolo della verità per ! è come segue:

 p !p = === 1 0 0 1 

Per il tuo caso specifico:

 0x65 && 0x55 

Poiché entrambi gli operandi 0x65 e 0x55 valutano true l’intera espressione 0x55 true e quindi si espande a 1 , che si applica a c99 ma altre risposte nel thread collegato spiegano come si applica prima di c99 .

C definisce valori maggiori di zero per essere “True”. Dato che sia 0x65 sia 0x55 corrispondono a questa condizione, anche il risultato è True – che, in uscita, è 1 – o, in notazione esadecimale, 0x01.

Uno stile alternativo di scrittura per il tuo codice sarebbe:

return (0x65 è vero) e (0x55 è vero);

Come hai detto, gli operatori logici considerano gli argomenti non nulli come rappresentativi

  (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