# Setting a bit

Use the bitwise OR operator (`|`

) to set a bit.

```
number |= 1UL << n;
```

That will set the `n`

th bit of `number`

. `n`

should be zero, if you want to set the `1`

st bit and so on upto `n-1`

, if you want to set the `n`

th bit.

Use `1ULL`

if `number`

is wider than `unsigned long`

; promotion of `1UL << n`

doesn't happen until after evaluating `1UL << n`

where it's undefined behaviour to shift by more than the width of a `long`

. The same applies to all the rest of the examples.

# Clearing a bit

Use the bitwise AND operator (`&`

) to clear a bit.

```
number &= ~(1UL << n);
```

That will clear the `n`

th bit of `number`

. You must invert the bit string with the bitwise NOT operator (`~`

), then AND it.

# Toggling a bit

The XOR operator (`^`

) can be used to toggle a bit.

```
number ^= 1UL << n;
```

That will toggle the `n`

th bit of `number`

.

# Checking a bit

You didn't ask for this, but I might as well add it.

To check a bit, shift the number n to the right, then bitwise AND it:

```
bit = (number >> n) & 1U;
```

That will put the value of the `n`

th bit of `number`

into the variable `bit`

.

# Changing the *n*th bit to *x*

Setting the `n`

th bit to either `1`

or `0`

can be achieved with the following on a 2's complement C++ implementation:

```
number ^= (-x ^ number) & (1UL << n);
```

Bit `n`

will be set if `x`

is `1`

, and cleared if `x`

is `0`

. If `x`

has some other value, you get garbage. `x = !!x`

will booleanize it to 0 or 1.

To make this independent of 2's complement negation behaviour (where `-1`

has all bits set, unlike on a 1's complement or sign/magnitude C++ implementation), use unsigned negation.

```
number ^= (-(unsigned long)x ^ number) & (1UL << n);
```

or

```
unsigned long newbit = !!x; // Also booleanize to force 0 or 1
number ^= (-newbit ^ number) & (1UL << n);
```

It's generally a good idea to use unsigned types for portable bit manipulation.

or

```
number = (number & ~(1UL << n)) | (x << n);
```

`(number & ~(1UL << n))`

will clear the `n`

th bit and `(x << n)`

will set the `n`

th bit to `x`

.

It's also generally a good idea to not to copy/paste code in general and so many people use preprocessor macros (like the community wiki answer further down) or some sort of encapsulation.

I see you're using unsigned integers. By definition, **in C** (I don't know about C++), unsigned arithmetic does not overflow ... so, at least for C, your point is moot :)

With signed integers, once there has been overflow, undefined behaviour (UB) has occurred and your program can do anything (for example: render tests inconclusive).

```
#include <limits.h>
int a = <something>;
int x = <something>;
a += x; /* UB */
if (a < 0) { /* Unreliable test */
/* ... */
}
```

To create a conforming program, you need to test for overflow **before** generating said overflow. The method can be used with unsigned integers too:

```
// For addition
#include <limits.h>
int a = <something>;
int x = <something>;
if ((x > 0) && (a > INT_MAX - x)) /* `a + x` would overflow */;
if ((x < 0) && (a < INT_MIN - x)) /* `a + x` would underflow */;
```

```
// For subtraction
#include <limits.h>
int a = <something>;
int x = <something>;
if ((x < 0) && (a > INT_MAX + x)) /* `a - x` would overflow */;
if ((x > 0) && (a < INT_MIN + x)) /* `a - x` would underflow */;
```

```
// For multiplication
#include <limits.h>
int a = <something>;
int x = <something>;
// There may be a need to check for -1 for two's complement machines.
// If one number is -1 and another is INT_MIN, multiplying them we get abs(INT_MIN) which is 1 higher than INT_MAX
if ((a == -1) && (x == INT_MIN)) /* `a * x` can overflow */
if ((x == -1) && (a == INT_MIN)) /* `a * x` (or `a / x`) can overflow */
// general case
if (a > INT_MAX / x) /* `a * x` would overflow */;
if ((a < INT_MIN / x)) /* `a * x` would underflow */;
```

For division (except for the `INT_MIN`

and `-1`

special case), there isn't any possibility of going over `INT_MIN`

or `INT_MAX`

.

## Best Solution

There is no ANSI C function that provides better than 1 second time resolution but the POSIX function

`gettimeofday`

provides microsecond resolution. The clock function only measures the amount of time that a process has spent executing and is not accurate on many systems.You can use this function like this:

This returns

`Time elapsed: 1.000870`

on my machine.