# 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

Handling a stack overflow is not the right solution, instead, you must ensure that your program does not overflow the stack.

Do not allocate large variables on the stack (where what is "large" depends on the program). Ensure that any recursive algorithm terminates after a known maximum depth. If a recursive algorithm may recurse an unknown number of times or a large number of times, either manage the recursion yourself (by maintaining your own dynamically allocated stack) or transform the recursive algorithm into an equivalent iterative algorithm

A program that must be "really robust" will not use third-party or external libraries that "eat a lot of stack."

Note that some platforms do notify a program when a stack overflow occurs and allow the program to handle the error. On Windows, for example, an exception is thrown. This exception is not a C++ exception, though, it is an asynchronous exception. Whereas a C++ exception can only be thrown by a

`throw`

statement, an asynchronous exception may be thrown at any time during the execution of a program. This is expected, though, because a stack overflow can occur at any time: any function call or stack allocation may overflow the stack.The problem is that a stack overflow may cause an asynchronous exception to be thrown even from code that is not expected to throw any exceptions (e.g., from functions marked

`noexcept`

or`throw()`

in C++). So, even if you do handle this exception somehow, you have no way of knowing that your program is in a safe state. Therefore, the best way to handle an asynchronous exception is not to handle it at all^{(*)}. If one is thrown, it means the program contains a bug.Other platforms may have similar methods for "handling" a stack overflow error, but any such methods are likely to suffer from the same problem: code that is expected not to cause an error may cause an error.

^{(*) There are a few very rare exceptions.}