1. Programming Logic and Design Seventh Edition
Chapter 3
Understanding Structure

2. 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

3. Three Basic Control Structures Sequence, Selection, Repetition/Iteration/Looping

4. RAPTOR Symbols Sequence Control Structures Selection and Repetition

5. Understanding Unstructured 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
RAPTOR does not permit you to draw an unstructured flowchart

6. Figure 3-1 Spaghetti code logic for washing a dog

7. Understanding the Three Basic Structures
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

8. 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.
Figure Sequence

9. Understanding the Three Basic Structures (continued)no
yes
question
usually referred to as the condition
statement
statement
Figure Selection structure

10. Understanding the Three Basic Structures (continued)
Dual-alternative if
Contains two alternatives
If-then-else structure
Pseudocode keywords:
if, then, do, else, endif
if someCondition [is true] then
do statement_1
else
do statement_2
endif
statements

11. 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

12. Understanding the Three Basic Structures (continued)
Figure Single-alternative selection structure

13. 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!

14. Understanding the Three Basic Structures (continued)
Connector
When using drawing software such as Visio
Figure Loop structure (pre-test form – while … do)

15. 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() //module call
do add 1 to count

16. 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

17. Understanding the Three Basic Structures (continued)
Connector
Figure Structured flowchart and pseudocode with three stacked structures

18. 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

19. Understanding the Three Basic Structures (continued)
block or compound statement
Figure Flowchart and pseudocode showing nested structures [ sequence nested within a selection ]

20. Understanding the Three Basic Structures (continued)
entry point and
exit point
for a structure
structures have ONE of each
Figure Flowchart and pseudocode showing nested structures
a loop nested within a sequence, nested within a selection

21. Understanding the Three Basic Structures (continued)
Figure Flowchart and pseudocode for
selection structure with nested sequence and loop structures

22. 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

23. 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

24. Using a Priming Input to Structure a Program (continued)
Figure Structured, but nonfunctional, flowchart of number-doubling problem

25. 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 Functional but unstructured flowchart
Programming Logic & Design, Sixth Edition

26. 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

27. Figure 3-17 Functional, structured flowchart for the number-doubling problem

28. Programming Logic & Design, Sixth Edition
Figure Structured but incorrect solution to the number-doubling problem
Programming Logic & Design, Sixth Edition

29. Understanding the Reasons for Structure
Clarity
Professionalism
Efficiency
Ease of maintenance
Supports modularity

30. 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

31. Flowchart Status
Flowcharts fall in to one of the 3 following categories:
structured AND functional
structured but NOT functional
functional but NOT structured
These categories will be presented over the next several slides.

32. Recognizing Structure (continued)
What are the structures?
Are they:
stacked?
nested?
structured?
functional?
Figure 3-20 Example 2
Programming Logic & Design, Sixth Edition

33. Recognizing Structure (continued)
This is a no no!
Functional
but
not
Structured
Figure 3-21 Example 3

34. Recognizing Structure (continued)
Single process like G is part of an acceptable structure
At least the beginning of a sequence structure
Figure Untangling Example 3, first step

35. Recognizing Structure (continued)
H begins a selection structure
Sequences never have decisions in them
Logic never returns to G
Figure Untangling Example 3, second step

36. Recognizing Structure (continued)
Pull up on the flowline from the left side of H
Figure Untangling Example 3, third step

37. Recognizing Structure (continued)
Next, pull up the flowline on the right side of H
Figure Untangling Example 3, fourth step

38. Recognizing Structure (continued)
Pull up the flowline on the left side of I and untangle it from the B selection by repeating J
Figure Untangling Example 3, fifth step

39. Recognizing Structure (continued)
Now pull up the flowline on the right side of I
Figure Untangling Example 3, sixth step

40. Recognizing Structure (continued)
Bring together the loose ends of I and of H
Figure Finished flowchart and pseudocode for untangling Example 3

41. 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

42. 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 Washing the dog, part 2

43. Programming Logic & Design, Sixth Edition
Figure 3-31 Washing the dog, part 3
Programming Logic & Design, Sixth Edition

44. Programming Logic & Design, Sixth Edition
Figure Structured dog-washing flowchart and pseudocode
Programming Logic & Design, Sixth Edition

45. Programming Logic & Design, Sixth Edition
Figure Modularized version of the dog-washing program
Programming Logic & Design, Sixth Edition

46. Summary Spaghetti code Three basic structures Priming read
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

47. Summary (continued) Structured techniques promote:
Clarity
Professionalism
Efficiency
Modularity
Flowchart can be made structured by untangling