### original_pld7e_ch03

```Programming Logic and Design
Seventh Edition
Chapter 3
Understanding Structure
Objectives
In this chapter, you will learn about:
• The three basic control structures:
– Sequence
– Selection
– Repetition ( aka looping and iteration )
•
•
•
•
The need for structure
The features of unstructured spaghetti code
Recognizing structure
Structuring and modularizing unstructured logic
• Using a priming input to structure a program
2
Three Basic Control Structures
Sequence, Selection, Repetition/Iteration/Looping
3
RAPTOR Symbols
Sequence
Control
Structures
Selection and
Repetition
Control
Structures
4
Understanding Unstructured Spaghetti Code
•
Spaghetti code
– Logically snarled program statements
– Can be the result of poor program design
– Programs often work but are difficult to read and maintain
– Convoluted logic usually requires more code
•
Unstructured programs
– Do not follow the rules of structured logic
•
Structured programs
– Do follow rules of structured logic
•
5
RAPTOR does not permit you to draw an unstructured flowchart
Figure 3-1 Spaghetti code logic for washing a dog
6
Understanding the Three Basic Structures
• Structure
– A Control Structure is a basic unit of programming logic
– Sequence
• Perform a single action ( input, output, assign, … )
– Selection ( aka decision )
• Ask a question, take one of two actions
• Dual-alternative or single-alternative if's
– Loop ( aka repetition/iteration )
• Repeat actions based on answer to a question
7
Understanding the Three Basic
Structures (continued)
There is a distinction between sequence and a
sequence structure. The book doesn't make this
distinction which is unfortunate.
On the right, you see 3 sequence structures being
executed in sequence ( or sequentially ). To the right
of that, you see 3 selection structures in a sequence.
You enter a control structure through an entry point
and exit from an exit point.
Control structures can be stacked and nested.
Stacked control structures are always executed in
sequence.
8
Figure 3-2
Sequence
Understanding the Three Basic
Structures (continued)
question
usually referred to as the
condition
no
statement
Figure 3-3
9
yes
statement
Selection structure
Understanding the Three Basic
Structures (continued)
• Dual-alternative if
– Contains two alternatives
– If-then-else structure
if someCondition [is true] then
Pseudocode
keywords:
if, then, do,
else, endif
do statement_1
statements
else
do statement_2
endif
10
Understanding the Three Basic Structures (continued)
• Single-alternative if
– Else clause is not required
– If the condition does not evaluate to true, the statement(s) are
not executed and control passes to the next structure
• null case
– Situation where nothing is done
if employee belongs to dentalPlan then
do deduct \$40 from employeeGrossPay
endif
11
Understanding the Three Basic Structures
(continued)
Figure 3-4 Single-alternative selection structure
12
Understanding the Three Basic
Structures (continued)
• Loop structure
– Repeats a set of actions based on the answer to a question
• Loop body
– Also called repetition or iteration
– Question is asked first in the most common form of a loop
– while … do (pre-test)
or
do … while (post-test)
– RAPTOR lets you put the test anywhere you like!
13
Understanding the Three Basic Structures (continued)
Connector
When using
drawing software
such as Visio
Figure 3-5
14
Loop structure (pre-test form – while … do)
Understanding the Three Basic Structures (continued)
• Loop structure [ pre-test loop ]
while testCondition continues to be true
do someStatement
endwhile
while count less than 11
do printCount()
do add 1 to count
//module call
endwhile
15
Understanding the Three Basic Structures (continued)
• All logic problems can be solved using only these three structures
• Structures can be combined in an infinite number of ways
• Stacking
– Attaching structures end-to-end
• Nesting
– discussed a few slides later…
• End-structure statements
– Indicate the end of a structure
– endif ends an if-then-else structure
– endwhile ends a loop structure
16
Understanding the Three Basic Structures (continued)
Connector
Figure 3-6 Structured flowchart and pseudocode with three stacked structures
17
Understanding the Three Basic Structures (continued)
• Any individual task or step in a structure can be
replaced by a structure
• Nesting
– Placing one structure within another
– Indent the nested structure’s statements
• Block [ aka compound statement ]
– Group of statements that execute as a single unit
– Java uses { } to enlcose these
18
Understanding the Three Basic Structures (continued)
block or compound
statement
Figure 3-7 Flowchart and pseudocode showing nested structures
[ sequence nested within a selection ]
19
Understanding the Three Basic Structures (continued)
entry point
and
exit point
for a structure
structures
have ONE of
each
Figure 3-8 Flowchart and pseudocode showing nested structures
a loop nested within a sequence, nested within a selection
20
Understanding the Three Basic Structures (continued)
Figure 3-9 Flowchart and pseudocode for
selection structure with nested sequence and loop structures
21
Understanding the Three Basic Structures (continued)
• Structured programs have the following
characteristics:
– Include only combinations of the three basic structures
– Each of the structures has a single entry point and a single
exit point
– Structures can be stacked or connected to one another
only at their entry or exit points
– Selection and Loop structures can have nested structures
22
Using a Priming Input to Structure
a Program
• Priming read (or priming input)
– Reads the first input data record outside of the loop that reads the rest of
the records
– Helps keep the program structured
– Note: it is not always necessary to do this…
• Analyze a flowchart for structure one step at a time
• Watch for unstructured loops that do not follow this order:
– First ask a question
– Take action based on the answer
– Return to ask the question again
23
Using a Priming Input to Structure a Program (continued)
Figure 3-15 Structured, but nonfunctional, flowchart of number-doubling problem
24
Using a Priming Input to Structure a Program (continued)
RAPTOR would
let you do this
because there
are languages
that support a
“mid-test”
condition.
Our book only
considers pre-test
and post-test
loops as
structured.
Figure 3-16
Functional but unstructured flowchart
Programming Logic & Design, Sixth Edition
25
Using a Priming Input to Structure a Program (continued)
• Priming read sets up the process so the loop can be
structured
• To analyze a flowchart’s structure, try writing
pseudocode for it
start
get inputNumber
//priming read
while not eof
calculatedAnswer = inputNumber * 2
print calculatedAnswer
get inputNumber
endwhile
stop
26
Figure 3-17
Functional, structured flowchart for the number-doubling problem
27
Figure 3-18 Structured but incorrect solution to the number-doubling problem
Programming Logic & Design, Sixth Edition
28
Understanding the Reasons for
Structure
• Clarity
• Professionalism
• Efficiency
• Ease of maintenance
• Supports modularity
29
Recognizing Structure
• Any set of instructions can be expressed in
structured format
• Any task to which you can apply rules can be
expressed logically using sequence, selection, loop
• It can be difficult to detect whether a flowchart is
structured
30
Flowchart Status
• Flowcharts fall in to one of the 3 following categories:
–
–
–
structured
structured
functional
AND
but NOT
but NOT
functional
functional
structured
• These categories will be presented over the next several slides.
31
Recognizing Structure (continued)
What are the
structures?
Are they:
stacked?
nested?
Are they:
structured?
functional?
Figure 3-20 Example 2
Programming Logic & Design, Sixth Edition
32
Recognizing Structure (continued)
This is a no
no!
Functional
but
not
Structured
Figure 3-21 Example 3
33
Recognizing Structure (continued)
• Single process like G is part of an acceptable
structure
– At least the beginning of a sequence structure
Figure 3-22 Untangling Example 3, first step
34
Recognizing Structure (continued)
• H begins a selection structure
– Sequences never have decisions in them
– Logic never returns to G
Figure 3-23 Untangling Example 3, second step
35
Recognizing Structure (continued)
• Pull up on the flowline from the left side of H
Figure 3-24 Untangling Example 3, third step
36
Recognizing Structure (continued)
• Next, pull up the flowline on the right side of H
Figure 3-25 Untangling Example 3, fourth step
37
Recognizing Structure (continued)
• Pull up the flowline on the left side of I and untangle it from
the B selection by repeating J
Figure 3-26 Untangling Example 3, fifth step
38
Recognizing Structure (continued)
• Now pull up the flowline on the right side of I
Figure 3-27 Untangling Example 3, sixth step
39
Recognizing Structure (continued)
• Bring together the loose ends of I and of H
Figure 3-28 Finished flowchart and pseudocode for untangling Example 3
40
Structuring and Modularizing
Unstructured Logic
• Dog-washing process
– Unstructured
– Can be reconfigured to be structured
• First step simple sequence
Figure 3-29 Washing the dog, part 1
41
Structuring and Modularizing
Unstructured Logic (continued)
• After the dog runs away
– Catch the dog and determine whether he runs away again
– A loop begins
Figure 3-30 Washing the dog, part 2
42
Figure 3-31 Washing the dog, part 3
Programming Logic & Design, Sixth Edition
43
Figure 3-33 Structured dog-washing flowchart and pseudocode
Programming Logic & Design, Sixth Edition
44
Figure 3-34 Modularized version of the dog-washing program
Programming Logic & Design, Sixth Edition
45
Summary
• Spaghetti code
– Snarled program logic
• Three basic structures
– Sequence, selection, and loop
– Combined by stacking and nesting
• Priming read
– Statement that reads the first input data record
46
Summary (continued)
• Structured techniques promote:
–
–
–
–
Clarity
Professionalism
Efficiency
Modularity
• Flowchart can be made structured by untangling
47
```