In practice, the difference is in the location where the preprocessor searches for the included file.

For `#include <filename>`

the preprocessor searches in an implementation dependent manner, normally in search directories pre-designated by the compiler/IDE. This method is normally used to include standard library header files.

For `#include "filename"`

the preprocessor searches first in the same directory as the file containing the directive, and then follows the search path used for the `#include <filename>`

form. This method is normally used to include programmer-defined header files.

A more complete description is available in the GCC documentation on search paths.

# 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.

## Best Answer

Use ignore() to ignore everything until the next line:

If you must do it manually just check othe character to see if is '\n'

This is probably failing because you are doing a seek before clearing the bad bits.