5.7 — Logical operators

While relational (comparison) operators can be used to test whether a particular condition is true or false, they can only test one condition at a time. Often we need to know whether multiple conditions are true simultaneously. For example, to check whether we’ve won the lottery, we have to compare whether all of the multiple numbers we picked match the winning numbers. In a lottery with 6 numbers, this would involve 6 comparisons, all of which have to be true. In other cases, we need to know whether any one of multiple conditions is true. For example, we may decide to skip work today if we’re sick, or if we’re too tired, or if won the lottery in our previous example. This would involve checking whether any of 3 comparisons is true.

Logical operators provide us with the capability to test multiple conditions.

C++ has 3 logical operators:

Operator Symbol Form Operation
Logical NOT ! !x true if x is false, or false if x is true
Logical AND && x && y true if both x and y are true, false otherwise
Logical OR || x || y true if either x or y are true, false otherwise

Logical NOT

You have already run across the logical NOT unary operator in lesson 4.9 -- Boolean values. We can summarize the effects of logical NOT like so:

Logical NOT (operator !)
Operand Result
true false
false true

If logical NOT’s operand evaluates to true, logical NOT evaluates to false. If logical NOT’s operand evaluates to false, logical NOT evaluates to true. In other words, logical NOT flips a Boolean value from true to false, and vice-versa.

Logical NOT is often used in conditionals:

One thing to be wary of is that logical NOT has a very high level of precedence. New programmers often make the following mistake:

This program prints:

x is equal to or greater than y

But x is not equal to or greater than y, so how is this possible? The answer is that because the logical NOT operator has higher precedence than the greater than operator, the expression ! x > y actually evaluates as (!x) > y. Since x is 5, !x evaluates to 0, and 0 > y is false, so the else statement executes!

The correct way to write the above snippet is:

This way, x > y will be evaluated first, and then logical NOT will flip the Boolean result.

Best practice

If logical NOT is intended to operate on the result of other operators, the other operators and their operands need to be enclosed in parenthesis.

Simple uses of logical NOT, such as if (!value) do not need parenthesis because precedence does not come into play.

Logical OR

The logical OR operator is used to test whether either of two conditions is true. If the left operand evaluates to true, or the right operand evaluates to true, or both are true, then the logical OR operator returns true. Otherwise it will return false.

Logical OR (operator ||)
Left operand Right operand Result
false false false
false true true
true false true
true true true

For example, consider the following program:

In this case, we use the logical OR operator to test whether either the left condition (value == 0) or the right condition (value == 1) is true. If either (or both) are true, the logical OR operator evaluates to true, which means the if statement executes. If neither are true, the logical OR operator evaluates to false, which means the else statement executes.

You can string together many logical OR statements:

New programmers sometimes confuse the logical OR operator (||) with the bitwise OR operator (|). Even though they both have OR in the name, they perform different functions. Mixing them up will probably lead to incorrect results.

Logical AND

The logical AND operator is used to test whether both operands are true. If both operands are true, logical AND returns true. Otherwise, it returns false.

Logical AND (operator &&)
Left operand Right operand Result
false false false
false true false
true false false
true true true

For example, we might want to know if the value of variable x is between 10 and 20. This is actually two conditions: we need to know if x is greater than 10, and also whether x is less than 20.

In this case, we use the logical AND operator to test whether the left condition (value > 10) AND the right condition (value < 20) are both true. If both are true, the logical AND operator evaluates to true, and the if statement executes. If neither are true, or only one is true, the logical AND operator evaluates to false, and the else statement executes.

As with logical OR, you can string together many logical AND statements:

If all of these conditions are true, the if statement will execute. If any of these conditions are false, the else statement will execute.

Short circuit evaluation

In order for logical AND to return true, both operands must evaluate to true. If the first operand evaluates to false, logical AND knows it must return false regardless of whether the second operand evaluates to true or false. In this case, the logical AND operator will go ahead and return false immediately without even evaluating the second operand! This is known as short circuit evaluation, and it is done primarily for optimization purposes.

Similarly, if the first operand for logical OR is true, then the entire OR condition has to evaluate to true, and the second operand won’t be be evaluated.

Short circuit evaluation presents another opportunity to show why operators that cause side effects should not be used in compound expressions. Consider the following snippet:

if x does not equal 1, the whole condition must be false, so ++y never gets evaluated! Thus, y will only be incremented if x evaluates to 1, which is probably not what the programmer intended!

Warning

Short circuit evaluation may cause Logical OR and Logical AND to not evaluate one operand. Avoid using expressions with side effects in conjunction with these operators.

As with logical and bitwise OR, new programmers sometimes confuse the logical AND operator (&&) with the bitwise AND operator (&).

Mixing ANDs and ORs

Mixing logical AND and logical OR operators in the same expression often can not be avoided, but it is an area full of potential dangers.

Many programmers assume that logical AND and logical OR have the same precedence (or forget that they don’t), just like addition/subtraction and multiplication/division do. However, logical AND has higher precedence than logical OR, thus logical AND operators will be evaluated ahead of logical OR operators (unless they have been parenthesized).

New programmers will often write expressions such as value1 || value2 && value3. Because logical AND has higher precedence, this evaluates as value1 || (value2 && value3), not (value1 || value2) && value3. Hopefully that’s what the programmer wanted! If the programmer was assuming left to right evaluation (as happens with addition/subtraction, or multiplication/division), the programmer will get a result he or she was not expecting!

When mixing logical AND and logical OR in the same expression, it is a good idea to explicitly parenthesize each operator and its operands. This helps prevent precedence mistakes, makes your code easier to read, and clearly defines how you intended the expression to evaluate. For example, rather than writing value1 && value2 || value3 && value4, it is better to write (value1 && value2) || (value3 && value4).

Best practice

When mixing logical AND and logical OR in a single expression, explicitly parenthesize each operation to ensure they evaluate how you intend.

De Morgan’s law

Many programmers also make the mistake of thinking that !(x && y) is the same thing as !x && !y. Unfortunately, you can not “distribute” the logical NOT in that manner.

De Morgan’s law tells us how the logical NOT should be distributed in these cases:

!(x && y) is equivalent to !x || !y
!(x || y) is equivalent to !x && !y

In other words, when you distribute the logical NOT, you also need to flip logical AND to logical OR, and vice-versa!

This can sometimes be useful when trying to make complex expressions easier to read.

Where’s the logical exclusive or (XOR) operator?

Logical XOR is a logical operator provided in some languages that is used to test whether an odd number of conditions is true.

Logical XOR
Left operand Right operand Result
false false false
false true true
true false true
true true false

C++ doesn’t provide a logical XOR operator. Unlike logical OR or logical AND, logical XOR cannot be short circuit evaluated. Because of this, making an logical XOR operator out of logical OR and logical AND operators is challenging. However, you can easily mimic logical XOR using the inequality operator (!=):

This can be extended to multiple operands as follows:

Note that the above XOR patterns only work if the operands are Booleans (not integers). If you need a form of logical XOR that works with non-Boolean operands, you can static_cast them to bool:

Quiz time

Question #1

Evaluate the following expressions.

Note: in the following answers, we “explain our work” by showing you the steps taken to get to the final answer. The steps are separated by a => symbol. For example “(true || false) => true” means we evaluated “(true || false)” to arrive at the value “true”.

a) (true && true) || false

Show Solution

b) (false && true) || true

Show Solution

c) (false && true) || false || true

Show Solution

d) (5 > 6 || 4 > 3) && (7 > 8)

Show Solution

e) !(7 > 6 || 3 > 4)

Show Solution 5.x -- Chapter 5 summary and quiz Index 5.6 -- Relational operators and floating point comparisons

126 comments to 5.7 — Logical operators

• derpasaurus

When should the logical NOT be used versus the not equal to?

• Alex

You should use != when you want to check if two things are not equal. You should use ! if you want to invert a result.

It's better to use != than ! (==) because it's both clearer what your intent is, and it's one operator instead of two.

• Joe

Alex,
great work with these tutorials. I have learned so much in such a little time. Anyhow, I had this idea that it may be cool to combine all of your Rules onto one page (each rule is linked back to the section for context reference and such). anyhow... just thinking out loud here!

• Alex

Yes, this is on my to-do list. :) Thanks for reminding me that I need to get around to actually doing it. :)

• C programmer

How to decide the operator precedence in a complex logical expression like this.
if(a > b && c != 0 || d <= a != 0)

• Alex

We talk about precedence in lesson 3.1 -- Precedence and associativity.

• Jim

Alex,
Is it true that the comparison operator == can be evaluated as bool true or false? The reason for asking this is does the comparison operator have an effect on the logical or operator.  In the program above you wrote ( if ( value == 0 ll value == 1) ).  If I'm not mistaken if a user enters a value of 1 or above the left side of the or is false and the right side is always true. So the if statement still evaluated as true.  However if the user entered a 2, 3, or 4 .  The wording in the cout statements would be wrong. A negative number would have the same effect. Wouldn't it?

• Alex

Yes, operator== evaluates its operands and returns true if they are identical, and false otherwise. If the user entered a value of 2, the left hand side would evaluate to false, and the right hand side would evaluate to false, and false || false is false. The provided statement will only evaluate to true if value evaluates to 0 or 1.

• Elpidius

Here is a simplified way to understanding how the logical NOT is distributed using De Morgan's law. This is under the assumption that the operators mentioned below are all boolean true.

In the following condition:

(x && y)

If one operand is true, and one false, then both are false. Both x and y have to be true.

If you don't want the overall condition to be true, i.e. !(x && y), you have to make sure that only one of the operands is false, i.e. make sure either x is false (!x), or y is false (!y).

This way the condition will always evaluate to false. Which would be written as: !x || !y

--------------------

In the following condition:

(x || y)

Only one operand has to be true.

If you don't want the overall condition to be true, i.e. !(x || y), you have to make sure that both operands are false, i.e. make sure x is false (!x) and y is false (!y).

This way the condition will always evaluate to false. Which would be written as !x && !y

--------------------

I hope this helps anybody trying to understand this!

• Elpidius

Edit: This is under the assumption that the *operands mentioned below (i.e. x and y) are all boolean true.

• Pisces

Hello, can you tell me why this works as expected, i.e. a 0 return, assuming polje.at(x).at(y) is a ‘0’ or a ‘>’

but this does not (returns 1):

Is it because (‘0’ || ‘>’) evaulates to 1 and polje.at(x).at(y) is not a char code 1? Am I right?

• Alex

Yes, you are correct.

• Pisces

Thank you for the quick answer.

• Shiva

<u>Typo</u>

Hey Alex,

Above, isn't the first 'Short circuit evaluation' in bold the sub-heading for the section that follows? Currently it is wrapped at the end of the paragraph before it. May seem silly, but it makes it trickier to read. Or is it a browser-specific issue? (I'm using Safari 8.0.3)

Thanks again for all these great stuff. :)

• Alex

It was a formatting error. It's fixed now, thanks for pointing it out!

• Baubas

int x = 5;
int y = 7;

if (x == y)
cout << "x does not equal y";
else
cout << "x equals y";

Why do I get this: x equals y

• Alex

Your logic is inverted. You check if x is equal to y, and if so, you print that they're not equal (and vice-versa).

In other words, your output statements need to be switched.

• Aryan

Hey Alex! (This does not concern this chapter)
Just want to know if I can skip a few chapters?
Like I I don't want to study the entire 4th section, can I skip that and move on to 5th? Or if I do this will section 5th be the most difficult for me to understand?

• Alex

Depends on the lesson. Some lessons are super important, others are more situationally useful. Some are one-offs, others build on concepts over multiple lessons.

• Avneet

#include <iostream>
int main()
{
using namespace std ;
cout << "Enter a number: " ;
int value;
cin >> value ;
if ( value > 10 && value <
20)
cout << "Your value is
between 10 and 20" << endl;
else
cout << "You value is
not between 10 and 20" << endl;
return 0 ;
}
In this case, we use the logical AND operator to
test whether the left condition (nValue > 10) AND
the right condition (nValue < 20) are both true.

The variable closed in brackets is a variable that was never declared in the program. Variable declared in the program was named value (not nValue). I think you should update the paragraph (next to the program) in the logical AND operator section.
One typo:
Look at the example of logical AND. You left the character 'r' (r is missing from "Your") in your else statement. Sorry again for my bad english.

• Alex

I fixed the typos. Thanks for pointing them out!

• Todd

Typos.

"Logical not (NOT) is often used in conditionals"

"This is known as short circuit evaluation, and it is done primary (primarily) for optimization purposes." (User 'Cyrus' pointed this out)

"C++ doesn’t provide an (a) logical XOR operator."

In the following example (under 'Quiz answers'), shouldn't you use || instead of | for the OR operators?
"For example '(true | false) => true' means we evaluated '(true | false)' to arrive at the value 'true'."

In solutions 4 and 5, you mistakenly wrote '&' instead of '>':

"(5 & 6 || 4 & 3) && (7 & 8) =>"

"!(7 & 6 || 3 & 4) =>"

Alex, thanks for bearing so patiently with all my critiques! That takes some serious humility.

• Alex

You are right on all counts. Good eye! Thanks.

• Elpidius

Those who have checked out De Morgan's Law on Wikipedia, the colored region that's important in the Venn diagram is the light blue region.

For those who'd like to understand De Morgan's Law, I found that it doesn't work using AND and OR logic. It's only understandable if you use UNION(for AND) and INTERSECTION(for OR) logic.

If you'd like to understand the logic behind it, this is the best video I found explaining De Morgan's Law on YouTube:
De Morgan's Laws

• Bojan

Doesn't C++ provide the XOR operator through ^ ?

• Bojan

NVM that's Bitwise XOR, not Logical XOR!

• Stack

You might want to update the link to De Morgan’s law:
http://en.wikipedia.org/wiki/De_Morgan%27s_laws

• Alex

Thanks! Updated.

• Yotam

I came up with a pretty good analogy to help me understand the logical NOT's effect on the logical AND and OR:

Door = statement
Open Door = true statement
Closed Door = false statement

Logical AND:

1) You are walking through a long corridor. There are many doors in your path. In order to reach the other side (final statement=true), all the doors have to be open.

Logical OR:

2) You are standing in a large room. There are many doors leading out of the room. In order to leave the room (final statement=true), at least one of these doors has to be open.

Now, when you add in the NOT:

1) If you didn't reach the other side, it means that at least one of the doors in your path was closed: The first one OR the second one OR the third one etc.
2) If you didn't leave the room, it means that all the doors were closed: the first one AND the second one AND the third one etc.

You can clearly see how NOT turned the AND into OR and OR into AND.

• Joseph

I'm sorry, but your quiz section just looks like a gigantic headache to me.
I thought I knew what it was I had to figure out, but when I checked the answers it made me more confused.

• Alex

I changed the == symbol to a => symbol to (hopefully) better indicate that the quiz answers are showing you a progression of steps to get to the final answer.

eg. (true | false) => true

means we evaluated "(true | false)" to arrive at the value "true".

• Charly Escobia

Haha. pakyu all.

• Vaibhav Vardhan

#include

int main()
{
using namespace std;
cout <> nValue;

if (nValue == 0 || nValue == 1)
cout << "You picked 0 or 1" << endl;
else
cout << "You did not pick 0 or 1" << endl;
return 0;
}

In your this program if I enter any letter , the output comes that I have picked 0 or 1.........
can anyone explain me this....

• Charly Escobia

ulors. i dont understand your comment. ../..

• eyob worku

please alex i don't understand about right and left shift please expan

• Tinkerplus92

I don't know if anyone will answer but i don't understand how Logical NOT works.

int x = 5;
int y = 7;

if (!(x == y))
cout << "x does not equal to y";
else
cout << "x equals to y";

wouldn't if (!(x == y)) translate to if (!(false))
and if the variable were equal wouldn't it translate to (!(true)) the conditions in the parentheses would be set either way, my question is how does else get called when it seems the conditions no matter what will always call the first cout. I could just be missing something but I am so confused.

• Tinkerplus92

Ok I think i get it. True executes the IF statements and False executes the Else statement. If its not that please do explain to me.

• Biro Nikolett

I have some issue with the logical NOT and || parameters.

My code is this:

...

int story(){
// kiválasztása a névnek és a nem-nek. A név nem befojásoló tényezõ viszont a nem igen
// mert másképp kell szólítani, hivatkozni rá!
cout << "Well then i think i can't do anything else. \n I tell one more good night story...\n\n";
cout << " But lets do it together litle pumkins. First what would be, he or she \? \n";
cout <> sex ;

// Fiú szála a történetnek
if (sex == "he")
{
// névadás a fiúnak
cout <> character_name; cout << "\n\n";
// a történet megkezdése
cout << " ___________________________________________________________________\n";
cout <<" It was a sunny day when our hero " << character_name << " went out with they wooden sword to play a litle outside.\n";

};

// lány szála a történetnek
if (sex =="she")
{
// névadás a lánynak
cout <> character_name; cout << "\n\n";
// a történet megkezdése
cout << " ___________________________________________________________________\n";
cout <<" It was a sunny day when our heroine " << character_name << " went out with they wooden sword to play a litle outside.\n\n\n";

};

if (sex != "he" || sex!="she") {
cout << "\t Your answer is invalid. Please be sure to tipe in he or she !\n\n\n";

return story();
};

return 0;
}

When you tipe in he or she it go and ask for the name as it needed but after giving the name the prograb drop up the error message that you dont tiped he or she. But it catch the problem too if someone dont tipe in he or she he dont let them furter and warn the user.
I dont know why it is drop out the error when the program once accepted it and let them go forward.

What i wanted to do is that if the user not give right ansver ( now its he or she ) then return to the beginning after the warning. But right now is either give he or she or give someting else its stuk in a loop. ( this is just a part of my code where are i think the problem should be)

• Sakthi

Hi Alex and team,

Application of DeMorgan's Law is NOT explained in the answer of the last quiz question.

Shouldn't it be like this ?

!(7 > 6 || 3 > 4) == !(true || false)
== (!true && !false) == (false && true) == false

• Elpidius

Correction: The application of De Morgan's law is NOT necessary in the answer of the last quiz question.

De Morgan's law is only necessary if you wish to remove the parentheses from the expression. Both your's and Alex's answers are correct.

• jimbo

Hi guys and Alex. First of all thanks a lot for this great tutorial. I understand all the information youv'e provided on logical operators or at least I think I do. However the quiz has totally threw me I don't understand it at all. If someone could break it down (the quiz) so it's easier to understand it would be much appreciated. Many thanks in advance.

• kscarfe

^ this.

I don't understand the quiz at all. More explanation of the working there would be really helpful. I feel that I understood everything leading up to the quiz, but the format of the quiz was unexpected.

• Grimercy

It confused me at first as well. The equality operator is stating that all the preceding (since the previous equality operator) is equivalent to the following. The first problem's answer could be read like this.

(true && true) || false

// (true && true): If one true is true, then both trues are true, so the above statement means the same as (or ==)

true || false

// Either true or false must be true, so the above statement evaluates as (or ==)

true

If it helps to clarify, ((true && true) || false) == (true || false) == (true). Basically, the goal is to simplify the expression as far as possible, noting the simplifications with ==. Hope that helps!

• Elpidius

This also confused me. Even after I read what you wrote, Grimercy, it helped only a little bit. I still didn't understand the other questions. So while I drove to work I prayed to God. Then when I arrived home from work I understood everything.

First of all, in order to understand how to evaluate the questions we can refer to the tables Alex mentioned in this subchapter. I will rewrite them below.

Logical OR

The logical OR operator is used to test whether either of two conditions is true. If either the left operand evaluates to true, or the right operand evaluates to true, the logical OR operator returns true.

Logical OR (operator ||)
false || false == false
false || true == true
true || false == true
true || true == true

Logical AND

The logical AND operator is used to test whether both conditions are true. If both conditions are true, logical AND returns true. Otherwise, it returns false.

Logical AND (operator &&)
(false && false) == false
(false && true) == false
(true && false) == false
(true && true) == true

After reiterating the information in the tables from logical OR, and logical AND, we can now answer the questions.

1) (true && true) || false
== true || false
== true

2) (false && true) || true
== false || true
== true

3) (false && true) || false || true
== false || false || true
== false || true
== true

4) (5 > 6 || 4 > 3) && (7 > 8)
== (false || true) && false
== true && false
== false

Question 5 can be evaluated as is:

5) !(7 > 6 || 3 > 4)
== !(true || false)
== !(true)
== false

Or it can be evaluated by removing the parentheses and using De Morgan's law:

5) !(7 > 6 || 3 > 4)
== !(true || false)
== !true && !false
== false && true
== false

As you can see, the result is exactly the same.

• Rand_Al_Thor

Heyyy, look at me! I have a nice, polished, streak-free new account! Check out the shine on this baby. :)

About the quiz questions for this section of the chapter, I know they are meant to test my knowledge of the level of precedence logical AND and logical OR operators have when used in the same expression, but I can't figure out how to "answer" them after Quiz Question #3.

I got the first two fine, but I get a little lost when the third one goes into "|| true == false". I thought it would be "|| false == false" or "|| false == true", not the other way around?

I know it seems like a trivial question, but I need to understand this.

• Cyrus

This is known as short circuit evaluation, and it is done

for optimization purposes.

Should be PRIMARILY :]

• lsandling

so how do you get these symbols in Code::Blocks

• Jake

...you type them, just like anywhere else. they're on your keyboard

• Kaonashi

Can you use the logical operators in do...while loops? I try to check an user-entered integer if it's between 1 and 10. I use the && operator, but I can't get it to work properly.

Here's the code:

Whatever value I enter, the program always goes to the next part. If I check either

or

it works properly, but I can't check both at the same time...

• Kaonashi

Never mind... I see my mistake; I should've used the || operator.

Thanks for a great tutorial, Alex!

• Wintur

Kaonashi
"int nInvoer=0;
do
{
cout <> nInvoer;
}
while (nInvoer = 10 );

// Do here if entered value is between 1 and 10.

Your problem is actually that you have your comparison operators reversed. You want to evaluate between 1 and "&&" 10. As you have it written it will always come up false. This is because you are asking for less than "=", both can never be true of the same variable, thus it will always be false. If you change your and "&&" to or "||" you will instead be checking if the number entered is not between 1 and 10.

the correction for this is:

while (nInvoer >= 1 && nInvoer <= 10 );

This will check for any number including and between 1 and 10.

• Florian

Hey Ronnie,

I just thought about your XOR question and came to this solution (since their is no XOR to use directly in c++)

(!america && russia) || (america && !russia)

lets just take a logic look behind this:

So basically with only 2 conditions it is easy to handle. How did you manage to pick that example?! :)

wish you all a nice weekend
Florian

• RonnieTheBear

Hi Alex. Love the tutorials, especially how you try to relate things back to machine code and whatnot. Truly deepens my understanding. Quick question: is there not an exclusive OR? i.e. if either x OR y are true, but NOT if both are? i.e.

America has nukes / Russia has nukes / World gets destroyed

false / false / false
true / false / true
false / true / true
true / true / false [MAD theory ;)]

Or is there a combination of ANDs and ORs and NOTs to achieve this?

• Alex

C++ doesn't provide an exclusive or operator. I've added an example of how to mimic XOR behavior using operator!= into the lesson.

• Elpidius

Thank you for providing such an excellent example for mimicing logical XOR behavior using the != operator.

• Marius

Hello Alex,

Your workaround for the missing xor can only deal with booleans. To fix this use:

The ! operator will make sure the operands are bool before the != gets evaluated. This way it will work on anything that can be cast to bool. Note that xor has the same result when all operands are inverted.

• Alex

That's kind of neat. While not likely to be used very often, neither is XOR in general. I've added it to the lesson.

• Tadas

This only works if there is an equal number of operands.
If you have an equal number of operands and an odd number of them are true, there also must be an odd number of false operands. On the other hand, if you have an odd number of operands and an equal number of them are true, there must be an odd number of false operands.

Double negation (i.e. (!!a != !!b != !!c)) or static casts work for both odd and equal number of operands.

• Alex

It appears you are correct. I've updated the lesson to use static_cast instead, since doing a double-negation likely has more performance impact.

• faBRicio

Since you updated the lesson to use static_cast, you should get rid of the sentence "In this form, the logical NOT operator is used to convert the operand to an inverse boolean value. However, XOR evaluates the same way when all operands have been inverted, so this does not impact the result".

• Alex

Thanks -- sentence removed!

• Rob

I'm probably splitting hairs with this comment, but in the Logical OR section you say the following:

If the left operand evaluates to true, or the right operand evaluates to true, or both evaluate to true, the logical OR operator returns true.

However, if the left operand is true, a "short circuit" occurs. In other words, if the left operand is true, the right operand is not even evaluated because the entire statement is already true (so technically, it's not possible for both operands to evaluate to true in a logical OR). Consider the following code snippet. In this case, "True" will always be printed (the right operand is never evaluated because of the short circuit, even though dividing by zero is illegal):

• Alex

I redid the wording to disambiguate, and added a note about short circuit evaluation of logical OR. Thanks!

• shinjan

Just wondering, if this "short circuit" is something which is compiler dependent. There could be many architectures (esp DSP processors) where multiple instructions can be issued on multiple ALUs (VLIW architectures). For e.g. in (x == 1 && y++ == 2), compiler might generate a code for (x==1) and y++ to go in the same cycle. Do you think it is mandatory that compilers have to implement "short circuit".

• Alex

Short circuit evaluation is guaranteed in C++ with the fundamental data types. However, it's worth noting that if you override the || or && operator for your own classes, short circuit evaluation is not performed when used in those cases. For that reason, operators || and && normally aren't overridden.