# Operator | = for boolean in C ++

I came across the following construct in C ++:

```
bool result = false;
for(int i = 0; i<n; i++){
result |= TryAndDoSomething(i);
}
```

I assumed this `|=`

was a shortcut for the OR operator and that it `result`

would end up equal `true`

if at least one of those calls `TryAndDoSomething`

returned `true`

.

But now I'm wondering if more than one call can actually return `true`

. Indeed, if we continue the operation as:

```
result = result || TryAndDoSomething(i);
```

Then the method will only be called if return evaluates to `false`

, that is, if no other call before returning `true`

. This way, after one call that returns `true`

, no other call will be made.

Is this the correct interpretation?

source to share

The only difference in this context between `x |= f()`

(bitwise OR) and `x = x || f()`

(logical OR) is that the latter is short-circuited. In the first case, it `f()`

will be executed `n`

once, unless, of course, `f()`

it throws an exception, but that's another story.

The version `||`

`f()`

will no longer be called once `x`

becomes `true`

. C ++ does not have an operator `||=`

, but it is important to understand that because of this, `|=`

and `||=`

(if it existed) would have different semantics. `|=`

is not just a replacement for the absent one `||=`

.

As a side note, if you use `bool`

, the bitwise operation is safe as the standard states that `true`

both are `false`

converted to integers `1`

and `0`

respectively. So the only difference in this case is impatient and lazy appraisal.

source to share

`result |= Try()`

not suitable for `result = result | Try();`

. The operator `||`

you seem to understand, but the operator is `|`

completely different. This name is bitwise or (as opposed to boolean or). It has the same effect as if it was executing `a=a||b`

for every bit of the operands and did not have fast escape information that was logical and / or having. (It's also insanely fast, just as fast or faster than adding). Other bitwise operations are `&`

(bitwise and: `a=a&&b`

for each bit) and `^`

(bitwise xor: `a=(a!=b)`

for each bit).

source to share