Implementing Homework 1. (Or Functions 101)

• The purpose of a functional decomposition is to identify the functions we will eventually implement in our program.
• Once we have cohesive concrete functions we can begin to design the code.
• As I pointed out in the last section, we need to know what data a function needs
  • To be given so it can do it's work.
  • To return, so it can report the results.
• There are two mechanisms for data exchange between a calling function and a called function
  • one piece of data can be returned via a return value.
    • This can be a complex data type, so multiple information is possible.
    • More on this as the semester goes along.
  • Data can be sent to a function via a value parameter
  • Data can be sent to/returned from a function via a reference parameter.
  • All three of these can be used in one function.
  • I lie, values can be used globally but for the most part that is just bad programming practice.
• It is both a technical and aesthetic choice on what to pick.
• Let's look at value returning functions.
  • Usage
    • These are best suited when a single value needs to be returned.
    • But sometimes the are used when an error message, independent of the results should be returned.
    • We have seen these, pow, sqrt, ...
    • I really like them to return a bool for use in a loop or selection statement.
      • For our program

      • while (GetContinue()) {
            ...
        }
        

      • By implication, how does GetContinue return information?
      • What (data) type of information does it return.
      • Can you explain
    • Syntax:
      • Remember function syntax is
      • return_type identifier([parameter list]); for the function prototype

      • return_type identifier([parameter list]) {
        ...
           return expression;
        }

      • Note expression must be of type return_type
      • If the return_type is void, then simply return; will suffice.
      • The parameter_list can be empty or void.
  • Let's implement GetContinue
    • No data is needed from the calling function.
    • We will return a bool via the return value.
    • We will implement just like main
      • Declare and initialize local variables needed.
      • Implement code to perform the function.
      • Return the correct value.
  • Implementation:

    • GetContinue:
          Input: no input from main
          Output: returns a bool  (yes continue -> true, no don't continue -> false)
      
          While we don't have a response of yes or no
              Print the prompt
              read in the response
              convert the response to lower case
          return the response
               

    • So the implementation would be

    • bool GetContinue() {
          string answer;
      
          while (answer!= "yes" and answer != "no") {
              cout <<  "Do you wish to encrypt a message (yes/no)? ";
              getline(cin, answer);
              cout << endl;
      
              answer= ToLower(answer);
          }
      
          return answer == "yes";
      } 

    • This implies a ToLower function, which C++ does not have, so let's write that.
  • Put it in main

    int main() {
        while (GetContinue()) {
           cout << "\tProcessing a code" << endl;
        }
    
        return 0;
    }
         

  • Now we can test to see if the two functions work or not.
  • Note that each of these functions could be written as functions with a single reference parameter.
  • What other functions in our design can be written as value returning functions.