Perché un sacco di lingue mancano di un operatore XOR logico?

Question

In cima alla mia testa, non riesco a pensare a una singola lingua che ho usato che aveva un esclusivo o operatore logico, ma tutti hanno operatori logici e bit a bit and e or.

Guardandosi intorno, l'unica ragione per cui riuscivo a trovare era quella esclusiva o non può essere cortocircuitata, quindi una versione logica sarebbe inutile, cosa che davvero non riesco a vedere. La ragione per cui è venuto alla mia attenzione che la maggior parte delle lingue manca è che ne avevo bisogno (stavo usando Ruby, quindi ho scritto un metodo per convertire un intero in un booleano, e quindi usare XOR bit a bit, che sui booleani si comporta come XOR logico) .

Anche l'uso di XOR bit a bit non funziona, perché darà un risultato diverso.

0b0001^0b1000 = 0b1001 (True) 
0b0001 XOR 0b1000 = False 
// Where^is bitwise exclusive or and XOR is logical exclusive or 
// Using != (not equal to) also doesn't work 
0b0001 != 0b1000 = True 

Quindi perché la maggior parte delle lingue non include un operatore o un operatore logico?

Edit: ho aggiunto un esempio di come !=, inoltre, non faccio quello che voglio, che quasi fa, ma cade nella stessa problema che l'uso di bit per bit esclusivo o lo fa, funziona solo se si sa che si stanno lavorando con zero o uno, e non con qualsiasi altro numero.

E da notare, questo presuppone che il linguaggio usi zero come falso e non nullo come vero.

Answer 1

OK, siete alla ricerca di un byte saggio esclusivo o contro un po ' saggio esclusivo o . Sembra che tu stia cercando qualcosa che funzionerà su un byte come "on" o "off", poiché i byte sono "0" o "diverso da zero", quindi XOR. Sembra davvero che tu stia cercando di comprimere ogni byte in un singolo bit che indica vero o falso. Quindi, sembra che tu voglia (a! = 0)^(b!= 0)

 
a b a YOURXOR b a!=0 b!=0 (a!=0)^(b!=0) 
0 0   0   0  0  0   
0 1   1   0  1  1 
1 0   1   1  0  1 
7 0   1   1  0  1 
0 7   1   0  1  1 
3 7   0   1  1  0 
7 3   0   1  1  0 
7 7   0   1  1  0 

Per quanto riguarda il motivo per cui questo non è in tutte le lingue ... che non posso rispondere. Tuttavia non è poi così difficile da implementare con gli elementi costitutivi di bit xor disponibili in tutte le lingue, e nessun linguaggio offre tutte le funzionalità possibili - offrono solo abbastanza per permetterti di creare la funzionalità estesa di cui potresti aver bisogno. Oh, e se questo fosse un problema abbastanza comune, ci si aspetterebbe di vedere librerie o macro dappertutto; mentre forse non ho fatto una ricerca sufficiente per tale codice/libs, non l'ho trovato io stesso, indicando che il requisito è o banale da scrivere, o un requisito di nicchia.

Answer 2

L'unica ragione per cui posso pensare è che l'operazione è relativamente rara. Non vedo perché qualcosa come ^^ non possa essere assegnato a questo, anche se forse le persone che progettano le lingue vogliono evitare l'ingombro dell'operatore.

In quanto inutile perché non può essere cortocircuitato, in molte lingue fortemente tipizzate non è possibile utilizzare l'operatore XOR bit a bit per confrontare i booleani senza eseguire il casting avanti e indietro, nel qual caso anche un non breve circuiting XOR logico avrebbe senso avere.

Answer 3

Probabilmente perché XOR non è comunemente necessario in quanto un operatore logico, e si può fare quasi facilmente come questo:

// foo xor bar 
(foo & !bar) || (bar & !foo) 

// or like this (assuming foo and bar are booleans) 
!(foo==bar) 

// assume boleans that can be cast as integers with true=1 and false=0 
// foo XOR bar XOR baz XOR alice 
((int)foo + (int)bar + (int)baz + (int)alice)&0b1 

Answer 4

Quasi ogni lingua ha una logica XOR. Il simbolo che usano per questo varia, ma indipendentemente dal simbolo, la maggior parte delle persone lo pronuncia "non uguale".

Edit: per coloro che dubitano, codice di prova per le tre variabili:

#include <iostream> 

int main() { 
    for (int i=0; i<2; i++) 
     for (int j=0; j<2; j++) 
      for (int k=0; k<2; k++) { 
       std::cout << "\n!=" << (i!=j!=k); 
       std::cout << "\t^ " << (i^j^k); 
      } 
    return 0; 
} 

Answer 5

Cosa si intende per "operatore XOR logica"? Non sono sicuro di quale risultato ti aspetti dal tuo esempi, ma ecco la mia risposta:

a (logical XOR) b è lo stesso di bool(a) != bool(b)

La disuguaglianza è una logica XOR. Dato che hai già la versione XOR bit a bit, non hai bisogno di un operatore speciale per quello logico.

Answer 6

È inoltre possibile scrivere !a^!b per ottenere lo stesso effetto di un xor logico.

Probabilmente non trovare logica XOR nei linguaggi di programmazione, perché:

• non genera codice assembly molto efficiente
• non è necessaria molto spesso
• progettisti di linguaggi devono mettere la linea da qualche parte, perché non NAND, NOR, NXOR, ecc.