# & Operator (C# Reference)

The `&`

operator can function as either a unary or a binary operator.

## Remarks

The unary `&`

operator returns the address of its operand (requires unsafe context).

Binary `&`

operators are predefined for the integral types and `bool`

. For integral types, & computes the logical bitwise AND of its operands. For `bool`

operands, & computes the logical AND of its operands; that is, the result is `true`

if and only if both its operands are `true`

.

The binary `&`

operator evaluates both operands regardless of the first one's value, in contrast to the conditional AND operator `&&`

. For example:

```
int i = 0;
if (false & ++i == 1)
{
// i is incremented, but the conditional
// expression evaluates to false, so
// this block does not execute.
}
```

User-defined types can overload the binary `&`

operator (see operator). Operations on integral types are generally allowed on enumeration. When a binary operator is overloaded, the corresponding assignment operator, if any, is also implicitly overloaded.

## Example

```
class BitwiseAnd
{
static void Main()
{
// The following two statements perform logical ANDs.
Console.WriteLine(true & false);
Console.WriteLine(true & true);
// The following line performs a bitwise AND of F8 (1111 1000) and
// 3F (0011 1111).
// 1111 1000
// 0011 1111
// ---------
// 0011 1000 or 38
Console.WriteLine("0x{0:x}", 0xf8 & 0x3f);
}
}
// Output:
// False
// True
// 0x38
```