Implementing Functions from a Detailed Design Quick Tips

General Idea A function is segment of code that: - gets inputs from some source - performs some operation (algorithm) to transform the inputs into results - delivers the results to some destination as output

General Idea Graphically, think of something like a Sausage Grinder: usually, several things go “in” and one thing comes “out” (though that’s not always the case)

Input Input is data “coming in” to the function. Sources include: - Data passed in from another function - Data entered by the user (human interaction) - Data read from a file

Output Output is data “going out” of the function. Destinations include: - Data passed to (back to) another function - Data delivered to the user (printed) - Data written to a file

Important Design Philosophy “That’s not MY job!!!” A function should do a single task. The task of some functions is to interact with the user: ask for input and print output. But some functions do NOT interact with the user: they get their input from elsewhere, and deliver their output elsewhere.

Important Design Philosophy “That’s not MY job!!!” Think about workers in a fast food restaurant: Some interact with customers (take and deliver orders), others do not: cooks for instance. One employee takes the order, and “passes” that info to the cook. The cook prepares the food and “passes” it back to the first employee, who then gives it to the customer.

Important Design Philosophy “That’s not MY job!!!” Functions are designed to work in the same way: each does a specific job, and not another job; and some jobs don’t involve interacting with the customer (user). The point: not every function will use cin/cout!

Detailed Designs Detailed Design Documents are very “technical” in nature, but are still written in a human language. This language must be interpreted and translated into actual C++ code. One of the easiest ways to do this is to look for the use of key phrases and words that indicate the specification of the code.

Detailed Designs: Inputs Input Arguments: Look for phrases like: - “function is given” - “function is passed” - “function takes” Data that “is given” indicates use of PBV Formal Variables.

Detailed Designs: Inputs Input Arguments: Examples “Write a function that is given two integers...” Interpretation: void fun(int a, int b) “Write a function that takes a dollar amount...” Interpretation: void fun(float dollarAmt)

Detailed Designs: Inputs Input Arguments: Pitfall Here is where beginning students often make a mistake: they correctly determine that a value is an Input Argument, but when they write the function, they still “ask the user”. Remember that Input Arguments already have a value...assigned by the invoking function. So there is no need to “ask the user” again

Detailed Designs: Inputs Input Arguments: Pitfall “Write a function that is given a subtotal and calculates and returns the tax. The tax rate is 6%” float calcTax(float subtotal) { cout << ”Enter subtotal: ”; cin >> subtotal; float tax = subtotal * 0.06; return tax; }

Detailed Designs: Inputs Input Arguments: Pitfall The cout/cin are not needed, because subtotal = value_of_Actual_Arg; is executed when the function is invoked. ... AND: it is somebody else’s job to “ask”...my job is to calculate tax!

Detailed Designs: Inputs User input: Look for phrases like: “asks the user” “gets from the user” “prompts the user” These are interpreted as a cin/cout pair.

Detailed Designs: Inputs User input: Example “Write a function that asks the user to enter their age...” Interpretation: void fun() { int age; cout << ”Enter your age: ”; cin >> age; }

Detailed Designs: Outputs Output back to the invoking function: Most functions send output back to the function which invoked them. Usually there is only one such output, but sometimes there are more, and sometimes there is none. Look for the phrase “... returns ...” or “... passes back” in the description.

Detailed Designs: Outputs Output back to the invoking function: When there is no value returned: - the return type is void When there is one value returned: - the return type is the type of the value returned. - use the return command to return the value. Where there is more than one value returned: - use a void return type - use a PBR argument for each value “returned”. - do not use the return command; instead: - set the value of each PBR argument to the “returned” value.

Detailed Designs: Outputs Output back to the invoking function: no value “Write a function that prints hello on the screen.” Note, there is no mention of “returns”, so use void: void sayHi() { cout << ”Hello”; }

Detailed Designs: Outputs Output back to the invoking function: 1 value “Write a function that asks the user to enter their age and returns the age entered.” int askAge() { int age; cout << ”Enter your age: ”; cin >> age; // age is int, so return age; // return type is int }

Detailed Designs: Outputs Output back to the invoking function: 2 values “Write a function that asks the user to enter their name and age and passes these back.” void askNameAndAge(string & n, int & a) { cout << ”Enter your name: ”; cin >> n; cout << ”Enter your age: ”; cin >> a; }

Detailed Designs: Outputs User Output: Look for the words: - prints - displays - shows These are interpreted as cout’s

Detailed Designs: Outputs User Output: Example "Write a function that is given a name and greets the user printing Hello followed by the name" void greet(string name) { cout << "Hello " << name; }