CONTROL STRUCTURES:

SEQUENTIAL, SELECTIVE,
AND REPETITIVE
THREE CATEGORIES
OF CONTROL
STRUCTURES:

• SEQUENTIAL
• SELECTIVE
• REPETITIVE
 SEQUENTIA
L

CONTROL FLOWS FROM STATEMENT_1 TO

STATEMENT_2 AND SO ON TO STATEMENT_N.
statement_1

statement_2

.
.

statement_n
 SELECTIV
E
CONTROL FOLLOWS ONE OF SEVERAL
ALTERNATIVES OF LOGIC FLOW BASED ON A
CONDITION.
 ENTER

true logical false

expression

process process

EXIT
 REPETITIV
E
CONTROL ALLOWS FOR THE REPETITION OF A
CERTAIN TASK BASED ON A CONDITION.
 ENTER

true
logical
process
expression

false

EXIT
 EXAMPLE
:
PROBLEM:

DESIGN, DEVELOP AND IMPLEMENT A PAYROLL

SYSTEM THAT COMPUTES AN EMPLOYEE'S GROSS PAY.
THE SYSTEM SHOULD ALSO COMPUTE NET PAY USING
THE FOLLOWING CRITERION TO DETERMINE THE
AMOUNT TO BE DEDUCTED FROM THE EMPLOYEE'S
GROSS SALARY FOR SOCIAL SECURITY TAX:
IF AN EMPLOYEE EARNS MORE THAN $100.00 IN A
WEEK, DEDUCT A TAX OF $25.00; OTHERWISE, DEDUCT
NO TAX.
PROCESSING SHOULD BE REPEATED, BASED ON THE
USER’S REQUEST.
 ANALYSIS AND SPECIFICATIONS:

1. DISCUSSION

TO COMPUTE GROSS PAY (THE PROBLEM’S OUTPUT), WE

MUST KNOW THE HOURS WORKED AND THE HOURLY RATE
(THE PROBLEM’S INPUT). AFTER READING THESE DATA, WE
CAN COMPUTE GROSS PAY BY FINDING THEIR PRODUCT.
NEXT WE CAN COMPUTE THE EMPLOYEE'S NET PAY (THE
PROBLEM’S OTHER OUTPUT) BY SUBTRACTING ANY TAX
DEDUCTION FROM THE GROSS PAY.

0
 2. DATA REQUIREMENTS

a) INPUT
hours (float) // HOURS WORKED
rate (float) // HOURLY RATE
final (int) // NUMBER OF REPETITIONS

b) OUTPUT
gross (float) // GROSS PAY
net (float) // NET PAY

c) INTERMEDIATE DATA
counter (int) // LOOP CONTROL VARIABLE

d) NAMED CONSTANTS
tax_bracket = 100.00 // MAXIMUM SALARY WITHOUT
// A TAX DEDUCTION
tax = 25.00 // AMOUNT OF TAX WITHHELD
1
 3. RELEVANT FORMULAE
gross pay = hourly rate x hours worked
net pay = gross pay - deductions

2
 DESIGN:
1. STRUCTURE CHART

PAYROLL
LEVEL 0
SYSTEM

LEVEL 1

DISPLAY GET COMPUTE COMPUTE DISPLAY

INSTRUCTIONS DATA GROSS PAY NET PAY RESULTS

3
 2. MODULE SPECIFICATION
(WE INCLUDE ONLY ONE MODULE DESCRIPTION AS AN EXAMPLE):

AS AN ALTERNATIVE METHOD TO FURTHER AID IN

UNDERSTANDING HOW DATA ARE TRANSMITTED, WE
WILL INCLUDE MODULE SPECIFICATIONS FOR "GROSS
PAY" MODULE.

MODULE SPECIFICATIONS FOR THE GROSS PAY ARE:

GROSS PAY
DATA RECEIVED: hours, rate
INFORMATION RETURNED: gross
LOGIC: THE HOURS ARE MULTIPLIED BY THE PAY
RATE TO PRODUCE THE GROSS PAY.

4
 3. ALGORITHM:

1. DISPLAY USER INSTRUCTIONS

2. WHILE COUNTER <= FINAL
2.1. GET DATA
2.2. COMPUTE GROSS PAY
2.3. COMPUTE NET PAY
2.3.1. IF GROSS PAY > TAXBRACKET THEN
DEDUCT TAX
ELSE
DEDUCT NO TAX
2.4. DISPLAY RESULTS

5
 NEW
CONCEPTS
LOGICAL EXPRESSIONS, SELECTION, AND REPETITION

6
 LOGICAL
EXPRESSIONS
CONDITIONS ARE WRITTEN IN THE FORM OF
LOGICAL EXPRESSIONS.
THERE ARE TWO POSSIBLE VALUES FOR SUCH AN
EXPRESSION: 1 (REPRESENTS TRUE), OR 0
(REPRESENTS FALSE).

7
 LOGICAL EXPRESSIONS MAY BE FORMED BY USING
COMBINATIONS OF TWO KINDS OF OPERATORS:
RELATIONAL AND LOGICAL.

8
 RELATIONAL
OPERATORS
OPERATOR MEANING

== EQUAL TO
!= NOT EQUAL TO
< LESS THAN
<= LESS THAN OR EQUAL TO
> GREATER THAN
>= GREATER THAN OR EQUAL TO

9
 LOGICAL
OPERATORS
OPERATOR MEANING

&& AND
|| OR
! NOT

0
 LOGICAL EXPRESSIONS ARE MADE UP OF

VARIABLES, CONSTANTS AND OPERATORS.

operand operator operand

1
 EXAMPLE
S:
(counter <= FINAL)

(class_average < 70.0)

total_grade >= class_average

hours_worked <= 35.0

divisor == 0

(angle1 + angle2 + angle3) != 180

2
 (midterm_grade >= 90) && (final_grade >= 90)

(side_1 == side_2) || (side_2 == side_3)

! (class_average >= 70.0)

3
 && TRUTH TABLE
operand operator operand
outcome
1(true) && 1(true) 1(true)
1(true) && 0(false) 0(false)
0(false) && 1(true) 0(false)
0(false) && 0(false) 0(false)

4
 || TRUTH TABLE
operand operator operand outcome
1(true) || 1(true) 1(true)
1(true) || 0(false) 1(true)
0(false) || 1(true) 1(true)
0(false) || 0(false) 0(false)

5
 ! TRUTH TABLE
operator operand outcome
! 1(true) 0(false)
! 0(false) 1(true)

6
 PRECEDENCE OF
OPERATORS (REVISITED)
! HIGHEST
* / % PRECEDENCE
+ -
< <= >= >
== !=
&&
||
=
LOWEST PRECEDENCE
EXPRESSION EVALUATION IS LEFT TO RIGHT.

7
 THE if
STATEMENT
if STATEMENT INSTRUCTIONS ARE EXECUTED IN A

LOGICAL ORDER THAT DIFFERS FROM THEIR

PHYSICAL ORDER.

A CONDITION IS EVALUATED, AND AN ACTION IS

TAKEN DEPENDING ON THE TRUTH VALUE OF THE

CONDITION (THE ANSWER CAN BE EITHER 1

8
(TRUE) OR 0 (FALSE).
 ONE
ALTERNATIVE
if (logical_expression)
statement_1;

if (total_grade >= class_average)

cout << "passing!" << endl;

9
 LOGIC FLOW OF if
WITH
ONE ALTERNATIVEENTER

true logical
expressio
n

false
statement_1

0 EXIT
 TWO
ALTERNATIVES
if (logical expression)
statement_1a;
else
statement_1b;

if (total_grade >= class_average)

cout << "passing!" << endl;
else
cout << "in trouble!!!" << endl;

1
 LOGIC FLOW OF if
WITH
TWO ALTERNATIVES
ENTER

true logical false

expressio
n

statement_1a statement_1b

2 EXIT
 COMPOUND
STATEMENTS
AND THE if
THE “TASK” TO BE CARRIED OUT WITHIN THE if
STATEMENT MAY BE SIMPLE OR COMPOUND.

ASSIGNMENT STATEMENTS, FUNCTION CALLS,

INPUT/OUTPUT STATEMENTS, OTHER if STATEMENTS,
ETC. MAY ALSO BE INCLUDED IN ANY OF THE if
ALTERNATIVES.

3
 EXAMPL
if
E:
(total_grade >= class_average)
{
passing_grade = passing_grade + 1;
cout << "passing!" << endl;
}
else
{
weak_grade = weak_grade + 1;
cout << "in trouble!!!" << endl;
}

4
 MULTIPLE
ALTERNATIVES
if (logical expression_1)
statement_1;
else if (logical expression_2)
statement_2;
.
.
else if (logical expression_n)
statement_n;
else
5 statement_n+1;
 if (total_grade >= 90)
letter_grade = ‘A’;
else if (total_grade >= 80)
letter_grade = ‘B’;
else if (total_grade >= 70)
letter_grade = ‘C’;
else if (total_grade >= 60)
letter_grade = ‘D’;
else
letter_grade = ‘F’;

6
 LOGIC FLOW OF if WITH
MULTIPLE ALTERNATIVES
ENTER

true logical false

expression_1

true logical false

expression_
2

statement_1 statement_2a statement_2b

7 EXIT
 LOGIC FLOW OF if WITH
MULTIPLE ALTERNATIVES
ENTER

true logical false

expression_1

true logical false

expression_
2

statement_1a statement_1b statement_2

8
EXIT
 SEQUENTIAL if
VERSUS
NESTED if
if STATEMENTS
(number > 0)
positive_num = positive_num + 1;
if (number < 0)
negative_num = negative_num + 1;
if (number == 0)
zero_num = zero_num + 1;

9
 if (total_grade >= 90)
letter_grade = ‘A’;
else if (total_grade >= 80)
letter_grade = ‘B’;
else if (total_grade >= 70)
letter_grade = ‘C’;
else if (total_grade >= 60)
letter_grade = ‘D’;
else
letter_grade = ‘F’;

0
 . COMPOUND if
. STATEMENTS
if (side_1 == side_2) && (side_2 == side_3)
cout << "Triangle is Equilateral" << endl;
else if (side_1 == side_2) || (side_2 == side_3) ||
(side_1 == side_3)
cout << "Triangle is Isosceles" << endl;
else
cout << "Triangle is Scalene" << endl;
.
1
.
 THE while STATEMENT
THE REPETITION OF TASKS IN A PROGRAM IS

CALLED LOOPING.

WITH THE while LOOP, IF A CONDITION EXISTS,

TASK IS EXECUTED. AFTER THE EXECUTION OF

THE TASK, THE CONDITION IS TESTED AGAIN.

THIS CONTINUES AS LONG AS THE CONDITION

REMAINS TRUE.
2
 while (logical_expression)
statement;

total = 0;
counter = 1;

// the following is a loop

while (counter <= 10)

{
cout << "Enter grade: ";
cin >> grade;
total = total + grade;
counter = counter + 1;
}
3
 WHAT IF THE LOGICAL EXPRESSION IS FALSE

TO BEGIN WITH?

TASK NEVER EXECUTES, AND FLOW OF

CONTROL CONTINUES WITH THE FIRST

STATEMENT FOLLOWING THE LOOP.

4
 IMPLEMENTATION:
// FILE: Payroll.cpp
// Computes and prints gross pay and net pay given an
// hourly rate and number of hours worked. Deducts a tax
// of $25 if gross salary exceeds $100; otherwise, deducts
// no tax.

#include <iostream> // needed for cin and cout

using std::cin;
using std::cout;
using std::endl;
void main()
{
// FUNCTIONS USED:
// Display user instructions
void Instruct_user
(const float, // IN: max salary for no deductions
const float); // IN: tax amount
// Find the gross salary
float Compute_gross
(float, // IN: number of hours worked
5
float); // IN: hourly payrate
 // Find the net salary
float Compute_net
(float, // IN: gross salary
const float, // IN: max salary for no deductions
const float); // IN: tax amount

// LOCAL DATA:
const float tax_bracket = 100.00; // max salary for
// no deductions
const float tax = 25.00; // tax amount

float hours; // input: hours worked

float rate; // input: hourly payrate
int final; // input: number of repetitions
float gross; // output: gross pay
float net; // output: net pay
int counter; // intermediate: loop control variable

6
 // Display user instructions
Instruct_user (tax_bracket, tax);

// Enter number of repetitions

cout << "Number of repetitions : ”;
cin >> final;

counter = 1;
while (counter <= final)
{
// Enter hours and rate
cout << "Hours worked: ";
cin >> hours;
cout << "Hourly rate: ";
cin >> rate;

// Compute gross salary

gross = Compute_gross (hours, rate);

7
 // Compute net salary
net = Compute_net (gross, tax_bracket, tax);

// Print gross and net

cout << "Gross salary is $" << gross << endl;
cout << "Net salary is $" << net << endl;

// Increment the counter

counter ++;
} // end of the while loop
return;
} // end of main ()

8
 // Display user instructions
void Instruct_user
(const float tax_bracket, // IN: maximum salary
// for no deduction
const float tax) // IN: tax amount
{
cout << "This program computes gross and net salary."
<< endl;
cout << "A tax amount of $" << tax << " is deducted for"
<< endl;
cout << "an employee who earns more than $" << tax_bracket
<< endl << endl;
cout << "First, enter how many times do you want to "
<< "repeat the calculations." << endl << endl;
cout << "Then, enter hours worked and hourly rate" << endl;
cout << "on separate lines after the prompts." << endl;
cout << "Press <RETURN> after typing each number."
<< endl << endl;
return;
} // end of Instruct_user

9
 // Find the gross salary
float Compute_gross
(float hours, // IN: number of hours worked
float rate) // IN: hourly payrate
{
// Compute gross pay
return hours * rate;
} // end of Compute_gross

// Find the net salary

float Compute_net
(float gross, // IN: gross salary
const float tax_bracket, // IN: max salary
// for no deductions
const float tax) // IN: tax amount
{
// Compute net salary
if (gross > tax_bracket)
return gross - tax; // deduct a tax amount
else
return gross; // deduct no tax
} // end of Compute_net
0