กก

Section 1.3 Operators.

Once we know the existence of variables and constants we can begin to operate with them. For that exist the operators, which in C++ are reserved words and signs not included in the alphabet but available in almost every keyboard of the world. It is important to know them since they are the basis of the C++ language.

You do not have to memorize all the content of this page, since the details are only specified to serve you as a later reference if you need it.

Assignation (=).

The assignation operator serves for assigning a value to a variable.

a = 5;

assigns the integer value 5 to variable a. The part at the left of the = operator is known as lvalue (left value) and the right one as rvalue (right value). lvalue must always be a variable whereas right side can be any constant, variable, result of operation or any combination of such.

It is necessary to emphasize that the assignation operation always takes place from right to left and never at the inverse.

a = b;

assigns to the variable a (lvalue) the value that contains the variable b (rvalue) independently of the value that was stored in a until then. Consider that we are only assigning the value of b to a and that a later change of b would not affect the new value of a.

For example, if we take this code (with the evolution of the variables' content in green color):

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

will give us as result that the value contained in a is 4 and the one contained in b is 7. The final modification of b has not affected a although before we have declared a = b;.

A property that has the assignation operation in C++ over the ones of other programming languages is that an allocation operation can serve as rvalue (or part of an rvalue) for another assignation. For example:

a = 2 + (b = 5);

is equivalent to:

b = 5;
a = 2 + b;

that means: first assign 5 to variable b and then assign to a the value 2 plus the result of the previous assignation of b (that is 5), remaining a with a final value of 7. Thus, the following expression is also valid in C++:

a = b = c = 5;

assigns 5 to the three variables a, b and c.

Arithmetic operators ( +, -, *, /, % )

The five arithmetical operations supported by the language are:

+	addition
-	subtraction
*	multiplication
/	division
%	module

Operations of addition, subtraction, multiplication and division would not suppose an understanding challenge for you since they literally correspond with their respective mathematical operators.

The only that can seem strange to you is the module, specified with the percentage sign (%). Module is the operation that gives the rest of a division of two integer values. For example, if a = 11 % 3;, the variable a will contain 2 as result since 2 is the rest from dividing 11 between 3.

Compound assignation operators (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

A feature of the allocation in C++ that contributes to its fame of sparing language when writing are the compound assignation operators (+=, -=, *= and /= among others), which allow to modify the value of a variable with one of the basic operators:

value += increase; is equivalent to value = value + increase;
a -= 5; is equivalent to a = a - 5;
a /= b; is equivalent to a = a / b;
price *= units + 1; is equivalent to price = price * (units + 1);

and the same for all other operations.

Increase and decrease.

Another example of saving when writing code is the increase operator (++) and the decrease operator (--). They add or reduce by 1 the value stored in a variable. They are equivalent to +=1 and to -=1, respectively. Thus:

a++;
a+=1;
a=a+1;

are equivalent on its function: the three increase by 1 the value of a.

Its existence is due to that in the first C compilers the three previous expressions produced different executable code according on which was used.

A characteristic of this operator is that it can be both prefix or suffix, that means, can be written before the variable identifier (++a) or after (a++) and, although in so simple expressions like a++ or ++a they have the same meaning, in other operations in which the result of the increase or decrease is evaluated as another expression may have an important difference in their meaning: In case that the increase operator is used as a prefix (++a) the value is increased before the expression is evaluated and therefore the already increased value is considered in the expression; in case that it is used as suffix (a++) the value stored in a is increased after being evaluated and therefore in the expression the value stored before the increase operation is evaluated. Notice the difference:

Example 1	Example 2
B=3; A=++B; // A is 4, B is 4	B=3; A=B++; // A is 3, B is 4

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 later B is increased.

Relational operators ( ==, !=, >, <, >=, <= )

In order to evaluate a comparison between two expressions we can use the Relational operators. As specified by the ANSI-C++ standard the result of a relational operation is a bool value that can only be true or false, according to if the resulting expression is true or false.

We may want to compare two expressions, for example, to know if they are equal or if one is greater than other. Here is a list of the relational operators you can use in C++:

==	Equal
!=	Different
>	Greater than
<	Less than
> =	Greater or equal
< =	Less or equal

Here you have a pair of examples:

(7 == 5)	would return false.
(5 > 4)	would return true.
(3 != 2)	would return true.
(6 >= 6)	would return true.
(5 < 5)	would return false.

of course, instead of using only numbers, we could use any expression. Suppose that a=2, b=3 and c=6,

(a == 5)	would return false.
(a*b >= c)	would return true since (2*3 >= 6) is it.
(b+4 < a*c)	would return false since (3+4 < 2*6) is it.
((b=2) == a)	would return true.

Be aware that = (one equal sign) is not the same as == (two equal signs), the first one is an assignation operator (assigns the right side of the expression to the variable in the left) and the other (==) is a relational operator of equality that compares if both expressions in the two sides of the operator 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 with a, that also stores the value 2, being true the result of the operation.

In many compilers previous to the publication of the ANSI-C++ standard, as well as in the C language, the relational operations did not return a bool value true or false, but they returned an int as result with a value of 0 in order to represent "false" and a value different from 0 (generally 1) to represent "true". For more information, or if your compiler does not support the bool type, consult the section bool type.

Logic operators ( !, &&, || ).

Operator ! is equivalent to boolean operation NOT, it has only one operand located at its right, and the only thing that it does is to invert the value of it, producing false if its operand is true or true if its operand is false. Is like to say that it returns the opposite result of evaluating its operand. For example:

!(5 == 5)	returns false because the expression at its right (5 == 5) would be true.
!(6 <= 4)	returns true because (6 <= 4) would be false.
!true	returns false.
!false	returns true.

Logic operators && and || are used when evaluating two expressions to obtain a single result. They correspond with boolean logic operations AND and OR respectively. The result of them depends on the relation between its two operands:

First Operand a	Second Operand b	result a && b	result a || b
true	true	true	true
true	false	false	true
false	true	false	true
false	false	false	false

For example:

( (5 == 5) && (3 > 6) ) returns false ( true && false ).
( (5 == 5) || (3 > 6)) returns true ( true || false ).

Conditional operator ( ? ).

The conditional operator evaluates an expression and returns a different value according to the evaluated expression, depending on if it is true or false. Its format is:

condition ? result1 : result2

if condition is true the expression will return result1, if not it will return result2.

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 a, since 5 is greater than 3.
a>b ? a : b	returns the greater one, a or b.

Bitwise Operators ( &, |, ^, ~, <<, >> ).

Bitwise operators modify the variables considering the bits that represent the number stored in them, that means, the binary representation of such.

op	asm	Description
&	AND	Logical AND
|	OR	Logical OR
^	XOR	Logical exclusive OR
~	NOT	Complement to one (bit inversion)
<<	SHL	Shift Left
>>	SHR	Shift Right

For more information about binary numbers and bitwise operations, consult Boolean logic.

Explicit type casting operators

Type casting operators allows you to convert a datum of a given type to another type. There are some ways to do this in C++, the most basic one, that comes from the C language is to precede the expression to be converted by the new type enclosed between parenthesis (), like in:

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

The previous code converts the float number 3.14 to an integer value (3). Here, the type casting operator was (int). Another way to do the same thing in C++ is using constructors instead of operators: preceding the expression to be converted by the type and enclose the expression between parenthesis:

i = int ( f );

Both ways of type casting are valid in C++. And additionally ANSI-C++ added new type casting operators more specific to object oriented programming.

sizeof()

This operator accepts one parameter, that can be either a variable type or a variable itself and returns the size in bytes of that type or object:

a = sizeof (char);

This will return 1 to a because char is generally one byte long in all systems.
The value returned by sizeof is a constant, so it is always determined before program execution.

Other operators

More ahead we will see a few more operators, like the ones referring to pointers or the specifics of object-oriented programming, that are treated in their respective sections.

Priority of operators

a = 5 + 7 % 2

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

Priority	Operator	Description	Associativity
1	::	scope	Left
2	() [ ] -> . sizeof		Left
3	++ --	increment/decrement	Right
	~	Complement to one (bitwise)
	!	unary NOT
	& *	Reference and Dereference (pointers)
	(type)	Type casting
	+ -	Unary less sign
4	* / %	arithmetical operations	Left
5	+ -	arithmetical operations	Left
6	<< >>	bit shifting (bitwise)	Left
7	< <= > >=	Relational operators	Left
8	== !=	Relational operators	Left
9	& ^ |	Bitwise operators	Left
10	&& ||	Logic operators	Left
11	?:	Conditional	Right
12	= += -= *= /= %= >>= <<= &= ^= |=	Assignation	Right
13	,	Comma, Separator	Left

Associativity defines in the case that there are several operators of the same priority level, which one must be evaluated before, the rightmost one or the leftmost one.

All these precedence levels for operators can be manipulated or become more legible using parenthesis "(" and ")" like in this example:

a = 5 + 7 % 2;

a = 5 + (7 % 2); or
a = (5 + 7) % 2;

So if you want to write a complicated expression and you are not sure of the precedence levels include always parenthesis. It will also be a more legible code.

© The C++ Resources Network, 2000 - All rights reserved

Previous: 1-2. Variables. Data types. Constants.

index

Next: 1-4. Communication through console.