Operators
Once we know of the existence of variables and constants, we can begin
to operate with them. For that purpose, C++ integrates operators. Unlike other
languages whose operators are mainly keywords, operators in C++ are mostly made
of signs that are not part of the alphabet but are available in all keyboards.
This makes C++ code shorter and more international, since it relies less on
English words, but requires a little of learning effort in the beginning.
You do not have to memorize all the content of this page. Most details
are only provided to serve as a later reference in case you need it.
The assignment operator assigns a
value to a variable.
|
|
|
This statement assigns the integer value 5 to the variable a.
The part at the left of the assignment operator (=)
is known as the lvalue (left value) and the
right one as the rvalue (right value). The lvalue has to be a variable whereas the rvalue
can be either a constant, a variable, the result of an
operation or any combination of these.
The most important rule when assigning is the right-to-left rule:
The assignment operation always takes place from right to left, and never the
other way:
|
|
|
This statement assigns to variable a
(the lvalue) the value contained in variable b
(the rvalue). The value that was stored until this
moment in a is
not considered at all in this operation, and in fact that value is lost.
Consider also that we are only assigning the value of b to a at the moment of the assignment operation. Therefore a later
change of b will not affect the new value of a.
For example, let us have a look at the following code - I have included
the evolution of the content stored in the variables as comments:
|
1 |
// assignment operator#include <iostream>using int
|
a:4 b:7 |
This code will give us as result that the value contained in a is 4
and the one contained in b is 7.
Notice how a was
not affected by the final modification of b,
even though we declared a = b earlier (that is
because of the right-to-left rule).
A property that C++ has over other programming languages is that the
assignment operation can be used as the rvalue (or
part of an rvalue) for another assignment operation. For
example:
|
|
|
is equivalent to:
|
1 |
|
that means: first assign 5
to variable b and then assign to a
the value 2 plus the result of the previous assignment
of b (i.e. 5), leaving a
with a final value of 7.
The following expression is also valid in C++:
|
|
|
It
assigns 5 to the all the three variables: a,
b and c.
The
five arithmetical operations supported by the C++ language are:
|
+ |
addition |
|
- |
subtraction |
|
* |
multiplication |
|
/ |
division |
|
% |
modulo |
Operations of addition, subtraction, multiplication and division
literally correspond with their respective mathematical operators. The only one
that you might not be so used to see is modulo; whose operator is the
percentage sign (%). Modulo is the operation
that gives the remainder of a division of two values. For example, if we write:
|
|
|
the variable a will
contain the value 2, since 2
is the remainder from dividing 11 between
3.
When we
want to modify the value of a variable by performing an operation on the value
currently stored in that variable we can use compound assignment operators:
|
expression |
is equivalent to |
|
value += increase; |
value = value + increase; |
|
a -= 5; |
a = a - 5; |
|
a /= b; |
a = a / b; |
|
price *= units + 1; |
price = price * (units + 1); |
and the same for all other operators. For example:
|
1 |
// compound assignment operators#include <iostream>using int
|
5 |
Shortening even more some expressions, the increase operator (++)
and the decrease operator (--)
increase or reduce by one the value stored in a variable. They are equivalent
to +=1 and to -=1,
respectively. Thus:
|
1 |
|
are all
equivalent in its functionality: the three of them increase by one the value of
c.
In the early C compilers, the three previous expressions probably
produced different executable code depending on which one was used. Nowadays,
this type of code optimization is generally done automatically by the compiler,
thus the three expressions should produce exactly the same executable code.
A characteristic of this operator is that it can be used both as a
prefix and as a suffix. That means that it can be written either before the
variable identifier (++a) or after it (a++).
Although in simple expressions like a++ or ++a
both have exactly the same meaning, in other expressions in which the result of
the increase or decrease operation is evaluated as a value in an outer
expression they may have an important difference in their meaning: In the case
that the increase operator is used as a prefix (++a) the value is increased before
the result of the expression is evaluated and therefore the increased value is
considered in the outer expression; in case that it is used as a suffix (a++)
the value stored in a is increased after being evaluated and therefore the
value stored before the increase operation is evaluated in the outer
expression. Notice the difference:
|
Example 1 |
Example 2 |
|
B=3; |
B=3; |
In Example 1, B is increased before its
value is copied to A. While in Example 2, the
value of B is copied to A
and then B is increased.
In order to evaluate a comparison between two expressions we can use the
relational and equality operators. The result of a relational operation is a
Boolean value that can only be true or false, according to its Boolean result.
We may want to compare two expressions, for example, to know if they are
equal or if one is greater than the other is. Here is a list of the relational
and equality operators that can be used in C++:
|
== |
Equal to |
|
!= |
Not equal to |
|
> |
Greater
than |
|
< |
Less than |
|
>= |
Greater than or equal to |
|
<= |
Less than or equal to |
Here
there are some examples:
|
1 |
|
Of course, instead of using only numeric constants, we can use any valid
expression, including variables. Suppose that a=2,
b=3 and c=6,
|
1 |
|
Be
careful! The operator = (one equal
sign) is not the same as the operator ==
(two equal signs), the first one is an assignment operator (assigns the value
at its right to the variable at its left) and the other one (==) is the equality operator that compares whether
both expressions in the two sides of it are equal to each other. Thus, in the
last expression ((b=2) == a), we
first assigned the value 2 to b and then we compared it to a, that also stores the value 2, so the result of the operation is true.
Logical operators ( !, &&, || )
The Operator !
is the C++ operator to perform the Boolean operation NOT, it has only one
operand, located at its right, and the only thing that it does is to inverse
the value of it, producing false if its operand is true and true if its operand
is false. Basically, it returns the opposite Boolean value of evaluating its
operand. For example:
|
1 |
|
The logical operators && and ||
are used when evaluating two expressions to obtain a single relational result.
The operator && corresponds with
Boolean logical operation AND. This operation results true if both its two
operands are true, and false otherwise. The following
panel shows the result of operator &&
evaluating the expression a && b:
&& OPERATOR
|
a |
b |
a && b |
|
true |
true |
true |
|
true |
false |
false |
|
false |
true |
false |
|
false |
false |
false |
The operator || corresponds with Boolean
logical operation OR. This operation results true if either one of its two
operands is true, thus being false only when both operands are false
themselves. Here are the possible results
of a
|| b:
|| OPERATOR
|
a |
b |
a || b |
|
true |
true |
true |
|
true |
false |
true |
|
false |
true |
true |
|
false |
false |
false |
For example:
|
1 |
|
The conditional operator evaluates
an expression returning a value if that expression is true and a different one
if the expression is evaluated as false. Its format is:
condition ?
result1 : result2
If condition is true the expression
will return result1, if it is not it will return
result2.
|
1 |
|
|
1 |
// conditional operator#include <iostream>using int
|
7 |
In this example a was 2
and b was 7,
so the expression being evaluated (a>b)
was not true, thus the first value specified after the question mark was
discarded in favor of the second value (the one after
the colon) which was b, with a value of 7.
The comma operator (,)
is used to separate two or more expressions that are included where only one
expression is expected. When the set of expressions has to be evaluated for a
value, only the rightmost expression is considered.
For example, the following code:
|
|
|
Would first assign the value 3 to b,
and then assign b+2 to variable a.
So, at the end, variable a
would contain the value 5 while
variable b would contain value 3.
Bitwise operators modify variables
considering the bit patterns that represent the values they store.
|
operator |
asm equivalent |
description |
|
& |
AND |
Bitwise
AND |
|
| |
OR |
Bitwise
Inclusive OR |
|
^ |
XOR |
Bitwise
Exclusive OR |
|
~ |
NOT |
Unary complement (bit inversion) |
|
<< |
SHL |
Shift Left |
|
>> |
SHR |
Shift Right |
Type casting operators allow you to
convert a datum of a given type to another. There are several ways to do this
in C++. The simplest one, which has been inherited from the C language, is to
precede the expression to be converted by the new type enclosed between
parentheses (()):
|
1 |
intfloat
|
The previous code converts the float number 3.14
to an integer value (3), the remainder is lost.
Here, the typecasting operator was (int).
Another way to do the same thing in C++ is using the functional notation:
preceding the expression to be converted by the type and enclosing the
expression between parentheses:
|
|
|
Both ways of type casting are valid in C++.
This operator accepts one
parameter, which can be either a type or a variable itself and returns the size
in bytes of that type or object:
|
|
|
This will assign the value 1
to a because char is a
one-byte long type.
The value returned by sizeof
is a constant, so it is always determined before program execution.
Later in these tutorials, we will
see a few more operators, like the ones referring to pointers or the specifics
for object-oriented programming. Each one is treated in its respective section.
When writing complex expressions
with several operands, we may have some doubts about which operand is evaluated
first and which later. For example, in this
expression:
|
|
|
we may doubt if it really means:
|
1 |
|
The correct answer is the first of the two expressions, with a result of 6.
There is an established order with the priority of each operator, and not only
the arithmetic ones (those whose preference come from mathematics) but for all
the operators which can appear in C++. From greatest to lowest priority, the
priority order is as follows:
|
Level |
Operator |
Description |
Grouping |
|
1 |
:: |
scope |
Left-to-right |
|
2 |
() [] . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid |
postfix |
Left-to-right |
|
3 |
++ -- ~ ! sizeof new
delete |
unary (prefix) |
Right-to-left |
|
* & |
indirection and reference
(pointers) |
||
|
+ - |
unary sign operator |
||
|
4 |
(type) |
type casting |
Right-to-left |
|
5 |
.* ->* |
pointer-to-member |
Left-to-right |
|
6 |
* / % |
multiplicative |
Left-to-right |
|
7 |
+ - |
additive |
Left-to-right |
|
8 |
<< >> |
shift |
Left-to-right |
|
9 |
< > <= >= |
relational |
Left-to-right |
|
10 |
== != |
equality |
Left-to-right |
|
11 |
& |
bitwise
AND |
Left-to-right |
|
12 |
^ |
bitwise
XOR |
Left-to-right |
|
13 |
| |
bitwise
OR |
Left-to-right |
|
14 |
&& |
logical
AND |
Left-to-right |
|
15 |
|| |
logical
OR |
Left-to-right |
|
16 |
?: |
conditional |
Right-to-left |
|
17 |
= *= /= %= += -= >>= <<= &= ^= |= |
assignment |
Right-to-left |
|
18 |
, |
comma |
Left-to-right |
Grouping
defines the precedence order in which operators are evaluated in the case that
there are several operators of the same level in an expression.
All
these precedence levels for operators can be manipulated or become more legible
by removing possible ambiguities using parentheses signs (
and ), as in this example:
|
|
|
might be
written either as:
|
|
|
or
|
|
|
depending on the operation that we want to perform.
So if you want to write complicated expressions and you are not
completely sure of the precedence levels, always include parentheses. It will
also become a code easier to read.