Cosa significa bit a bit o | l'operatore fa?

Question

Stavo leggendo enumerazioni di bandiera e operatori bit per bit, e ho trovato questo codice:

enum file{
read = 1,
write = 2,
readandwrite = read | write
}

Ho letto da qualche parte sul perché c'è una dichiarazione inclusiva o come e come non ci può essere un & amp ;, ma non riesco a trovare l'articolo. Qualcuno può rinfrescare la mia memoria e spiegare il ragionamento?

Inoltre, come posso dire e / o? Per esempio. se dropdown1 = " ciao " e / o dropdown2 = " ciao " ....

Grazie

Answer 1

Prima domanda:

Un | esegue un bit per bit o; un bit verrà impostato nel risultato se è impostato nel primo valore o nel secondo valore. (Lo usi su enums per creare valori che sono combinazioni di altri valori) Se dovessi usare un bit per bit, non avrebbe molto senso.

Viene utilizzato come segue:

[Flags] 
enum FileAccess{
None = 0,                    // 00000000 Nothing is set
Read = 1,                    // 00000001 The read bit (bit 0) is set
Write = 2,                   // 00000010 The write bit (bit 1) is set
Execute = 4,                 // 00000100 The exec bit (bit 2) is set
// ...
ReadWrite = Read | Write     // 00000011 Both read and write (bits 0 and 1) are set
// badValue  = Read & Write  // 00000000 Nothing is set, doesn't make sense
ReadExecute = Read | Execute // 00000101 Both read and exec (bits 0 and 2) are set
}
// Note that the non-combined values are powers of two, \
// meaning each sets only a single bit

// ...

// Test to see if access includes Read privileges:
if((access & FileAccess.Read) == FileAccess.Read)

In sostanza, è possibile verificare se sono impostati determinati bit in un enum ; in questo caso stiamo testando per vedere se i bit corrispondenti a un Leggi sono impostati. I valori Read e ReadWrite supererebbero entrambi questo test (entrambi hanno il bit zero impostato); Scrivi non (non ha bit zero impostato).

// if access is FileAccess.Read
        access & FileAccess.Read == FileAccess.Read
//    00000001 &        00000001 => 00000001

// if access is FileAccess.ReadWrite
        access & FileAccess.Read == FileAccess.Read
//    00000011 &        00000001 => 00000001

// uf access is FileAccess.Write
        access & FileAccess.Read != FileAccess.Read
//    00000010 &        00000001 => 00000000

Seconda domanda:

Penso che quando dici "e / o", intendi "uno, l'altro o entrambi". Questo è esattamente ciò che fa il || (o operatore). Per dire " l'uno o l'altro, ma non entrambi ", useresti ^ (l'esclusivo o l'operatore).

Tabelle di verità (true == 1, false == 0):

     A   B | A || B 
     ------|-------
OR   0   0 |    0
     0   1 |    1 
     1   0 |    1
     1   1 |    1 (result is true if any are true)

     A   B | A ^ B 
     ------|-------
XOR  0   0 |    0
     0   1 |    1 
     1   0 |    1
     1   1 |    0  (if both are true, result is false)

Answer 2

Quanto sopra o è un bit per bit o, non un logico o. 1 | 2 è equivalente a 3 (mentre 1 & amp; 2 = 0).

Vedi http://en.wikipedia.org/wiki/Bitwise_operation per una migliore spiegazione sulle operazioni bit per bit.

Answer 3

Tipi di enumerazione . Guarda la sezione Tipi di enumerazione come flag di bit, fornisce un esempio di OR o un esempio di AND AND b.

Answer 4

Bene, ci sono due domande diverse qui, ma per rispondere al n. 2, l'OR logico come si trova nella maggior parte dei linguaggi di programmazione è ciò che intendi con e / o, credo.

if (dropdown == "1" || dropdown == "2") // Works if either condition is true.

Esclusivo-OR significa tuttavia, " Uno o l'altro ma non entrambi " ;.