Operators in C++
C++ has different kind of operators. Each operator define some action. We already saw couple operators: assignment operator =, and stream insertion/extraction <<, >>. There are many others in C++.
We'll list almost all operators but many of them we'll learn in later tutorials.
Each operator has one or more operands. Operator with one operand is called unary. Operator with two operands - binary. And each operator has a result - we'll call it: evaluation of an operator to some value. Let's discuss sum operator +:
As you can see operators can use literals and variables. We can do anything (that allowed by the rules of C++) with the result of operator:
Precedence of Operators in C++ Language
Here is the interesting thing. There are two operators on this line. Operator + has operands a and b. And operator = has operands c and result of a + b.
So, if there are more then one operator on one line, they will be executed one by one in the specific order. The order in which operators are executed is called precedence. + is executed before = as assignment has lower precedence than addition.
Moreover, there is such thing as associativity.
Associativity of Operators in C++
Associativity is the order of operators execution when operators have the same precedence. Let's look at the example. If we have several additions, they will be executed one by one from left to right - it corresponds to math rules. This is left to right associativity. Same if we have additions and subtractions operators mixed - they have same precedence.
Example of right to left associativity is assignment:
First will be executed the right assignment. The result of this assignment is the value that was assigned to b. After this line, all three variables will have the same value 1.
Precedence groups in C++
Almost all groups have left to right associativity. I'll point which groups have right to left.
1. Highest priority has scope resolution operator. We met it already - it's two colons. It's used for namespaces:
2. In this group there are all functional type casts - we'll know about it later.
Dot . and ->. Member access operators. They are used with more advanced data types than we know.
 and (). First is subscript - array element access, and second is function call. Again, we'll learn them soon too.
3. This group has right to left associativity. Post-increment (or postfix) ++ and post-decrement --. They are used with numbers. They increase or decrease the number by one:
Post-increment first return current value and after that increases variable by 1. The result of the first line: 1 on the screen, but in memory, after that line, there is 2 already... Purpose of these operators is to reduce the amount of code. We can substitute increment/decrement with this code:
Unary operators + and -. Unary means that operator uses only one operand.
We use minus when we want to change the sign of a number. And we can use plus explicitly if we want.
Logical and bitwise NOT: !, ~. We omit all bitwise operators by now. Logical NOT changes bool value to opposite:
C-style type casts also in this group. We'll have a big talk about typecasting very soon.
Several memory operators: allocation new, deallocation delete, sizeof, indirection a*, address-of a&. We can learn size of variable with this code:
4. Operators to access members through pointers: ->* and .*.
5.Multiplication *, division / and remainder %. The interesting operation here is remainder:
Remainder perform division and return the remainder. So in this case on the screen, you'll see 2. It's quite a common operation in programming that's why it has a separate operator in most programming languages.
6. Addition + and subtration -. Nothing interesting here. As you can see they have lower precedence than multiplication, remainder, division.
7. Bitwise shifts. Left shift << and right shift >>. Important thing - these are not stream insertion/extraction operators. Here we see that one symbol has two meanings - it's called operator overload. And C++ use this feature a lot as we'll see in the future.
Bitwise shifts works with bits - they move bits of the number to the left and to the right. It has interesting practical value. With bitwise shifts, we can easily multiply/divide by power of 2.
These two lines are equivalent and the result will be 16.
8. Comparisons: less than <, less than or equal <=, greater than >, greater than or equal >=. They return bool value.
9. Equality == and inequality !=. Return bool too.
10. Bitwise AND &. All bitwise operators work with separate bits. We'll have separate tutorial where we'll learn how to use them.
11. Bitwise XOR ^.
12. Bitwise OR |.
13. Logical AND &&.
14. Logical OR ||. Logical operations return bool value. With logical AND and OR we can build complex conditions (that's the theme of next tutorial).
15. This group has right to left associativity. There is throw operator, it's used when something unexpected happens.
Only one ternary operator in C++ ?:. Ternary means that it requires three operands. The first part of the operator is a condition. If it's true, then the second part executed, if the first part is not true, then the third part is executed. So the idea behind this operator: only second or third part will be executed and it depends on the condition in first part:
This code is not working - it's just idea how to use ?:. Later we'll actually learn how to check if the enemy is near and act accordingly.
Also in this group several assignments operators. =, +=, -=, *=, /=, %= and bitwise analogues >>=, <<=, ^=, &=, |=. We can use only first one - it's called direct assignment. Others (compound assignments) will allow you to reduce amount of code. Let's compare:
It's the same. Others compound assignments work the same way.
16. The latest one is comma ,. Here is how it can be used:
Here we defined two int variables in one line.
That's a brief view of operators in C++. We'll discuss most of them in details when we'll learn corresponding topics.