FM-AA-CIA-15 Rev.

0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

STUDY GUIDE FOR MODULE NO. 4

Expressions and Operators in C++

MODULE OVERVIEW

Welcome to this module! By the time that you are reading this, you have been immersed with the identifiers,
variables and data types in C++ programming and started your adventurous journey in programming. Further,
declaration and initialization and assignment including scope and lifetime were also introduced to you in the
previous module. However, the best way to learn to program is through writing programs directly. Thus, ready
your tools and let’s start a new knowledge to enjoy programming!

MODULE LEARNING OBJECTIVES

By the end of this module you should be able to:

 Familiarize themselves with the different uses of operators, and expressions in C++ programming.
 Apply the different functions of operators, and expressions in building C++ programs.

LEARNING CONTENTS (Assignment Operator (=))

Introduction

An expression is a combination of literals, variables, operators, and explicit function calls (not shown above)
that produce a single output value. When an expression is executed, each of the terms in the expression is
evaluated until a single value remains (this process is called evaluation). That single value is the result of the
expression.

Here are some examples of different kinds of expressions, with comments indicating how they evaluate:
2 // 2 is a literal that evaluates to value 2
"Hello world!" // "Hello world!" is a literal that evaluates to text "Hello world!"
x // x is a variable that evaluates to the value of x
2+3 // 2 + 3 uses operator + to evaluate to value 5
x=2+3 // 2 + 3 evaluates to value 5, which is then assigned to variable x
std::cout << x // x evaluates to the value of x, which is then printed to the console

Note: Wherever you can use a single value in C++, you can use an expression instead, and the compiler will resolve the expression
down to a single value.

In mathematics, an operation is a mathematical calculation involving zero or more input values (called operands)
that produces a new value (called an output value). The specific operation to be performed is denoted by a
construct (typically a symbol or pair of symbols) called an operator.

For example, as children we all learn that 2 + 3 equals 5. In this case, the literals 2 and 3 are the operands, and
the symbol + is the operator that tells us to apply mathematical addition on the operands to produce the new
value 5.

1.1 Assignment Operator

The assignment operator assigns a value to a variable.

x = 5;

PANGASINAN STATE UNIVERSITY 1

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

This statement assigns the integer value 5 to the variable x. The assignment operation always takes place from
right to left, and never the other way around:

x = y;

This statement assigns to variable x the value contained in variable y. The value of x at the moment this
statement is executed is lost and replaced by the value of y.

Consider also that we are only assigning the value of y to x at the moment of the assignment operation.
Therefore, if y changes at a later moment, it will not affect the new value taken by x.

For example, let's have a look at the following code:

C++ Code
// assignment operator
#include <iostream>
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 << b;
}

[Sample Output]
a:4 b:7 0---------------------------------------------------0-0-

This program prints on screen the final values of a and b (4 and 7, respectively). Notice how a was not affected
by the final modification of b, even though we declared a = b earlier.

Assignment operations are expressions that can be evaluated. That means that the assignment itself has a
value, and -for fundamental types- this value is the one assigned in the operation. For example:

y = 2 + (x = 5);

In this expression, y is assigned the result of adding 2 and the value of another assignment expression (which
has itself a value of 5). It is roughly equivalent to:

1 x = 5;
2 y = 2 + x;

With the final result of assigning 7 to y.

The following expression is also valid in C++:

x = y = z = 5;

It assigns 5 to the all three variables: x, y and z; always from right-to-left.

Now let’s us have a practice. Type the following codes in C++ IDE available in your laptop.

PANGASINAN STATE UNIVERSITY 2

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_
C++ Code [assignOperator.cpp]
#include <iostream>
using namespace std;

int main() {
int a, b, temp;

// 2 is assigned to a
a = 2;
// 7 is assigned to b
b = 7;
// value of a is assigned to temp
temp = a; // temp will be 2
cout << "temp = " << temp << endl;

// assigning the sum of a and b to a

a += b; // a = a +b
cout << "a = " << a << endl;

return 0;
}

[Sample Output]
temp = 2
a = 9

LEARNING ACTIVITY 1

Try to answer the following by indicating what output each should produce.

For each of the following, indicate what output they produce:

a) std::cout << 3 + 4;
b) std::cout << 3 + 4 - 5;
c) std::cout << 2 + 3 * 4;

LEARNING CONTENTS (Arithmetic Operators ( +, -, *, /, % ) )

Arithmetic operators are used to perform arithmetic operations on variables and data.

The five arithmetical operations supported by C++ are:

operator description
+ addition
- subtraction
* multiplication
/ division
% modulo

PANGASINAN STATE UNIVERSITY 3

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_
Operations of addition, subtraction, multiplication and division correspond literally to their respective
mathematical operators. The last one, modulo operator, represented by a percentage sign (%), gives the
remainder of a division of two values. For example:

x = 11 % 3;

results in variable x containing the value 2, since dividing 11 by 3 results in 3, with a remainder of 2.

Let’s try to practice the given example:

C++ Code [arithmeticSample.cpp]

#include<iostream>
using namespace std;

int main() {
int a,b;
a=7;
b=2;

// printing the sum of a and b

cout<<"a + b = "<<(a+b)<<endl;
// printing the difference of a and b
cout << "a - b = "<<(a-b)<<endl;
// printing the product of a and b
cout<<"a * b = "<<(a*b)<<endl;
// printing the division of a by b
cout<<"a / b = "<<(a/b)<<endl;
// printing the modulo of a by b
cout<<"a % b = "<<(a%b)<<endl;

return 0;
}

[Sample Output]
a+b=9
a-b=5
a * b = 14
a/b=3
a%b=1

Here, the operators +, - and * compute addition, subtraction, and multiplication respectively as we might have
expected.

2.1 Division Operator

Note the operation (a / b) in our program. The / operator is the division operator.

As we can see from the above example, if an integer is divided by another integer, we will get the quotient.
However, if either divisor or dividend is a floating-point number, we will get the result in decimals.

PANGASINAN STATE UNIVERSITY 4

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

In C++,
7/2 is 3
7.0 / 2 is 3.5
7 / 2.0 is 3.5
7.0 / 2.0 is 3.5

2.2 Modulo Operator

The modulo operator % computes the remainder. When a = 9 is divided by b = 4, the remainder is 1.

Note: The % operator can only be used with integers.

2.3 Compound Operator

Compound assignment operators modify the current value of a variable by performing an operation on it. They
are equivalent to assigning the result of an operation to the first operand:

expression equivalent to...

y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
price *= units + 1; price = price * (units+1);

and the same for all other compound assignment operators. For example:

C++ Code [compoundAssignment.cpp]

// compound assignment operators
#include<iostream>
using namespace std;

int main()
{
int a,b=3;
a=b;
a+=2; // equivalent to a=a+2
cout<<a;
}

[Sample Output]
5

2.3 Increment and Decrement (++, --)

Some expression can be shortened even more: the increase operator (++) and the decrease operator (--) incr
ease or reduce by one the value stored in a variable. They are equivalent to +=1 and to -=1, respectively. Thu
s:

1 ++x;
2 x+=1;
3 x=x+1;

PANGASINAN STATE UNIVERSITY 5

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

are all equivalent in its functionality; the three of them increase by one the value of x.

In the early C compilers, the three previous expressions may have produced different executable code depend
ing on which one was used. Nowadays, this type of code optimization is generally performed automatically by t
he compiler, thus the three expressions should produce exactly the same executable code. C++ allows two ve
ry useful operators not generally found in other computer languages. These are the increment and decrement
operators, ++ and --. The operation ++ adds 1 to its operand, and -- subtracts 1.

A peculiarity of this operator is that it can be used both as a prefix and as a suffix. That means that it can be w
ritten either before the variable name (++x) or after it (x++). Although in simple expressions like x++ or ++x, bo
th have exactly the same meaning; in other expressions in which the result of the increment or decrement ope
ration is evaluated, they may have an important difference in their meaning: In the case that the increase oper
ator is used as a prefix (++x) of the value, the expression evaluates to the final value of x, once it is already inc
reased. On the other hand, in case that it is used as a suffix (x++), the value is also increased, but the express
ion evaluates to the value that x had before being increased. Notice the difference:

Example 1 Example 2

x = 3; x = 3;
y = ++x; y = x++;
// x contains 4, y contains 4 // x contains 4, y contains 3

In Example 1, the value assigned to y is the value of x after being increased. While in Example 2, it is the valu
e x had before being increased.

C++ Code [IncrDecr.cpp]

// Working of increment and decrement operators
#include<iostream>
using namespace std;

int main() {
int a=10, b=100, result_a, result_b;

// incrementing a by 1 and storing the result in result_a

result_a=++a;
cout<<"result_a = "<<result_a<<endl;

// decrementing b by 1 and storing the result in result_b

result_b=--b;
cout<<"result_b="<<result_b<<endl;
return 0;
}

[Sample Output]

result_a = 11
result_b = 99

In the above program, we used ++ and -- operator as prefixes. We can also use these operators as postfix.

There is a slight difference when these operators are used as a prefix versus when they are used as a postfix.

To learn more about these operators, visit https://www.programiz.com/article/increment-decrement-operator-difference-prefix-postfix

PANGASINAN STATE UNIVERSITY 6

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

LEARNING ACTIVITY 2

Determine what values the following program outputs. Do not compile this program. Just work through it line by
line in your head.

#include<iostream>
using namespace std;
int main()
{
std::cout<<2+3<<”\n”;
int x{6};
int y{x-2};
std::cout<<y<<”\n”;

int z{0};
z=x;
std::cout<<z-x<<”\n”;

return 0;
}

LEARNING CONTENTS (Relational Operator (==, <=, >=, !, >, <) )

Introduction

In the term relational operator, the word relational refers to the relationship values can have with one another.
Two expressions can be compared using relational and equality operators. For example, to know if two values
are equal or if one is greater than the other.

The result of such an operation is either true or false (i.e., a Boolean value).

The relational operators in C++ are:

Operator Description
== Equal to
!= Not equal to
< Less than
> Greater than
<= Less than or equal to
>= Greater than or equal to

Here there are some examples:

1 (7 == 5) // evaluates to false
2 (5 > 4) // evaluates to true
3 (3 != 2) // evaluates to true
4 (6 >= 6) // evaluates to true
5 (5 < 5) // evaluates to false

Of course, it's not just numeric constants that can be compared, but just any value, including, of course,
variables. Suppose that a=2, b=3 and c=6, then:

PANGASINAN STATE UNIVERSITY 7

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_
1 (a == 5) // evaluates to false, since a is not equal to 5
2 (a*b >= c) // evaluates to true, since (2*3 >= 6) is true
3 (b+4 > a*c) // evaluates to false, since (3+4 > 2*6) is false
4 ((b=2) == a) // evaluates to true

Here, > is a relational operator. It checks if a is greater than b or not.

If the relation is true, it returns 1 whereas if the relation is false, it returns 0.

Operator Meaning Example

== Is Equal To 3 == 5 gives us false

!= Not Equal To 3 != 5 gives us true

> Greater Than 3 > 5 gives us false

< Less Than 3 < 5 gives us true

>= Greater Than or Equal To 3 >= 5 give us false

<= Less Than or Equal To 3 <= 5 gives us true

Be careful! The assignment operator (operator =, with one equal sign) is not the same as the equality
comparison operator (operator ==, with two equal signs); the first one (=) assigns the value on the right-hand to
the variable on its left, while the other (==) compares whether the values on both sides of the operator are equal.
Therefore, 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), yielding true.

Note: Relational operators are used in decision making and loops.

LEARNING ACTIVITY 3

Type the code below in your C++ IDE and observe the output. Try to reverse the operator used and share what
your answer.

C++ Code [relational1.cpp]

#include<iostream>
using namespace std;
int main() {
int a, b;
a=3;
b=5;
bool result;
result=(a==b); // false
cout<<"3 == 5 is "<<result<<endl;

PANGASINAN STATE UNIVERSITY 8

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_
result=(a!=b); // true
cout<<"3 != 5 is "<<result<<endl;
result=a>b; // false
cout<<"3 > 5 is "<<result<<endl;
result=a<b; // true
cout<<"3 < 5 is "<<result<<endl;
result=a>= b; // false
cout<< "3 >= 5 is " <<result<<endl;
result = a <= b; // true
cout<<"3 <= 5 is "<<result<<endl;
return 0;
}

LEARNING CONTENTS (Logical Operator (!, &&, ||))

Introduction

The word logical refers to the ways these relationships can be connected together using the rules of formal
logic. The key to the concept or relational and logical operators is the idea of true or false.

The operator ! is the C++ operator for the Boolean operation NOT. It has only one operand, to its right, and
inverts 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 !(5 == 5) // evaluates to false because the expression at its right (5 == 5) is true

2 !(6 <= 4) // evaluates to true because (6 <= 4) would be false
3 !true // evaluates to false
4 !false // evaluates to true

The logical operators && and || are used when evaluating two expressions to obtain a single relational result.
The operator && corresponds to the Boolean logical operation AND, which yields true if both its operands
are true, and false otherwise. The following panel shows the result of operator && evaluating the
expression a&&b:

&& OPERATOR (and)

a b a && b
true true true
true false false
false true false
false false false

The operator || corresponds to the Boolean logical operation OR, which yields true if either of its operands
is true, thus being false only when both operands are false. Here are the possible results of a||b:

|| OPERATOR (or)
a b a || b
true true true
true false true
false true true
false false false

PANGASINAN STATE UNIVERSITY 9

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

For example:
1 ( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false )
2 ( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false )

When using the logical operators, C++ only evaluates what is necessary from left to right to come up with the
combined relational result, ignoring the rest. Therefore, in the last example ((5==5)||(3>6)), C++ evaluates first
whether 5==5 is true, and if so, it never checks whether 3>6 is true or not. This is known as short-circuit
evaluation, and works like this for these operators:

Operator Short-circuit
if the left-hand side expression is false, the combined result is false (the right-hand side
&&
expression is never evaluated).
if the left-hand side expression is true, the combined result is true (the right-hand side
||
expression is never evaluated).

This is mostly important when the right-hand expression has side effects, such as altering values:

if ( (i<10) && (++i<n) ) { /*...*/ } // note that the condition increments i

Here, the combined conditional expression would increase i by one, but only if the condition on the left
of && is true, because otherwise, the condition on the right-hand side (++i<n) is never evaluated.

4.1 The 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 right-most
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.

4.2 Bitwise operators (&, |, ^, ~, <<, >> )

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 bits left
>> SHR Shift bits right

4.3 Explicit Type casting operator

Type casting operators allow to convert a value of a given type to another type. 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

PANGASINAN STATE UNIVERSITY 10

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_
be converted by the new type enclosed between parentheses (()):

1 int i;
2 float f = 3.14;
3 i = (int) f;

The previous code converts the floating-point 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 to use the functional notation
preceding the expression to be converted by the type and enclosing the expression between parentheses:

i = int (f);
Both ways of casting types are valid in C++.

4.3 Explicit Type casting operator

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

x = sizeof (char);

Here, x is assigned the value 1, because char is a type with a size of one byte.

The value returned by sizeof is a compile-time constant, so it is always determined before program execution.

LEARNING ACTIVITY 4

In a ¼ sheet of paper, evaluate the program below and provide the expected output.

C++ Code [logical.cpp]

#include <iostream>
using namespace std;

int main() {
bool result;

result = (3 != 5) && (3 < 5); // true

cout << "(3 != 5) && (3 < 5) is " << result << endl;
result = (3 == 5) && (3 < 5); // false
cout << "(3 == 5) && (3 < 5) is " << result << endl;
result = (3 == 5) && (3 > 5); // false
cout << "(3 == 5) && (3 > 5) is " << result << endl;
result = (3 != 5) || (3 < 5); // true
cout << "(3 != 5) || (3 < 5) is " << result << endl;
result = (3 != 5) || (3 > 5); // true
cout << "(3 != 5) || (3 > 5) is " << result << endl;
result = (3 == 5) || (3 > 5); // false
cout << "(3 == 5) || (3 > 5) is " << result << endl;
result = !(5 == 2); // true
cout << "!(5 == 2) is " << result << endl;
result = !(5 == 5); // false

PANGASINAN STATE UNIVERSITY 11

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_
cout << "!(5 == 5) is " << result << endl;

return 0;
}

PANGASINAN STATE UNIVERSITY 12

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

LEARNING CONTENTS (Operator Precedence)

A single expression may have multiple operators. For example:

I.II.x = 5 + 7 % 2;

In C++, the above expression always assigns 6 to variable x, because the % operator has a higher
precedence than the + operator, and is always evaluated before. Parts of the expressions can be enclosed in
parenthesis to override this precedence order, or to make explicitly clear the intended effect. Notice the
difference:

III.IV.
1 x = 5 + (7 % 2); // x = 6 (same as without parenthesis)
2 x = (5 + 7) % 2; // x = 0
V.

From greatest to smallest priority, C++ operators are evaluated in the following order:

Level Precedence group Operator Description Grouping

1 Scope :: scope qualifier Left-to-right
++ -- postfix increment / decrement
() functional forms
2 Postfix (unary) Left-to-right
[] subscript
. -> member access
++ -- prefix increment / decrement
~! bitwise NOT / logical NOT
+- unary prefix
3 Prefix (unary) &* reference / dereference Right-to-left
new delete allocation / deallocation
sizeof parameter pack
(type) C-style type-casting
4 Pointer-to-member .* ->* access pointer Left-to-right
5 Arithmetic: scaling */% multiply, divide, modulo Left-to-right
6 Arithmetic: addition +- addition, subtraction Left-to-right
7 Bitwise shift << >> shift left, shift right Left-to-right
8 Relational < > <= >= comparison operators Left-to-right
9 Equality == != equality / inequality Left-to-right
10 And & bitwise AND Left-to-right
11 Exclusive or ^ bitwise XOR Left-to-right
12 Inclusive or | bitwise OR Left-to-right
13 Conjunction && logical AND Left-to-right
14 Disjunction || logical OR Left-to-right
= *= /= %=
+= -=
Assignment-level assignment / compound assignment
15 >>= <<= &= Right-to-left
expressions ^= |=
?: conditional operator
16 Sequencing , comma separator Left-to-right

When an expression has two operators with the same precedence level, grouping determines which one is
evaluated first: either left-to-right or right-to-left.

Enclosing all sub-statements in parentheses (even those unnecessary because of their precedence) improves code readability.

PANGASINAN STATE UNIVERSITY 13

 FM-AA-CIA-15 Rev. 0 10-July-2020

Study Guide in CC102 Fundamentals of Programming Module No. 4

_

SUMMARY

In this section, we have covered the expressions and operators that could be used in creating C++ programs.
Try to practice the given examples and reverse the operators used. Observe the new output after incorporating
the reverse. Try to remember all the operators as we will be using them in the next modules. Arithmetic operators
are useful in creating basic problem-solving programs. Relational operators often used in decision making
programs and as well as the logical operators.

REFERENCES

Zak, D. (2016). An Introduction to Programming with C++ (8E), pages 75-104

Online Reading Materials:

 http://cplusplus.com/doc/tutorial/operators/
 https://www.learncpp.com/cpp-tutorial/introduction-to-literals-and-operators/
 https://www.learncpp.com/cpp-tutorial/introduction-to-expressions/
 https://www.programiz.com/cpp-programming/operatorshttps://www.programiz.com/cpp-
programming/comments

PANGASINAN STATE UNIVERSITY 14