Our Recommendation for You Search your Query, You can find easily. for example search by book name or course name or any other which is related to your education

Followers

CS201 Lecture No 7 Video

CS 201 Lecture No 7



  Lecture Handout
  Introduction to programming
  Lecture No. 7
  Reading Material
  Deitel & Deitel – C++ How to Program    Chapter 2 
  2.11, 2.12, 2.14, 2.15, 2.17
  Summary
  o  Do-While Statement
Example

for Statement
Sample Program 1 
Increment/decrement Operators
Sample Program 2
Tips 

  Do-While Statement
  We have seen that there may be certain situations when the body of while loop does not
  execute even a single time. This occurs when the condition in   while is false. In   while
  loop, the condition is tested first and the statements in the body are executed only when
  this condition is true. If the condition is false, then the control goes directly to the
  statement after the closed brace of the while loop. So we can say that in while structure,
  the loop can execute zero or more times. There may be situations where we may need
  that some task must be performed at least once. 
  For example, a computer program has a character stored from a-z. It gives to user
  five chances or tries to guess the character. In this case, the task of guessing the character
  must be performed at least once. To ensure that a block of statements is executed at least
  once, C provides a do-whilestructure. The syntax of do-whilestructure is as under:
  do 
   {  
      statement(s);
   } 
   while ( condition ) ;
  Here we see that the condition is tested after executing the statements of the loop body.
  Thus, the loop body is executed at least once and then the condition in do while statement
  is tested. If it is true, the execution of the loop body is repeated. In case, it proves
  otherwise (i.e. false), then the control goes to the statement next to the   do while
  statement. This structure describes ‘execute the statements enclosed in braces in   do
  clause' when the condition in while clause is true. 
  Broadly speaking, in   whileloop, the condition is tested at the beginning of the loop
  before the body of the loop is performed. Whereas in   do-while loop, the condition is
  tested after the loop body is performed. 
  Therefore, in do-whileloop, the body of the loop is executed at least once.
  The flow chart of do-while structure is as follow:
  Example
  Let’s consider the example of guessing a character. We have a character in the program
  to be guessed by the user. Let’s call it ‘z’. The program allows five  tries (chances) to the
  user to guess the character. We declare a variable tryNum to store the number of tries.
  The program prompts the user to enter a character for guessing. We store this character in
  a variable c.
  We declare the variable   c of type   char. The data type   char is used to store a single
  character. We assign a character to a variable of   char type by putting the character in
  single quotes. Thus the assignment statement to assign a value to a charvariable will be
  as c = ‘a’. Note that there should be a single character in single quotes. The statement like
  c = ‘gh’ will be a syntax error. 
  Here we use the   do-whileconstruct. In the   doclause we prompt the user to enter a
  character.
  After getting character in variable c from user, we compare it with our character i.e ‘z’.
  We use if\elsestructure for this comparison. If the character is the same as ours then we
  display a message to congratulate the user else we add 1 to tryNumvariable. And then in
  while clause, we test the condition whether tryNum is less than or equal to 5 (tryNum <=
  5). If this condition is true, then the body of the doclause is repeated again. We do this
  only when the condition (tryNum <= 5) remains true. If it is otherwise, the control goes
  to the first statement after the do-whileloop. 
  If guess is matched in first or second try, then we should exit the loop. We know that the
  loop is terminated when the condition tryNum <= 5 becomes false, so we assign a value
  which is greater than 5 to tryNum after displaying the message. Now the condition in the
  while statement is checked. It proves false (as tryNum is greater than 5). So the control
  goes out of the loop. First look here the flow chart for the program.
  The code of the program is given below.
  //This program allows the user to guess a character from a to z
  //do-while construct is used to allow five tries for guessing
  # include <iostream.h>
  main ( )
  {
  //declare & initialize variables
  int tryNum = 0 ;
  char c ;
  // do-while construct
  do
  {
  cout << “Please enter a character between a-z for guessing :     “ ;
  cin >> c ;
  //check the entered character for equality
  if ( c == ‘z’)
  {
  cout << “Congratulations,  Your guess is correct” ;
  tryNum = 6;
  }
  else
  {
  tryNum = tryNum + 1;
  }
  }
  while ( tryNum <= 5);
  }
  There is an elegant way to exit the loop when the correct number is guessed. We change
  the condition in   whilestatement to a compound condition. This condition will check
  whether the number of tries is less than or equal to 5 and the variable c is not equal to ‘z’.
  So we will write the   whileclause as while (tryNum <= 5 && c != ‘z’ ); Thus when a
  single condition in this compound condition becomes false, then the control will exit the
  loop. Thus we need not to assign a value greater than 5 to variable   tryNum. Thus the
  code of the program will be as:
  //This program allows the user to guess a character from a to z
  //do-while construct is used to allow five tries for guessing
  # include <iostream.h>
  main ( )
  {
  //declare & initialize variables
  int tryNum = 0 ;
  char c ;
  // do-while construct, prompt the user to guess a number and compares it 
  do
  {
  cout << “Please enter a character between a-z for guessing :     “ ;
  cin >> c ;
  //check the entered character for equality
  if ( c == ‘z’)
  {
  cout << “Congratulations,  Your guess is correct” ;
  }
  else
  {
  tryNum = tryNum + 1;
  }
  }
  while ( tryNum <= 5 && c != ‘z’ );
  }
  The output of the program is given below.
  Please enter a character between a-z for guessing :       g
  Please enter a character between a-z for guessing :       z
  Congratulations, Your guess is correct
  for Loop
  Let’s see what we do in a loop. In a loop, we initialize variable(s) at first. Then we set a
  condition for the continuation/termination of the loop. To meet the condition to terminate
  the loop, we affect the condition in the body of the loop. If there is a variable in the
  condition, the value of that variable is changed within the body of the loop. If the value of
  the variable is not changed, then the condition of termination of the loop will not meet
  and loop will become an infinite one. So there are three things in a loop structure i.e. (i)
  initialization, (ii) a continuation/termination condition and (iii) changing the value of the
  condition variable, usually the increment of the variable value.
  To implement these things, C provides a loop structure known as for loop.  This is the
  most often used structure to perform repetition tasks for a known number of repetitions.
  The syntax of for loop is given below.
  for ( initialization condition ; continuation condition ; incrementing condition )
  {
  statement(s) ;
  }
  We see that a 'for statement'consists of three parts. In initialization condition, we
  initialize some variable while in continuation condition, we set a condition for the
  continuation of the loop. In third part, we increment the value of the variable for which
  the termination condition is set. 
  Let's suppose, we have a variable counter of type int. We write for loop in our program
  as 
  for ( counter = 0 ; counter < 10 ; counter = counter +1 )
  {
  cout << counter << endl;
  }
  This 'for loop' will print on the screen 0, 1, 2 …. 9 on separate lines (as we use endl in our
  cout statement). In for loop, at first, we initialize the variable counter to 0. And in the
  termination condition, we write counter < 10. This means that the loop will continue till
  value of counter is less than 10. In other words, the loop will terminate when the value of
  counter is equal to or greater than 10. In the third part of forstatement, we write counter
  = counter + 1 this means that we add 1 to the existing value of   counter. We call it
  incrementing the variable.
  Now let's see how this loop executes. When the control goes to forstatement first time, it
  sets the value of variable counter to 0, tests the condition (i.e. counter < 10). If it is true,
  then executes the body of the loop. In this case, it displays the value of counterwhich is 0
  for the first execution. Then it runs the incrementing statement (i.e. counter = counter + 1
  ). Thus the value of counter becomes 1. Now, the control goes to forstatement and tests
  the condition of continuation. If it is true, then the body of the loop is again executed
  which displays 1 on the screen. The increment statement is again executed and control
  goes to for statement. The same tasks are repeated. When the value of counter becomes
  10, the condition   counter < 10 becomes false. Then the loop is terminated and control
  goes out of for loop.
  The point to be noted is that, the increment statement (third part of   for statement) is
  executed after executing the body of the loop. Thus for structure is equivalent to a while
  structure, in which, we write explicit statement to change (increment/decrement) the
  value of the condition variable after the last statement of the body. The for loop does this
  itself according to the increment statement in the for structure. There may be a situation
  where the body of for loop, like whileloop, may not be executed even a single time. This
  may happen if the initialization value of the variable makes the condition false. The
  statement in the following for loop will not be executed even a single time as during first
  checking, the condition becomes false. So the loop terminates without executing the body
  of the loop.
   for ( counter = 5 ; counter < 5 ; counter ++)
  {
  cout << “The value of counter is   “ << counter ;
  }
  Sample Program 1
  Let’s take an example to explain   for   loop. We want to write a program that prints the
  table of 2 on the screen. 
  In this program, we declare a variable   counter of type   int. We use this variable to
  multiply it by 2 with values 1 to 10. For writing the table of 2, we multiply 2 by 1, 2, 3 ..
  upto 10 respectively and each time display the result on screen. So we use   for loop to
  perform the repeated multiplication.
  Following is the code of the program that prints the table of 2.
  //This program display the table of 2 up to multiplier 10
  # include <iostream.h>
  main ( )
  {
  int counter;
  //the for loop
  for ( counter = 1 ; counter <= 10 ; counter = counter + 1)
  {
  cout << “2 x “ << counter << “ = “ << 2 * counter << “\n” ;
  }
  }
  This is a simple program. In the for statement, we initialize the variable counter to 1 as
  we want the multiplication of 2 starting from 1. In the condition clause, we set the
  condition   counter <= 10 as we want to repeat the loop for 10 times. And in the
  incrementing clause, we increment the variable counter by 1.
  In the body of the for loop, we write a single statement with cout. This single statement
  involves different tasks. The portion ‘<< “2 x “’displays the string “2 x “ on the screen.
  After this, the next part ‘<< counter’ will print the value of counter.  The ‘<< “ = ”’ will
  display ‘ = ‘ and then the next part ‘<< 2 * counter’  will display the result of 2 multiply
  by counter and the last <<”\n” ( the new line character) will start a new line. Thus in the
  first iteration where the value of   counter is 1, the   coutstatement will display the
  following line
  2 x 1 = 2
  After the execution of   coutstatement, the   for statement will increment the counter
  variable by 1. Thus value of counter will be 2. Then condition will be checked which is
  still true. Thus the body of for loop (here the   cout   statement) will be executed again
  having the value of counter 2. So the following line will be printed.
  2 x 2 = 4
  The same action will be repeated 10 times with values of counter from 1 to 10. When the
  value of counter is 11, the condition (   counter <= 10 ) will become false and the loop
  will terminate. 
  The output of the above program is as the following.
  2 x 1 = 2
  2 x 2 = 4
  2 x 3 = 6
  2 x 4 = 8
  2 x 5 = 10
  2 x 6 = 12
  2 x 7 = 14
  2 x 8 = 16
  2 x 9 = 18
  2 x 10 = 20
  Now what will we do, if some one says us to write a table of 3, or 4 or 8 or any other
  number. Here comes the point of re-usability and that a program should be generic. We
  write a program in which a variable is used instead of a hard code number. We prompt
  the user to enter the number for which he wants a table. We store this number in the
  variable and then use it to write a table. So in our previous example, we now use a
  variable say   numberwhere we were using 2. We also can allow the user to enter the
  number of multipliers up to which he wants a table. For this, we use a variable
  maxMultiplier and execute the loop for   maxMultiplier times by putting the condition
  counter <= maxMultiplier. Thus our program becomes generic which can display a table
  for any number and up to any multiplier.
  Thus, the code of our program will be as below:
  //This program takes an integer input from user and displays its table
  //The table is displayed up to the multiplier entered by the user
  # include <iostream.h>
  main ( )
  {
  int counter, number, maxMultiplier ;
  // Prompt the user for input
  cout << “Please enter the number for which you want a table :    “ ;
  cin >> number ;
  cout << “Please enter the multiplier up to which you want a table :   “ ;
  cin >> maxMultiplier ;
  //the for loop
  for ( counter = 1 ; counter <= maxMultiplier ; counter = counter + 1)
  {
  cout << number << “ x “ << counter << “ = “ <<  number * counter << “\n” ;
  }
  }
  The output of the program is shown as follows:
  Please enter the number for which you want a table :     7
  Please enter the multiplier up to which you want a table :    8
  7 x 1 = 7
  7 x 2 = 14
  7 x 3 = 21
  7 x 4 = 28
  7 x 5 = 35
  7 x 6 = 42 
  7 x 7 = 49 
  7 x 8 = 56
  Here is a guideline for programming style. We should avoid using constant values in our
  calculations or in long  routines. The disadvantage of this is that if we want to change that
  constant value later, then we have to change every occurrence of that value in the
  program. Thus we have to do a lot of work and there may be some places in code where
  we do not change that value. To avoid such situations, we can use a variable at the start
  and assign that constant value to it and then in the program use that variable. Thus, if we
  need to change the constant value, we can assign the new value to that variable and the
  remaining code will remain the same. So in our program where we wrote the table of 2,
  we can use a variable (say number) and assign it the value 2. And in coutstatement we
  use this variable instead of constant 2. If we want that the program should display a table
  of 5, then we just change the value of the variable. So for good programming, use
  variables for constant values instead of explicit constant values. 
  Increment Decrement Operators   
  We have seen that in while, do-while and for loop we write a statement to increase the
  value of a variable. For example, we used the statements like   counter = counter + 1;
  which adds 1 to the variable   counter. This increment statement is so common that it is
  used almost in every repetition structure (i.e. in while, do-while and for loop).  The C
  language provides a unary operator that increases the value of its operator by 1. This
  operator is called increment operator and sign ++ is used for this. The statement counter
  = counter + 1; can be replaced with the statement 
  counter ++ ; 
  The statement counter++ adds 1 to the variable counter. Similarly the expressions i = i +
  1 ; and   j = j + 1 ; are equivalent to i++ ; and j++; respectively. There is also an operator
  -- called decrement operator. This operator decrements, the value of its operand by 1. So
  the statements counter = counter - 1; and j = j - 1; are equivalent to counter--;  and j--;
  respectively.
  The increment operator is further categorized as pre-increment and post-increment.
  Similarly, the decrement operator, as pre-decrement and post-decrement.
  In pre-increment, we write the sign before the operand like ++jwhile in post-increment,
  the sign ++ is used after the operand like j++. If we are using only variable increment,
  pre or post increment does not matter. In this case,   j++ is equivalent to   ++j. The
  difference of pre and post increment matters when the variable is used in an expression
  where it is evaluated to assign a value to another variable. If we use pre-increment ( ++j ),
  the value of j is first increased by 1. This new value is used in the expression. If we use
  post increment ( j++ ),the value of j is used in the expression. After that it is increased by
  1. Same is the case in pre and post decrement.
  If j = 5, and we write the expression  
  x = ++ j ;
   After the evaluation of this expression, the value of x will be 6 (as j is incremented first
  and then is assigned to x). The value of j will also be 6 as ++ operator increments it by 1. 
  If j = 5, and we write the expression 
   x = j++ ;
  Then after the evaluation of the expression, the value of x will be 5 (as the value of j is
  used before increment) and the value of j will be 6. 
  The same phenomenon is true for the decrement operator with the difference that it
  decreases the value by 1. The increment and decrement operators affect the variable and
  update it to the new incremented or decremented value.
  The operators ++ and -- are used to increment or decrement the variable by 1. There may
  be cases when we are incrementing or decrementing the value of a variable by a number
  other than 1. For example, we write   counter = counter + 5; or   j = j – 4;. Such
  assignments are very common in loops, so C provides operators to perform this task in
  short. These operators do two things they perform an action (addition, subtraction etc)
  and do some assignment.
  These operators are +=, -=, *=, /= and %=. These operators are compound assignment
  operators. These operators assign a value to the left hand variable after performing an
  action (i.e. +, -, *, / and %). The use of these operators is explained by the following
  examples.
  Let’s say we have an expression,   counter = counter + 5;. The equivalent of this
  expression is counter += 5;. The statement counter += 5; does two tasks. At first, it adds
  5 to the value of counter and then assigns this result to counter. Similarly the following
  expressions
  x = x + 4 ;
  x = x - 3 ;
  x = x * 2 ;
  x  = x  / 2 ;
  x  = x  % 3;
  can be written in equivalent short statements using the operators ( +=, -=, *=, /=, %= ) as
  follows
  x  += 4 ;
  x  -= 3 ;
  x  *= 2;
  x  /= 2;
  x  %= 3 ;
  Note that there is no space between these operators. These are treated as single signs. Be
  careful about the operator %=. This operator assigns the remainder to the variable. These
  operators are alternate in short hand for an assignment statement. The use of these
  operators is not necessary. A programmer may use these or not. It is a matter of style.
  Example Program 2
  Let’s write a program using for loop to find the sum of the squares of the integers from 1
  to n. Where n is a positive value entered by the user (i.e. Sum = 12 + 22 + 32 + ……+ n2)
  The code of the program is given below:
  //This program displays the sum of squares of integers from 1 to n
  # include <iostream.h>
  main ( )
  {
  //declare and initialize variables
  int i, n, sum;
  sum = 0 ;
  //get input from user and construct a for loop
  cout << “Please enter a positive number for sum of squares:    ” ;
  cin >> n;
  for ( i = 1 ; i <= n ; i ++)
  {
  sum += i * i ;
  }
  cout << “The sum of the first ” << n << “ squares is  “ << sum << endl ;
  }
  In the program declared three variables   i,   n and sum. We prompted the user to enter a
  positive number. We stored this number in the variable n. Then we wrote a for loop. In
  the initialization part, we initialized variable i with value 1 to start the counting from 1. In
  the condition statement we set the condition i less than or equal to n (number entered by
  the user) as we want to execute the loop   n times. In the increment statement, we
  incremented the counter variable by 1. In the body of the   for loop we wrote a single
  statement sum += i * i ;. This statement takes the square of the counter variable ( i  )and
  adds it to the variable sum. This statement is equivalent to the statement  sum = sum + ( i
  * i ) ; Thus in each iteration the square of the counter variable (which is increased by 1 in
  each iteration ) is added to the sum. Thus loop runs ntimes and the squares of numbers
  from 1 to n are summed up. After completing the for loop the coutstatement is executed
  which displays the sum of the squares of number from 1 to n.
  Following is the output when the number 5 is entered.
  Please enter a positive number for sum of squares:      5
  The sum of the first 5 squares is 55
  Tips 
    Comments should be meaningful, explaining the task
    Don’t forget to affect the value of loop variable in while and do-while
  loops
    Make sure that the loop is not an infinite loop
    Don’t affect the value of loop variable in the body of for loop, the for loop
  does this by itself in the for statement
    Use pre and post increment/decrement operators cautiously in expressions