What is the difference between && and ||? [duplicate]

Question 1

You are looking at a "C++ puzzle" which is using two languages tricks.

The first is that postincrement uses the value of the variable first, then increments the variable.

So x++ has the value 2 in the expression and then x becomes 3 y++ has the value 0 in the expression, and then y becomes 1

&& is and || is or

both operators are short-circuiting.

Look at && first.

In order for and to be true, both sides must be true (non-zero)

Since it is x++ && y++, first the x++ happens, and since it is non-zero (true) the y++ has to happen to determine whether the result is true or not. Therefore x is 3 and y is 1.

The second case is the same. y is zero, but in order to determine if the OR is true, the if statement executes the second half of the expression.

The third case, since it is in the opposite order, never executes y++ because

x++ || y++

the first half being x++, it is already true, so the compiler does not bother to execute the second half of the test.

Question 2

int x=2,y=0;

Condition in if() is evaluated according to the rules:

operator && evaluates left operand first and if the value is logically false then it avoids evaluating the right operand. Typical use is for example if (x > 0 && k/x < limit) ... that avoids division by zero problems.
operator || evaluates left operand first and if the value is logically true then it avoids evaluating the right operand. For example if (overwrite_files || confirm("File existing, overwrite?")) ... will not ask confirmation when the flag overwrite_files is set.

To understand the following it is also important to note that x++ is postincrementation what means that in if( x++) x has the old value but just in the next line (or even same line but after if() was tested) x is incremented.

(i)

if(x++ && y++) // x=2,y=0;
 // 2 so y++ is evaluated
cout<<x<<y;    // skipped, but now x=3,y=1; 
Output:

(ii)

if(y++ || x++)    // x=2,y=0;
 //0 so x++ is evaluated
cout<<x<<" "<<y;  // x=3,y=1;
Output: 3 1

(iii)

if(x++||y++)      // x=2,y=0;
 //2 so y++ is not evaluated
cout<<x<<" "<<y;  // x= 3,y=0;

"IF" argument evaluation order?

Question 3

In C++ (and a few other languages) && and || are your logical operators in conditions. && is the logical AND operator and || is the logical OR operator.

When using these in a condition, the result of the condition is dependent on what is on either side of these operators and is read as if you were just saying the words.

Example:
if(thisNum > 0 && thisNum < 10) is read as "if thisNum is greater-than zero AND less-than 10, the condition will be true." Therefore, any number between 0 and 10 will make the condition true.

if(thisNum > 0 || thisNum < 10) is read as "if thisNum is greater-than zero OR less-than 10, the condition will be true." Therefore, ANY number at all will make this statement true because only one part of this statement has to be true to evaluate to TRUE.

A more detailed explanation on how these work is this:
OR (||) - If EITHER or BOTH sides of the operator is true, the result will be true.

AND (&&) - If BOTH and ONLY BOTH sides of the operator are true, the result will be true. Otherwise, it will be false.

There are many more explanations, including truth tables around the internet if you do a Google search to assist in understanding these.

As for your examples.

if(x++ && y++)
    cout<<x<<y;

You are doing an if statement that is comparing the the values of x and y. The important thing to remember is that you are NOT comparing the values together. In C++, and non-zero value will evaluate to TRUE while a zero value will result in FALSE. So, here you are checking to see if x AND y are TRUE and then increasing their values by one AFTER the comparison. Since x = 2 and y = 0, we have one TRUE value and one FALSE value and since we have a && (AND) operator between them we know the result of the condition is FALSE (since both aren't TRUE) and the output is skipped.

if(y++ || x++)
    cout<<x<<" "<<y;

In this example, we are doing the same thing EXCEPT we are doing a logical OR operation instead of AND (since we have || and not &&). This means, as I said above, that only one part of the condition has to be TRUE to result in TRUE. Since our values are still x = 2 and y = 0, we have one TRUE value and one FALSE value. Since part is TRUE, the whole condition is TRUE and the output occurs.

The reason the result is 3 1 and not 2 0 is because of the ++ operators after the variables. When the ++ operators are after the variable, it will add one AFTER the rest of the line has occurred and done the actions it needs. So it does evaluates the condition THEN increases the values by one.

if(x++||y++)
    cout<<x<<" "<<y;

This example is EXACTLY the same, the only difference is that the values have been swapped. And since it is an OR (||) operation, only one part has to be TRUE. And as before, we have one TRUE value (since x is non-zero) and one FALSE value (since y is zero). Therefore, we have a TRUE result, meaning the output is NOT skipped and we get the answer 3 1 again (since the ++ operators came AFTER the variables).

Now, speaking of the ++ operator. What if in the first example it had been:

if(++x && ++y)
    cout<<x<<y;

We would get a DIFFERENT result in this situation. Since the ++ operator comes BEFORE the variables, the first thing that happens is that the values are increased by one AND THEN the condition is evaluated. Since our new values would be x = 3 (TRUE) and y = 1 (also TRUE), we can conclude that we would get the same result as the other two examples since BOTH values are TRUE (which, since we have an AND (&&) operator, BOTH variables have to be TRUE to result in TRUE).

Hope this helps.

EDIT:
One of the other answers made an excellent point about the second and third examples. Result wise, there is no difference. HOWEVER, in terms of how it is evaluated there is a difference.

C++ automatically does something called "short-circuit evaluation". This means, it will skip any evaluations if it knows the result is already going to be TRUE or FALSE. This means that with an OR operation, if the first part is TRUE it will just skip the second part since it already knows the result HAS TO BE TRUE. (Remember, with OR only one part of the comparison has to be TRUE.) So this means that IF the first part is FALSE then the program HAS TO evaluate the second part too, since it determines whether the result will be TRUE or FALSE.
With an AND operation, it will do the opposite. If the first part is FALSE then the program knows the result has to be FALSE and will skip the rest. However, if the first part is TRUE then the program HAS TO evaluate the rest to determine if the result is TRUE or FALSE.

In terms of your examples, this means the second one HAS TO evaluation both sides since the first part results in FALSE.
In the third example, the second part is skipped because the first part is TRUE, meaning the whole condition is TRUE.

Question 4

For or(||) operator, if the expression of left side is true, it will ignore the expression of right side.

For and(&&) operator, if the expression of left side is false, it will ignore the expression of right side.

This is the answer of your question what makes the difference between (ii) and (iii).

Question 5

In the output (ii), it is:

as the time where compiler is evaluating y, y is equal to 0 so the statement is false it s evaluating the other member x which is equal to 2 so the statement is true. And then it operates the increment operator.

In the output (iii), it is:

as the time where compiler is evaluating x, x is equal to 2 so the statement is true as the operator of the condition is || it won't evaluate the other expression so the y++ is ignored. Only x will be incremented.