### Logical operatorsEdit

The operators ` and` (can also be written as

**&&**) and

`(can also be written as`

**or****||**) allow two or more conditions to be chained together. The

`operator checks whether all conditions are true and the`

**and**`operator checks whether at least one of the conditions is true. Both operators can also be mixed together in which case the order in which they appear from left to right, determines how the checks are performed. Older versions of the C++ standard used the keywords`

**or****&&**and

**||**in place of

`and`

**and**`. Both operators are said to`

**or***short circuit*. If a previous

`condition is false, later conditions are not checked. If a previous`

**and**`condition is true later conditions are not checked.`

**or**The ` not` (can also be written as

**!**) operator is used to return the inverse of one or more conditions.

**Syntax**:

condition1andcondition2condition1orcondition2notcondition

**Examples**:

When something should not be true. It is often combined with other conditions. If x>5 but not x = 10, it would be written:

```
if ((x > 5) and not (x == 10)) // if (x greater than 5) and ( not (x equal to 10) )
{
//...code...
}
```

When all conditions must be true. If x must be between 10 and 20:

```
if (x > 10 and x < 20) // if x greater than 10 and x less than 20
{
//....code...
}
```

When at least one of the conditions must be true. If x must be equal to 5 or equal to 10 or less than 2:

```
if (x == 5 or x == 10 or x < 2) // if x equal to 5 or x equal to 10 or x less than 2
{
//...code...
}
```

When at least one of a group of conditions must be true. If x must be between 10 and 20 or between 30 and 40.

```
if ((x >= 10 and x <= 20) or (x >= 30 and x <= 40)) // >= -> greater or equal etc...
{
//...code...
}
```

Things get a bit more tricky with more conditions. The trick is to make sure the parenthesis are in the right places to establish the order of thinking intended. However, when things get this complex, it can often be easier to split up the logic into nested if statements, or put them into bool variables, but it is still useful to be able to do things in complex boolean logic.

Parenthesis around `x > 10` and around `x < 20` are implied, as the `<` operator has a higher precedence than ` and`. First

`x`is compared to 10. If

`x`is greater than 10,

`x`is compared to 20, and if

`x`is also less than 20, the code is executed.

#### and (&&)Edit

statement1 |
statement2 |
and |
---|---|---|

T | T | T |

T | F | F |

F | T | F |

F | F | F |

The logical AND operator, **and**, compares the left value and the right value. If both *statement1* and *statement2* are true, then the expression returns TRUE. Otherwise, it returns FALSE.

```
if ((var1 > var2) and (var2 > var3))
{
std::cout << var1 " is bigger than " << var2 << " and " << var3 << std::endl;
}
```

In this snippet, the **if** statement checks to see if *var1* is greater than *var2*. Then, it checks if *var2* is greater than *var3*. If it is, it proceeds by telling us that *var1* is bigger than both *var2* and *var3*.

#### or (||)Edit

statement1 |
statement2 |
or |
---|---|---|

T | T | T |

T | F | T |

F | T | T |

F | F | F |

The logical OR operator is represented with **or**. Like the logical AND operator, it compares *statement1* and *statement2*. If either *statement1* or *statement2* are true, then the expression is true. The expression is also true if both of the statements are true.

```
if ((var1 > var2) or (var1 > var3))
{
std::cout << var1 " is either bigger than " << var2 << " or " << var3 << std::endl;
}
```

Let's take a look at the previous expression with an OR operator. If *var1* is bigger than either *var2* or *var3* or both of them, the statements in the **if** expression are executed. Otherwise, the program proceeds with the rest of the code.

#### not (!)Edit

The logical NOT operator, **not**, returns TRUE if the statement being compared is not true. Be careful when you're using the NOT operator, as well as any logical operator.

```
not x > 10
```

The logical expressions have a higher precedence than normal operators. Therefore, it compares whether "not x" is greater than 10. However, this statement always returns false, no matter what "x" is. That's because the logical expressions only return boolean values(1 and 0).