What is the purpose of the bitwise inclusive OR operator?

Question

From what I understand, the bitwise inclusive OR operator compares every bit in the first and second operand and returns 1 if either bit is 1. Bjarne Stroustrup uses it like this (ist being an istream object):

ist.exceptions(ist.exceptions()|ios_base::bad_bit);

I haven't really worked with bits a lot in programming, should it be on my to-do list to learn? I understand that if I had an int and the value was 9, the binary would be 00001001, but that is pretty much it. I do not understand why he would use this operator in the context that he used it in.

Possible duplicate of [What does the bitwise or | operator do?](https://stackoverflow.com/questions/612072/what-does-the-bitwise-or-operator-do) — phuclv, Aug 11 '17 at 03:01
@LưuVĩnhPhúc I don't think this is duplicate. He's asking a subtly different question regarding the use case for the bitwise operator. — sashang, Aug 11 '17 at 03:04
it's used to set bits. See how it's used for a single bit [here](https://stackoverflow.com/q/47981/995714). [What are bitwise operators?](https://stackoverflow.com/q/276706/995714), [Real world use cases of bitwise operators](https://stackoverflow.com/q/2096916/995714), [practical applications of bitwise operations](https://stackoverflow.com/q/3883384/995714) — phuclv, Aug 11 '17 at 03:04
@sashang probably, but it'll be duplicated with the other questions — phuclv, Aug 11 '17 at 03:10

score 1 · Answer 1 · answered Aug 11 '17 at 03:08

In this case, it simply means "turn a bit on".

Just an example: I have a byte 0100 0011 serves as 8 booleans. I want to turn on 4th bit (i.e. make 4th boolean true)

By bitwise operation, it looks like this: [0100 0011] Bitwise-OR [0000 1000] and it will give you 0100 1011. Which means, it simply change 4th bit to true, regardless of its original value

score 0 · Accepted Answer · answered Aug 11 '17 at 03:03

0

You can think of it as a way to add an option to a set of existing options. An analogy would be if you're familiar with linux:

PATH = "$PATH:/somenewpath"

This says 'I want the existing path and this new path /somenewpath'

In this case he's saying 'I want the existing options in exceptions and I want the bad_bit option as well'

answered Aug 11 '17 at 03:03

sashang

11,704
6
44
58

So it is used to throw ios_base::badbit to ist.exceptions() where it can be handled? – Aug 11 '17 at 03:06
Yes, It "adds" the `ios_base::badbit` to the existing `ist.exceptions()` without having to know (or care) what it was before. – Kevin Aug 11 '17 at 03:09
Would bit manipulation be something that I'd be required to pick up eventually, for someone that has been using C++ for a few months? – Aug 11 '17 at 03:15
@sS5H. yes. It's something you should learn early rather than later. It's basic C or C++. – sashang Aug 11 '17 at 03:32

score 0 · Answer 3 · answered Aug 11 '17 at 03:21

The std::ios::exceptions is a function which gets/sets an exception mask in the file which is used by the file object to decide in which situations it should throw an exception or not.

There exist two implementations of this function:

iostate exceptions() const; // get current bit mask
void exceptions (iostate except); // set new bit mask

The statement you've posted sets the new exception mask to the file object using ios_base::badbit flag combined with the current flags, that are currently set in the file object.

The OR bitwise operator is often used in order to create create a bitfield using already existing bitfield and a new flag. It could also be used in order to combine two flags together into a new bitfield.

Here is an example with explanation:

// Enums are usually used in order to represent 
// the bitfields flags, but you can just use the
// constant integer values.
// std::ios::bad_bit is, actually, just a constant integer.
enum Flags {
    A,
    B,
    C
};

// This function is similar to std::ios::exceptions
// in the sense that it returns a bitfield (integer,
// in which bits are manipulated directly).
Something foo() {
  // Return a bitfield in which A and B flags
  // are "on".
  return A | B;
}

int main() {
  // The actual bitfield, which is represented as a 32-bit integer
  int bf = 0;      

  // This is what you've seen (well, somethng similar).
  // So, we're assigning a new bitfield to the variable bf.
  // The new bitfield consists of the flags which are enabled
  // in the bitfield which foo() returns and the C flag.
  bf = foo() | C;

  return 0;
}

What is the purpose of the bitwise inclusive OR operator?

3 Answers3