C# & operator clarification

Question

I saw a couple of questions here about the diference between && and & operators in C#, but I am still confused how it is used, and what outcome results in different situations. For example I just glimpsed the following code in a project

bMyBoolean = Convert.ToBoolean(nMyInt & 1);
bMyBoolean = Convert.ToBoolean(nMyInt & 2);

When it will result 0 and when >0? What is the logic behind this operator? What are the diferences between the operator '|'?

bMyBoolean = Convert.ToBoolean(nMyInt | 1);
bMyBoolean = Convert.ToBoolean(nMyInt | 2);

Can we use the &&, || operators and get the same results (possibly with different code)?

The second set of `bMyBoolean`s trivially evaluate to true. – harold Sep 26 '12 at 11:01 — harold, Sep 26 '12 at 11:01

Sleiman Jneidi · Answer 1 · 2015-07-15T19:19:16.157

11

The && is a conditional and used in if statements and while

if(x>1 && y<3)

this means that x should be greater than 1 and y less than 3, satisfy both conditions

if(x>1 || y<3)

satisfy one of them

However, & and | are bitwise AND and OR respectively. ex:

 1 | 0  => 1
 1 & 0  => 0
 1 & 1  => 1

if this apply for straight integers, their corresponding binary value will be calculated and applied

2&1
=>   10  // the binary value of 2
     &
     01  // the binary value of 1
     --
     00  // the result is zero

edited Jul 15 '15 at 19:19

answered Sep 26 '12 at 10:57

Sleiman Jneidi

22,907
14
56
77

2

I think this doesn't explain the difference well. What happens when you use `&` on booleans? What happens when you use `&&` on integers? – svick Sep 26 '12 at 11:00
If anyone wants to know why `10 & 01 == 00`, you may understand how bitwase operations are done [here](https://en.wikipedia.org/wiki/Bitwise_operation#AND). – Alisson Reinaldo Silva Jan 17 '18 at 13:36

score 8 · Accepted Answer · answered Sep 26 '12 at 10:58

8

The ampersand does bitwise AND on the integers in their binary representations. The pipe does bitwise OR.

See here what those bitwise operations mean: http://en.wikipedia.org/wiki/Bitwise_operation

answered Sep 26 '12 at 10:58

Tomas Grosup

6,396
3
30
44

Kirill Bestemyanov · Answer 3 · 2012-09-26T11:01:07.610

4

& and | is bit operations. You must use it on bit masks. && and || is logical operations so you can use it for only bool values.

Example of bit operation:

var a = 1;
var b = 2;
var c = a|b;

in binary format this means a = 00000001, b = 00000010 c = 00000011

So if you use bitmask c it will pass values 1, 2 or 3.

edited Sep 26 '12 at 11:01

answered Sep 26 '12 at 10:56

Kirill Bestemyanov

11,946
2
24
38

score 2 · Answer 4 · answered Sep 26 '12 at 10:58

2

One more difference is that & operator computes the logical bitwise AND of its operands, if operands are not bool (integer in your case)

answered Sep 26 '12 at 10:58

berliner

1,887
3
15
23

score 2 · Answer 5 · answered Sep 26 '12 at 11:00

& operator is BItwise AND operator,it does manipulation on bits. e.g. 5 & 3

        0101    //5
        0011   //3
    ----------
5&3=    0001   //1

| operator is BItwise OR operator,it does manipulation on bits. 5|3

        0101    //5
        0011   //3
    ----------
  5|3=  0111   //7

&& operator is logical AND operator- it returns true if all conditions are true
e.g.

       if((3>5)&&(3>4))   //returns true
       if((6>5)&&(3>4))   //returns false

|| operator is logical OR operator- it returns true if one of the conditions is true
e.g.

   if((3>5)||(3>4))   //returns true
   if((6>5)||(3>4))   //returns true
   if((6>5)||(5>4))   //returns false

cuongle · Answer 6 · 2012-09-26T11:28:58.793

Other answers explains for you the different between && and &, so assume you understand this. In here, I just try to explain your specified case.

First case

bMyBoolean = Convert.ToBoolean(nMyInt & 1);

bMyBoolean false when nMyInt = 0 because:

  00 
& 01 
= 00;

Second case:

bMyBoolean = Convert.ToBoolean(nMyInt & 2);

bMyBoolean false when nMyInt = 0 or 1 because

  00 
& 10 
= 00;

Or:

  01 
& 10 
= 00;

The third and fourth cases with bitwise | are trivial because bMyBoolean always true with any nMyInt

bMyBoolean = Convert.ToBoolean(nMyInt | 1);
bMyBoolean = Convert.ToBoolean(nMyInt | 2);

You cannot apply && or || in this case because they are constraint only for bool, you will compiled errors.

score 0 · Answer 7 · answered May 29 '13 at 16:39

Here is something interesting for & . bit-wise as & be, it can be used to bool as in example below.

bool result = true;
result &= false;
Console.WriteLine("result = true & false => {0}", result );
//result = true & false => False

result = false;
result &= false;
Console.WriteLine("result = false & false => {0}", result );
//result = false & false => False


result = true;
result &= true;
Console.WriteLine("result = true & true => {0}", result );
//result = true & true => True

C# & operator clarification

7 Answers7

Linked