1. Chapter 4 – Control Structures Part 1
Outline Introduction Algorithms Pseudocode Control Structures if Selection Structure if/else Selection Structure while Repetition Structure Formulating Algorithms: Case Study 1 (Counter-Controlled Repetition) Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition) Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures) Assignment Operators Increment and Decrement Operators 4.13 Introduction to Windows Application Programming

2. Before writing a program
4.1 Introduction
Before writing a program
Understand the problem
Think of an approach
Understand building blocks
Use proven principals of structured programming

3. 4.2 Algorithms Procedure Program control
The actions a program will perform
The order these actions will be performed
Also called an algorithm
Program control
The task of ordering a computers procedure correctly

4. 4.3 Pseudocode Pseudocode Artificial and informal language
Helps programmers to plan an algorithm
Similar to everyday English
Not an actual programming language
Converting simply replaces words with C# code

5. 4.4 Control Structures Program of control
Program performs one statement then goes to next line
Sequential execution
Different statement other than the next one executes
Selection structure
The if and if/else statements
The goto statement
No longer used unless absolutely needed
Causes many readability problems
Repetition structure
The while and do/while loops (chapter 5)
The for and foreach loops (chapter 5)

6. 4.4 Control Structures Flow carts Used to map program
Illustrates the order events will go in
Rectangle used to show action
Oval used to show beginning
Circles used as connectors
Diamonds used as decisions
Combination of control structures
Stacking
Placing one after another
Nesting
Inserting of one structure into another

7. 4.4 Control Structures add grade to total add 1 to counter
total = total + grade;
counter = counter + 1;
Fig. 4.1 Flowcharting C#’s sequence structure.

8. 4.4 Control Structures

9. 4.5 if Selection Structure
The if structure
Causes the program to make a selection
Chooses based on conditional
Any expression that evaluates to a bool type
True: perform an action
False: skip the action
Single entry/exit point
Require no semicolon in syntax

10. 4.5 if Selection Structure
print “Passed”
Grade >= 60
true
false
Fig. 4.3 Flowcharting a single-selection if structure.

11. 4.6 if/else selection structure
The if/else structure
Alternate courses can be taken when the statement is false
Rather than one action there are two choices
Nested structures can test many cases
Structures with many lines of code need braces ({)
Can cause errors
Fatal logic error
Nonfatal logic error

12. 4.6 if/else Selection Structure
Grade >= 60
print “Passed”
print “Failed”
false
true
Fig. 4.4 Flowcharting a double-selection if/else structure.

13. Conditional Operator (?:)
C#’s only ternary operator
Similar to an if/else structure
The syntax is:
(boolean value ? if true : if false)

14. 4.7 while Repetition Structure
An action is to be repeated
Continues while statement is true
Ends when statement is false
Contain either a line or a body of code
Must alter conditional
Endless loop

15. 4.7 while Repetition Structure
true
false
Product = 2 * product
Product <= 1000
Fig. 4.5 Flowcharting the while repetition structure.

16. Counter Controlled Repetition
4.8 Formulating Algorithms: Case Study 1 (Counter Controlled Repetition)
Counter Controlled Repetition
Used to enter data one at a time
Constant amount
A counter is used to determine when the loop should break
When counter hits certain value, the statement terminates

17. 4.8 Formulating Algorithms: Case Study 1 (Counter Controlled Repetition)
Set total to zero Set grade counter to one While grade counter is less than or equal to ten Input the next grade Add the grade into the total Add one to the grade counter Set the class average to the total divided by ten Print the class average
Fig. 4.6 Pseudocode algorithm that uses counter-controlled repetition to solve the class-average problem.

18. Initialize gradeCounter to 1
1 // Fig. 4.7: Average1.cs 2 // Class average with counter-controlled repetition using System; class Average { static void Main( string[] args ) { int total, // sum of grades gradeCounter, // number of grades entered gradeValue, // grade value average; // average of all grades // initialization phase total = 0; // clear total gradeCounter = 1; // prepare to loop // processing phase while ( gradeCounter <= 10 ) // loop 10 times { // prompt for input and read grade from user Console.Write( "Enter integer grade: " ); // read input and convert to integer gradeValue = Int32.Parse( Console.ReadLine() ); // add gradeValue to total total = total + gradeValue; // add 1 to gradeCounter gradeCounter = gradeCounter + 1; }
Average1.cs
Initialize total to 0
Initialize gradeCounter to 1
The while loop will loop through 10 times to get the grades of the 10 students
Prompt the user to enter a grade
Accumulate the total of the 10 grades
Add 1 to the counter so the loop will eventually end

19. Average1.cs Program Output34
// termination phase
average = total / 10; // integer division 37
// display average of exam grades
Console.WriteLine( "\nClass average is {0}", average ); 40
} // end Main 42
43 } // end class Average1
Divide the total by ten to get the average of the ten grades
Average1.cs Program Output
Display the results
Enter integer grade: 100
Enter integer grade: 88
Enter integer grade: 93
Enter integer grade: 55
Enter integer grade: 68
Enter integer grade: 77
Enter integer grade: 83
Enter integer grade: 95
Enter integer grade: 73
Enter integer grade: 62
Class average is 79

20. Sentinel controlled repetition
4.9 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel Controlled Repetition)
Sentinel controlled repetition
Continues an arbitrary amount of times
Sentinel value
Causes loop to break
Avoid collisions
When flag value = user entered value
Creating pseudocode
Start with one task
Break it into several tasks
Continue breaking until each task is simple
Casting
Allows one variable to temporarily be used as another

21. 4.9 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel Controlled Repetition)
Initialize total to zero Initialize counter to zero Input the first grade (possibly the sentinel) While the user has not as yet entered the sentinel Add this grade into the running total Add one to the grade counter Input the next grade (possibly the sentinel) If the counter is not equal to zero Set the average to the total divided by the counter Print the average Else Print “No grades were entered”
Fig. 4.8 Pseudocode algorithm that uses sentinel-controlled repetition to solve the class-average problem.

22. Variables gradeCounter and total are set to zero at the beginning
1 // Fig. 4.9: Average2.cs
2 // Class average with sentinel-controlled repetition. 3
4 using System; 5
6 class Average2
7 {
static void Main( string[] args ) {
int total, // sum of grades
gradeCounter, // number of grades entered
gradeValue; // grade value 13
double average; // average of all grades 15
// initialization phase
total = 0; // clear total
gradeCounter = 0; // prepare to loop 19
// processing phase
// prompt for input and convert to integer
Console.Write( "Enter Integer Grade, -1 to Quit: " );
gradeValue = Int32.Parse( Console.ReadLine() ); 24
Average2.cs
The variable average is set to a double so that it can be more exact and have an answer with decimals
Variables gradeCounter and total are set to zero at the beginning
Get a value from the user and store it in gradeValue

23. Have the program loop as long as gradeValue is not -1 Average2.cs
// loop until a -1 is entered by user
while ( gradeValue != -1 ) {
// add gradeValue to total
total = total + gradeValue; 30
// add 1 to gradeCounter
gradeCounter = gradeCounter + 1; 33
// prompt for input and read grade from user
// convert grade from string to integer
Console.Write( "Enter Integer Grade, -1 to Quit: " );
gradeValue = Int32.Parse( Console.ReadLine() ); 38
} // end while 40
// termination phase
if ( gradeCounter != 0 ) {
average = ( double ) total / gradeCounter; 45
// display average of exam grades
Console.WriteLine( "\nClass average is {0}", average ); }
else {
Console.WriteLine( "\nNo grades were entered" ); } 53
} // end method Main 55
56 } // end class Average2
Have the program loop as long as gradeValue is not -1
Average2.cs
Accumulate the total of the grades
Add 1 to the counter in order to know the student count
Prompt the user for another grade, this time it is in the loop so it can happen repeatedly
Make sure the total amount of entered grades was not zero to prevent any errors
Divide the total by the number of times the program looped to find the average
Display the average
Inform user if no grades were entered

24. Average2.cs Program Output
Enter Integer Grade, -1 to Quit: 97
Enter Integer Grade, -1 to Quit: 88
Enter Integer Grade, -1 to Quit: 72
Enter Integer Grade, -1 to Quit: -1
Class average is
Average2.cs Program Output

25. 4.10 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)
Nesting
The insertion of one control structure inside another
Multiple loops
Loops with if statements

26. 4.10 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)
Initialize passes to zero
Initialize failures to zero
Initialize student to one
While student counter is less than or equal to ten
Input the next exam result
If the student passed
Add one to passes
Else
Add one to failures
Add one to student counter
Print the number of passes
Print the number of failures
If more than eight students passed
Print “Raise tuition”
Fig Pseudocode for examination-results problem.

27. Initialize both passes and failures to 0 Set the student count to 1
1 // Fig. 4.11: Analysis.cs
2 // Analysis of Examination Results. 3
4 using System; 5
6 class Analysis
7 {
static void Main( string[] args ) {
int passes = 0, // number of passes
failures = 0, // number of failures
student = 1, // student counter
result; // one exam result 14
// process 10 students; counter-controlled loop
while ( student <= 10 ) {
Console.Write( "Enter result (1=pass, 2=fail): " );
result = Int32.Parse( Console.ReadLine() ); 20
if ( result == 1 )
passes = passes + 1; 23
else
failures = failures + 1; 26
student = student + 1; } 29
Analysis.cs
Initialize both passes and failures to 0 Set the student count to 1
A while loop that will loop 10 times
A nested if statement that determines which counter should be added to
If the user enters 1 add one to passes
If the user enters 2 then add one to failures
Keep track of the total number of students

28. Analysis.cs Program Output
// termination phase
Console.WriteLine();
Console.WriteLine( "Passed: " + passes );
Console.WriteLine( "Failed: " + failures ); 34
if ( passes > 8 )
Console.WriteLine( "Raise Tuition\n" ); 37
} // end of method Main 39
40 } // end of class Analysis
Analysis.cs Program Output
Display the results to the user
If the total number of passes was greater than 8 then also tell the user to raise the tuition
Enter result (1=pass, 2=fail): 1
Enter result (1=pass, 2=fail): 2
Passed: 9
Failed: 1
Raise Tuition

29. Analysis.cs Program Output
Enter result (1=pass, 2=fail): 1
Enter result (1=pass, 2=fail): 2
Passed: 5
Failed: 5
Analysis.cs Program Output

30. 4.11 Assignment Operators Assignment operators Can reduce code
x += 2 is the same as x = x + 2
Can be done with all the math operators
++, -=, *=, /=, and %=

31. 4.11 Assignment Operators

32. 4.12 Increment and Decrement Operators
Increment operator
Used to add one to the variable
x++
Same as x = x + 1
Decrement operator
Used to subtract 1 from the variable
y--
Pre-increment vs. post-increment
x++ or x--
Will perform an action and then add to or subtract one from the value
++x or --x
Will add to or subtract one from the value and then perform an action

33. 4.12 Increment and Decrement Operators

34. Increment.cs Program Output
1 // Fig. 4.14: Increment.cs
2 // Preincrementing and postincrementing 3
4 using System; 5
6 class Increment
7 {
static void Main(string[] args) {
int c; 11
c = 5;
Console.WriteLine( c ); // print 5
Console.WriteLine( c++ ); // print 5 then postincrement
Console.WriteLine( c ); // print 6 16
Console.WriteLine(); // skip a line 18
c = 5;
Console.WriteLine( c ); // print 5
Console.WriteLine( ++c ); // preincrement then print 6
Console.WriteLine( c ); // print 6 23
} // end of method Main 25
26 } // end of class Increment
Increment.cs Program Output
Declare variable c
Set c equal to 5
Display c (5)
Display c (5) then add 1
Display c (6)
c is set to 5
Display c (5)
Add 1 then display c (6)
Display c (6) 5 6

35. 4.12 Increment and Decrement Operators

36. 4.13 Introduction to Windows Application Programming
Inheritance
Base class
a class from which another class inherits from
Derived class
The class from which another class inherits
Classes inherit basics of a class
Attributes (data)
Behaviors (methods)
Prevents the continual rewriting of code

37. 4.13 Introduction to Windows Application Programming
Collapsed comment
Collapsed code
Fig IDE showing program code for Fig

38. 4.13 Introduction to Windows Application Programming
Expanded code
Fig Windows Form Designer generated code when expanded.

39. 4.13 Introduction to Windows Application Programming
Click here for code view
Property initializations for WelcomeLabel
Click here for design view
Fig Code generated by the IDE for welcomeLabel.

40. 4.13 Introduction to Windows Application Programming
Text property
Fig Using the Properties window to set a property value.

41. 4.13 Introduction to Windows Application Programming
Fig Windows Form Designer generated code reflecting new property values.

42. 4.13 Introduction to Windows Application Programming
Text property
Fig Changing a property in the code view editor.

43. 4.13 Introduction to Windows Application Programming
Text property value
Fig New Text property value reflected in design mode.

44. 4.13 Introduction to Windows Application Programming
ASimpleProgram_Load method
Fig Method ASimpleProgram_Load.

45. 4.13 Introduction to Windows Application Programming
Fig Changing a property value at runtime.