Grade 9

ICT
Week 3
Programming Operators:
Assignment, Arithmetic, Relational, Logical

What’s Inside?
Defining Programming Operators
Describe and Identify Programming Operators
Apply Programming Operators in C++ Program
Precedence of Operators

Learning Competency/ies addressed: LC1, LC2, LC4, LC6

Upon successful completion of this module the students will be able to:

• Describe and Identify Programming Operators

• Apply Programming Operators in C++ Program
• Enumerate the Precedence of Operators
• Interpret the function of operators on sample programs

IMPORTANT REMINDERS:
• Use word document (MS Word) to answer the activities
• Document your coding exercises by copying the syntax to word document and screenshot of program
• Save your word document using this format: Act1_Surname_FirstName and CE1_Surname_FirstName
• Submit/Upload all activities and coding exercises to designated Google Classroom Assignment

Prepared by: Toshio Akira Capintog

Programming Operators
An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations.

Operators are the foundation of any programming language. Thus the functionality of C/C++ programming
language is incomplete without the use of operators. We can define operators as symbols that help us to
perform specific mathematical and logical computations on operands.
C++ divides the operators into the following groups:
• Assignment operators
• Arithmetic operators
• Comparison operators
• Logical operators

Assignment Operator
The assignment operator assigns a value to a variable.
X = 5;
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 - I have included the evolution of the content stored in
the variables as comments:

// 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:4 b:7
a = b; // a:4, b:4
b = 7; // a:4, b:7

cout << "a:";

cout << a;
cout << " b:";
cout << b;
}

This program prints on screen the final values of a and b (4 and 7, respectively). Notice how a was not af-
fected 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:
x = 5;
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.

Arithmetic Operators
Arithmetic operators are used to perform common mathematical operations.

Operator Name Description Example

+ Addition Adds together two values x+y

- Subtraction Subtracts one value from another x-y

* Multiplication Multiplies two values x*y

/ Division Divides one value by another x/y

% Modulus Returns the division remainder x%y

++ Increment Increases the value of a variable by 1 ++x

-- Decrement Decreases the value of a variable by 1 --x

//Example Arithmetic Operators // Sample Increment and Decrement Operator

#include <iostream>
using namespace std; #include <iostream>
int main() { using namespace std;
int a, b;
a = 7; int main() {
b = 2; int a = 10, b = 100, result_a, result_b;
// printing the sum of a and b // incrementing a by 1 and storing the result in
cout << "a + b = " << (a + b) << endl;
result_a
// printing the difference of a and b result_a = ++a;
cout << "a - b = " << (a - b) << endl; cout << "result_a = " << result_a << endl;

// printing the product of a and b

cout << "a * b = " << (a * b) << endl; // decrementing b by 1 and storing the result
in result_b
// printing the division of a by b
result_b = --b;
cout << "a / b = " << (a / b) << endl;
cout << "result_b = " << result_b << endl;
// printing the modulo of a by b
cout << "a % b = " << (a % b) << endl; return 0;
}
return 0;
}
Relational / Comparison Operators
Comparison operators are used to compare two values.

Note: The return value of a comparison is either true (1) or false (0).

Operator Name (Relational Expressions) Example

== Equal to x == y

!= Not equal x != y

> Greater than x>y

< Less than x<y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

Here are some examples:

(7 == 5) // evaluates to false
(5 > 4) // evaluates to true
(3 != 2) // evaluates to true
(6 >= 6) // evaluates to true
(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:

(a == 5) // evaluates to false, since a is not equal to 5

(a*b >= 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

#include <iostream>
using namespace std;

int main() {
Be careful! The assignment operator (operator =, int a, b;
a = 3;
with one equal sign) is not the same as the equali-
b = 5;
ty comparison operator (operator ==, with two bool result;
equal signs); the first one (=) assigns the value on result = (a == b); // false
the right-hand to the variable on its left, while the cout << "3 == 5 is " << result << endl;
result = (a != b); // true
other (==) compares whether the values on both
cout << "3 != 5 is " << result << endl;
sides of the operator are equal. Therefore, in the result = a > b; // false
last expression ((b=2) == a), we first assigned the cout << "3 > 5 is " << result << endl;
value 2 to b and then we compared it to a (that result = a < b; // true
cout << "3 < 5 is " << result << endl;
also stores the value 2), yielding true.
result = a >= b; // false
cout << "3 >= 5 is " << result << endl;
result = a <= b; // true
cout << "3 <= 5 is " << result << endl;
return 0;
}
Logical Operators
Logical operators are used to determine the logic between variables or values:

Operator Name Description Example

&& Logical and Returns true if both statements are true x < 5 && x < 10

|| Logical or Returns true if one of the statements is true x < 5 || x < 4

! Logical not Reverse the result, returns false if the result is true !(x < 5 && x < 10)

In C++, logical operators are commonly used in decision making. To further understand the logical opera-
tors, let's see the following examples,

//Example Logical Operator

#include <iostream>
using namespace std;

int main() {
Suppose, bool result;
a=5
b=8 result = (3 != 5) && (3 < 5); // true
cout << "(3 != 5) && (3 < 5) is " << result << endl;
Then, result = (3 == 5) && (3 < 5); // false
cout << "(3 == 5) && (3 < 5) is " << result << endl;
(a > 3) && (b > 5) evaluates to true result = (3 == 5) && (3 > 5); // false
(a > 3) && (b < 5) evaluates to false cout << "(3 == 5) && (3 > 5) is " << result << endl;
result = (3 != 5) || (3 < 5); // true
cout << "(3 != 5) || (3 < 5) is " << result << endl;
(a > 3) || (b > 5) evaluates to true
(a > 3) || (b < 5) evaluates to true result = (3 != 5) || (3 > 5); // true
(a < 3) || (b < 5) evaluates to false cout << "(3 != 5) || (3 > 5) is " << result << endl;
result = (3 == 5) || (3 > 5); // false
!(a == 3) evaluates to true cout << "(3 == 5) || (3 > 5) is " << result << endl;
!(a > 3) evaluates to false result = !(5 == 2); // true
cout << "!(5 == 2) is " << result << endl;
result = !(5 == 5); // false
cout << "!(5 == 5) is " << result << endl;
return 0;
}

Explanation of logical operator program

• (3 != 5) && (3 < 5) evaluates to 1 because both operands (3 != 5) and (3 < 5) are 1 (true).
• (3 == 5) && (3 < 5) evaluates to 0 because the operand (3 == 5) is 0 (false).
• (3 == 5) && (3 > 5) evaluates to 0 because both operands (3 == 5) and (3 > 5) are 0 (false).
• (3 != 5) || (3 < 5) evaluates to 1 because both operands (3 != 5) and (3 < 5) are 1 (true).
• (3 != 5) || (3 > 5) evaluates to 1 because the operand (3 != 5) is 1 (true).
• (3 == 5) || (3 > 5) evaluates to 0 because both operands (3 == 5) and (3 > 5) are 0 (false).
• !(5 == 2) evaluates to 1 because the operand (5 == 2) is 0 (false).
!(5 == 5) evaluates to 0 because the operand (5 == 5) is 1 (true).
Precedence of Operators
A single expression may have multiple operators. For example:

x = 5 + 7 % 2;

In C++, the above expression always assigns 6 to variable x, because the % operator has a higher prece-
dence 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 dif-
ference:
x = 5 + (7 % 2); // x = 6 (same as without parenthesis)

x = (5 + 7) % 2; // x = 0

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

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) im-
proves code readability.

SOURCES:
http://www.cplusplus.com/doc/tutorial/operators/
https://www.tutorialspoint.com/cplusplus/cpp_operators.htm
https://www.geeksforgeeks.org/operators-c-c/
Activity 1
Complete the following table, for int variables i and j, and float variables x and y.

i j x y x / y i / j i % j
4 1 4.0 1.0
4 2 4.0 2.0
4 3 4.0 3.0
4 4 4.0 4.0
4 5 4.0 5.0

Coding Exercises:
Document your coding exercises by copying the syntax to word document and screenshot of program

Coding Exercise 1:
Assuming that i is 11 and j is 22, complete the following table. In the middle column, use the relational
expressions to predict the results of each comparison. Then using the sample code below display the
result of each comparison, and record those results in the rightmost column.

Comparison Prediction Observation Comparison Prediction Observation

i == j i != j
i < j i >= j
i > j i <= j

//Sample Code for CE1

#include <iostream>
using namespace std;

int main()
{
int i = 11,
j = 22;
float x = 11.11,
y = 22.22;

cout << '\n' << i << '+' << j << " = " << i + j
<< endl << x << '+' << y << " = " << x + y
<< endl;
}

(Hint: You will need to add parenthesis to the relational expression within
the output statement in order for it to work correctly.)