2.

0 BASIC PROGRAM ELEMENTS

2.3 Apply operators and

expression
Operator

 Once we know of the existence of variables

and constants, we can begin to operate with
them.
 For that purpose, C++ integrates operators.
 Operator is a symbol that represents a
specific action. For example, a plus sign (+)
is an operator that represents addition.
Operator

 Operators includes Arithmetic's Operators,

Assignment Operators, Increment and
Decrement Operators(Unary), Relational
Operators, Logical Operators and
Conditional Operators
Types of Operators

Arithmetic's Operators
 The five arithmetical operations supported
by the C++ language are:

+ addition
- subtraction
* multiplication
/ division
% modulus
Types of Operators

 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
modulus; whose operator is the percentage sign (%).
 Modulus is the operation that gives the remainder of
a division of two values. For example, if we write:
a = 11 % 3;

 the variable a will contain the value 2, since 2 is the

remainder from dividing 11 between 3.
Types of Operators

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).
Types of Operators

 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;
Types of Operators

Compound assignment (+=, -=, *=, /=, %=)

 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 equivalent to
value += increase; value = value + increase;
a -= 5; a = a - 5;
a /= b; a = a / b;
price *= units + 1; price = price * (units + 1);
Types of Operators

// compound assignment operators Output::

#include <iostream.h> 5
int main ()
{
int a, b=3;
a = b;
a+=2; // equivalent to a=a+2
cout << a;
return 0;
}
Types of Operators

Increment and decrement operator

 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. c++;
2. c+=1;
3. c=c+1;

 are all equivalent in its functionality: the three of them increase by

one the value of c.
Types of Operators

 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++).
Types of Operators

 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.
Types of Operators

 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.
 In case that it is used as a suffix (a++) the
value stored in a is increased after being
evaluated.
Types of Operators

Example 1 Example 2

B=3; B=3;
A=++B; A=B++;
// A contains 4 // A contains 3
Types of Operators

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

 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.
Types of Operators

 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:
== Equal to

!= Not equal to

> Greater than

< Less than

>= Greater than or equal to

<= Less than or equal to

Types of Operators

 Here there 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.
Types of Operators

 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,

(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.
Types of Operators

 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.
Types of Operators

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.
Types of Operators

 Basically, it returns the opposite Boolean value of

evaluating its operand. For example:

!(5 == 5) // evaluates to false because the

expression at its right (5 == 5)
is true.
!(6 <= 4) // evaluates to true because (6 <= 4)
would be false.
!true // evaluates to false
!false // evaluates to true.
Types of Operators

 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.
Types of Operators

 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
Types of Operators

 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.
Types of Operators

 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
Types of Operators
 For example:

( (5 == 5) && (3 > 6) ) // evaluates to false (true && false ).

( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).

Types of Operators

Conditional operators
 ternary operator (working on three values)
 Format:
conditional Expression ? expression1 :expression2;
if the conditional Expression is true, expression 1
executes, otherwise if the conditional Expression is
false, expression 2 executes
Types of Operators

 Example
(a>b) ? (c=25) : (c=45);
 Program:
#include<iostream.h>
void main()
{
int a,b,c;
a=4;
b=5;
(a > b) ? (c=25) : (c=35);
cout<<a+c;
}
Typecasting

 Typecasting is making a variable of one type,

such as an int, act like another type, a char,
for one single operation.
 To typecast something, simply put the type of
variable you want the actual variable to act
as inside parentheses in front of the actual
variable.
 Example:
(char)a will make 'a' function as a char.
Typecasting

 Example:
cout<< char ( 65 ) ;
The (char) is a typecast, telling the computer to
interpret the 65 as a character, not as a
number. It is going to give the character output
of the equivalent of the number 65 (It should be
the letter A for ASCII).
Operators’ Precedence

 When writing complex expressions with

several operands, we may have some
doubts about which operand is evaluated first
and which later.
Operators’ Precedence

 For example, in this expression:

a=5+7%2

we may doubt if it really means:

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

 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++.
Operators’ Precedence

 From greatest to lowest priority, the priority order is as

follows:
Operator
! ++ --
* / %
From
greatest
+ -
to
< <= > >= lowest
== != priority
&&
||
=
Write expression using operator

 An expression in a programming language

is a combination of values, variables,
operators, and functions that are interpreted
(evaluated) according to the particular rule of
precedence and of association for a
particular programming language, which
computes and then produces (returns, in a
stateful environment) another value.
Write expression using operator

 Examples:
a. 25 + 18 * 2;
b. 3.00*40+1.5*6+10;
c. 2*payrate+bonus;
d. (4==4)
e. (grossPay > taxableAmount)
Apply expression and operators in
program

#include <iostream.h>
int main()
{
float payrate;
float hours;
float totalPay;

cout<<”Enter pay rate: RM “;

cin>>payrate;

cout<<”Enter hours worked: “;

cin>>hours;

totalPay=payrate*hours;
cout<<”\nTotal pay is RM “<<totalPay<<endl;
}