logical, and bitwise operators.

First, we have the four basic arithmetic operations, as well as modulus to get the division remainder.

Notice that the division sign gives an incorrect result here. This is because it operates on

two integer values and will therefore trunctate the result and return an integer. To get the

correct value we need to explicitly convert one of the numbers to a floating-point number.

A common use of the assignment and arithmetic operators is to operate on a variable and

then to save the result back into that same variable. These operations can be shortened

with the combined assignement operators.

Another common operation is to increment or decrement a variable by one.

This can be simplified with the increment (++) and decrement (--) operators.

Both of these can either be used before or after a variable.

The result on the variable is the same whichever we use. The difference is that the post-operator

returns the original value before it changes the variable while the pre-operator changes

the variable first and then returns the value.

Next, there's the comparison operators that compares two values and returns either true or false.

Used together with these we have the logical operators. Logical and (&&) evaluates to true if both the left and right sides are true,

and logical or (||) is true if either the left or right side is true.

To invert a boolean result we also have logical not (!). Note

that for both "logical and" and "logical or" the righthand side won't be evaluated if the

result is already determined by the left side.

Lastly, we have the bitwise operators which allow us to manipulate individual bits inside

of an integer. For example, the or operator (|) makes the

resulting bit 1 if the bits are set on either side of the operator. These bitwise operators

also have shorthand assigment operators.

Now, let's look at operator precedence. In C++ expressions are normally evaluated from

left to right. However, as can be seen in this table different operators also have different

precedents that determine which one gets evaluated first. This same order also applies to many

other languages such as Java and C# also. As an example, the logical and operator binds

weaker than the relational operators, which in turn binds weaker than the arithmetic operators.

To make things clearer we should instead use parenthesis to decide what part of the expression

will be evaluated first since parenthesis has the highest precendence of all operators.