Hi,

I realised that the the logical operators && and || are doing the same as & and |.

int res1 = 5 == 5 && 3 < 4
int res2 = 5 == 5 & 3 < 4

return the same result. I always used them without thinking about their difference. So why do I need extra operators for logical operations?

Thanks

& is binary:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

So if both sides of (foo == 1) & (bar == 2) evaluate to true, then the expression is true. But that only works with boolean values. Consider:

if (1 & 2) {
  // not true
}

if (1 && 2) {
  // true
}

Also, logical operators will short circuit.

They are used for different things ... although many times they are interchangeable.

They don't.

int a = 2 & 4;
int b = 2 && 4;

printf("a = %i", a);
printf("b = %i", b);

The logical operators evaluate each operand as a boolean, perform their logic on them, and return a boolean.
The binary operators evaluate each operand as an integer, perform their logic on individual bits, and return an integer.

I think | is always the same as ||... (in a condition)

Dustin: If both operands are booleans (only values 0x00000001 and 0x00000000), and if there are no side effects of evaluating the right one, and if you only care if the result equals zero; then yes, you get the same result.

Note that under the same conditions, + is the same as ||

Doesn't C++ require Booleans to be 1... uh, or 0 exclusively? 4 | 6 isn't the same as 4 || 6 then.

From what I remember being told, bools in C++ are not numbers, but are either true or false. Nothing else. False is interpreted as integer 0 (same as NULL is interpreted as integer 0, even if the NULL address is not 0x00000000), and true is a non-0 integer. Most compilers will use 1, but -1 and 124354245 are just as valid.

Dustin: I said "under the same conditions".... UINT_MAX is not equal to 0x00000001 or 0x00000000.

Unrelatedly, here are two valid uses of the operators, where you really shouldn't mistake one for the other.

// Use high quality sprite if available, or use the normal one.
// (If there was a big problem, none is available, so use a generic "missing" sprite)
BITMAP *sprite = high_quality_sprite || normal_quality_sprite || sprite_missing;

...

// Store multiple related booleans in a single field.
this->Collision_flags = COLLISION_SOLID | COLLISION_GRAVITY | COLLISION_PUSHABLE;

What did I miss ? Associativity is left-to-right, I just checked. I admit it's not a construct I actually use, so I'd rather know what's the mistake.

That should not matter. If the first one is zero, the next one will be returned (etc). I can't see why that would fail... Though I only ever used it in actionScript and ruby.

No. It requires boolean false to evaluate to zero when cast to integer, and boolean true to something non-zero. 1 is common, but AFAIK any other non-zero value would be valid too. The important thing is that when you cast a boolean to int and then back to boolean, the original value must be retained.
4 | 6 returns 6, 4 || 6 returns true. If you interpret the result as a boolean, both are equivalent, but not if you interpret them as integers.

The most important point IMO however is readability. Use the distinction between logical and bit-wise operator to clearly indicate your intention, even if they happen to be interchangeable.

Oh that's intresting. Never tried it in C/C++, just assumed it worked as in other languages

It's simple when you think about it like this. Boolean operators are either equal to 0 (FALSE) or not equal to zero (TRUE)... So any value that is not zero is TRUE.

Bottom line is, the two types of OR and AND operators should not be confused with each other. You will get unexpected results...

[edit]Arg... I was too slow...