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.  Assignment (=)
The assignment operator assigns a value to a variable.

 a = 5;

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:

 a = b;

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:

// assignment operator
#include
using namespace std;
int main ()
{
int a, b;
// a:?, b:? a = 10;
// a:10, b:? b = 4;
// a:10, b:4 a = b;
// a:4, b:4 b = 7;
// a:4, b:7
cout << "a:"; cout << a;
cout << " b:"; cout <>=, <<=, &=, ^=, |=)

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: expressionis equivalent tovalue += 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
2
3
4
5
6
7
8
9
10
11
12
13

// compound assignment operators
#include
using namespace std;
int main ()
{ int a, b=3;
a = b;
a+=2;
// equivalent to a=a+2
cout <, =, Greater than=Greater than or equal to 4)
// evaluates to true. (3 != 2)
// evaluates to true. (6 >= 6)
// evaluates to true. (5 = c)
// evaluates to true since (2*3 >= 6) is true. (b+4 > a*c)
// evaluates to false since (3+4 > 2*6) is false. ((b=2) == a)
// evaluates to true.

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
2
3
4

!(5 == 5)
// evaluates to false because the expression at its right (5 == 5) is true. !(6 <= 4)
// evaluates to true because (6 6) )
// evaluates to false ( true && false ). ( (5 == 5) || (3 > 6) )
// evaluates to true ( true || false ).

Conditional operator ( ? )

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
2
3
4

7==5 ? 4 : 3
// returns 3, since 7 is not equal to 5. 7==5+2 ? 4 : 3
// returns 4, since 7 is equal to 5+2. 5>3 ? a : b
// returns the value of a, since 5 is greater than 3. a>b ? a : b
// returns whichever is greater, a or b.

// conditional operator
#include
using namespace std;
int main ()
{ int a,b,c;
a=2;
b=7;
c = (a>b) ? a : b;
cout <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. Comma operator ( , )
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:

 a = (b=3, b+2);

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 ( &, |, ^, ~, <> )

Bitwise operators modify variables considering the bit patterns that represent the values they store.

operatorasm equivalentdescription&ANDBitwise AND|ORBitwise Inclusive OR^XORBitwise Exclusive OR~NOTUnary complement (bit inversion)<>SHRShift Right

Explicit type casting operator
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
2
3

int i;
float f = 3.14;
i = (int) f;

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:

 i = int ( f );

Both ways of type casting are valid in C++.

sizeof()
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:

 a = sizeof (char);

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. Other operators
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. Precedence of operators
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:

 a = 5 + 7 % 2

we may doubt if it really means:

1
2

a = 5 + (7 % 2)
// with a result of 6, or a = (5 + 7) % 2 // with a result of 0

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:  LevelOperatorDescriptionGrouping1::scopeLeft-to-right2() [] . -> ++ — dynamic_cast static_cast reinterpret_cast const_cast typeidpostfixLeft-to-right3++ — ~ ! sizeof new deleteunary (prefix)Right-to-left* &indirection and reference (pointers)+ -unary sign operator4(type)type castingRight-to-left5.* ->*pointer-to-memberLeft-to-right6* / %multiplicativeLeft-to-right7+ -additiveLeft-to-right8<>shiftLeft-to-right9 =relationalLeft-to-right10== !=equalityLeft-to-right11&bitwise ANDLeft-to-right12^bitwise XORLeft-to-right13|bitwise ORLeft-to-right14&&logical ANDLeft-to-right15||logical ORLeft-to-right16?:conditionalRight-to-left17= *= /= %= += -= >>= <<= &= ^= |=assignmentRight-to-left18,commaLeft-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:

 a = 5 + 7 % 2;

might be written either as:

 a = 5 + (7 % 2);

or

 a = (5 + 7) % 2;

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.