CS201 Lecture No 8 Video

CS 201 Lecture No 8

Lecture Handout

Introduction to Programming

Lecture No. 8

Reading Material

Deitel & Deitel – C++ How to Program Chapter 2

2.16, 2.18

Summary

o Switch Statement

Break Statement

Continue Statement

Guide Lines

Rules for structured Programming/Flow Charting

Sample Program

Tips

Switch Statement

Sometimes, we have multiple conditions and take some action according to each

condition. For example, in the payroll of a company, there are many conditions to deduct

tax from the salary of an employee. If the salary is less than Rs. 10000, there is no

deduction. But if it falls in the slab Rs. 10000 - 20000, then the income tax is deducted. If

it exceeds the limit of Rs. 20000, some additional tax will be deducted. So the appropriate

deduction is made according to the category or slab of the salary.

We can also understand this from the example of grades secured by the students of a

class. Suppose we want to print description of the grade of a student. If the student has

grade ‘A’ we print ‘Excellent’ and 'Very good', 'good', 'poor' and 'fail' for grades B, C, D,

and F respectively. Now we have to see how this multi-condition situation can be applied

in a program. We have a tool for decision making i.e. 'if statement'. We can use 'if

statement' to decide what description for a grade should be displayed. So we check the

grade in if statement and display the appropriate description. We have five categories of

grades-- A, B, C, D, and F. We have to write five if statements to check all the five

possibilities (probabilities) of grade. So we write this in our program as under-

if ( grade == ‘A’ )

cout << “Excellent” ;

if ( grade == ‘B’ )

cout << “Very Good” ;

if ( grade == ‘C’ )

cout << “Good” ;

if ( grade == ‘D’ )

cout << “Poor” ;

if ( grade == ‘F’ )

cout << “Fail” ;

These statements are correct and perform the required task. But the 'if statement' is

computationally one of the most expensive statements in a program. We call it expensive

due to the fact that the processor has to go through many cycles to execute an if statement

to evaluate a single decision. So to make a program more efficient, try to use the

minimum number of if statements. This will make the performance of the program better.

So if we have different conditions in which only one will be true as seen in the example

of student’s grades, the use of if statement is very expensive. To avoid this

expensiveness, an alternate of multiple if statements can be used that is if/else statements.

We can write an if statement in the body of an if statement which is known as nested if.

We can write the previous code of if statements in the following nested if/else form.

If ( grade == ‘A’ )

cout << “Excellent” ;

else if ( grade == ‘B’ )

cout << “Very Good” ;

else if ( grade == ‘C’ )

cout << “Good” ;

else if ( grade == ‘D’ )

cout << “Poor” ;

else if ( grade == ‘F’ )

cout << “Fail” ;

In the code, there is single statement with each if statement. If there are more statements

with an if statement, then don’t forget the use of braces and make sure that they match

(i.e. there is a corresponding closing brace for an opening brace). Proper indentation of

the blocks should also be made.

In the above example, we see that there are two approaches for a multi way decision. In

the first approach, we use as many if statements as needed. This is an expensive

approach. The second is the use of nested if statements. The second is little more efficient

than the first one. In the 'nested if statements' the nested else is not executed if the first if

condition is true and the control goes out of the if block.

The C language provides us a stand-alone construct to handle these instances. This

construct is switch structure. The switch structure is a multiple-selection construct that is

used in such cases (multi way decisions) to make the code more efficient and easy to read

and understand.

The syntax of switch statement is as follows.

switch ( variable/expression )

{

case constant1 : statementLlist1 ;

case constant2 : statementLlist2 ;

case constantN : statementListN ;

default : statementList ;

}

In the switch statement, there should be an integer variable (also include char) or an

expression which must evaluate an integer type (whole numbers only, the decimal

numbers 2.5, 14.3 etc are not allowed). We can’t use compound conditions (i.e. the

conditions that use logical operators && or ||) in switch statement and in case statements.

The constants also must be integer constants (which include char). We can’t use a

variable name with the case key word. The default statement is optional. If there is no

case which matches the value of the switch statement, then the statements of default are

executed.

The switch statement takes the value of the variable, if there is an expression then it

evaluates the expression and after that looks for its value among the case constants. If the

value is found among the constants listed in cases, the statements in that statementList

are executed. Otherwise, it does nothing. However if there is a default (which is

optional), the statements of default are executed.

Thus our previous grade example will be written in switch statement as below.

switch ( grade )

{

case ‘A’ : cout << “Excellent” ;

case ‘B’ : cout << “Very Good” ;

case ‘C’ : cout << “Good” ;

case ‘D’ : cout << “Poor” ;

case ‘F’ : cout << “Fail” ;

}

We know that C language is 'case sensitive'. In this language, ‘A’ is different from ‘a’.

Every character has a numeric value which is stored by the computer.. The numeric value

of a character is known as ASCII code of the character. The ASCII code of small letters

(a, b, c etc ) are different from ASCII code of capital letters (A, B, C etc). We can use

characters in switch statement as the characters are represented as whole numbers inside

the computers.

Now we will see how the use of ' the letter a' instead of 'A' can affect our program. We

want our program to be user- friendly. We don’t want to restrict the user to enter the

grade in capital letters only. So we have to handle both small and capital letters in our

program. Here comes the limitations of switch statement. We can’t say in our statement

case ‘A’ or ‘a’ : statements ;

We have to make two separate cases so we write

case ‘A” :

case ‘a’ :

statements;

In the switch statement, the cases fall through the case which is true. All the statements

after that case will be executed right down to the end of the switch statement. This is very

important to understand it. Let's suppose that the user enters grade ‘B’. Now the case ‘A’

is skipped. Next case ‘B’ matches and statement cout << “Very Good” ; is executed.

After that, all the statements will be executed. So cout << “Good” ; cout << “Poor”

;and cout << “Fail” ; will be executed after one another. We don’t want this to happen.

We want that when a case matches, then after executing its statement, the control should

jump out of the switch statement leaving the other cases. For this purpose we use a key

word break.

Break Statement

The break statement interrupts the flow of control. We have seen in switch statement that

when a true case is found, the flow of control goes through every statement down ward.

We want that only the statements of true case should be executed and the remaining

should be skipped. For this purpose, we use the break statement. We write the break

statement after the statements of a case. Thus, when a true case is found and its

statements are executed then the break statement interrupts the flow of control and the

control jumps out of the switch statement. If we want to do the same task for two cases,

like in previous example for ‘A’ and ‘a’, then we don't put break statement after the first

case. We write both the cases (or the cases may be more than two) line by line then write

the common statements to be executed for these cases. We write the break statement after

these common statements. We should use the break statement necessarily after the

statements of each case. The break statement is necessary in switch structure, without it

the switch structure becomes illogic. As without it all the statement will execute after first

match case is found.

The above code does nothing if the grade is other than these five categories (i.e. A, B, C,

D and F). To handle all the possibilities of grade input, we write a default statement after

the last case. The statement in this default case is executed if no case matches the grade.

So in our program, we can write the default statement after the last case as under.

default : cout << “Please enter grade from A to D or F ” ;

The break statement is also used in decision structures other than switch structure. We

have seen that in while, do-while and for loops, we have to violate some condition

explicitly to terminate the loop before its complete repetitions. As in a program of

guessing a character, we make a variable tryNum greater than 5 to violate the while

condition and exit the loop if the correct character is guessed before five tries. In these

loops, we can use the break statement to exit a loop. When a break statement is

encountered in a loop, the loop terminates immediately. The control exits the inner most

loop if there are nested loops. The control passes to the statement after the loop. In the

guessing character example, we want that if the character is guessed in first or second

attempt,. then we print the message ‘Congratulations, You guess is correct’ and exit the

loop. We can do this by using a break statement with an if statement. If the character is

guessed, we print the message. Afterwards, the break statement is executed and the loop

terminates. So we can write this as follows.

if ( c == ‘z’ ) // c is input from user

{

cout << “Great, Your guess is correct” ;

break;

}

Thus, break statement can be used to jump out of a loop very quickly.

The code of the program is given below.

//This program gets a grade from user and displays a description accordingly

# include <iostream.h>

main ( )

{

char grade ;

cout << “Please enter the student’s grade : ” ;

cin >> grade ;

switch ( grade )

{

case ‘A’ : // grade was upper case A

case ‘a’ : // grade was lower case a

cout << “Excellent” ;