CS102 Introduction to Computer Programming

1. CS102Introduction to Computer Programming Chapter 6 Functions Continued

2. Chapter 6 Topics • Storage Classes • Static Local Variables • Default Arguments • Using Reference Variables as Parameters • Inline Functions • Overloaded Functions • The exit() and atexit() Functions • Stubs and drivers • Testing Branches and Paths

3. Storage Classes • Four types of storage classes Automatic Variables External Variables Register Variables Static Variables • All variables are assigned a default class • You can specify a variables storage class by placing the class name before its data type • This will affect the variables lifetime not its scope Concept - All variables belong to a storage class, which determines the period of time the variable exists in memory.

4. Static Variables • Used to allow a local variable to remain in existence between function calls • makes the variable exist for the life time of the program • a static variable is only initialized once, when it is created • staticdata_type value; ex. static int Num; Concept - The variables stored in a functions local variables do not persist between function calls

5. /* This program shows that local variables do not retain their values between function calls. */ #include <iostream.h> // Function prototype void ShowLocal(void); void main(void) { ShowLocal(); ShowLocal(); } /* Definition of function ShowLocal. The initial value of LocalNum, which is 5, is displayed. The value of LocalNum is then changed to 99 before the function returns. */  void ShowLocal(void) { int LocalNum = 5; // Local variable cout << "LocalNum is " << LocalNum << endl; LocalNum = 99; } Program 6-20 Program Output LocalNum is 5 LocalNum is 5

6. /* This program uses a static local variable */ #include <iostream.h> // Function prototype void ShowStatic(void); void main(void) { for (int Count = 0; Count < 5; Count++) ShowStatic(); } // Definition of function ShowStatic. void ShowStatic(void) { static int StatNum = 0; cout << "StatNum is " << StatNum << endl; StatNum++; } StatNum is 0 Program 6-21 This program demonstrates the effect of defining a variable as static Program Output StatNum is 1 StatNum is 2 StatNum is 3 StatNum is 4

7. Default Arguments • The value of a default argument must be a constant (a literal value or a named constant) • When an argument is left out of a function call, all the arguments that come after it must be left out as well. • If a function has a mixture of parameters, the parameters with default arguments must be declared last. Concept - Default arguments are passed to parameters automatically if no argument is provided in the function call.

8. Defining Default Arguments • In the function prototype void showArea (float = 20, float = 10); void showArea (float length = 20, float width = 10); • In the function definition void showArea (float length = 20, float width = 10) float area = length * width; cout << “the area is “ << area << endl: Concept – If there is not function prototype the default arguments can be placed in the function definition

9. /* This program demonstrates default function arguments. */ #include <iostream.h> // Function prototype with default arguments */ void DisplayStars(int = 10, int = 1); void main(void) { DisplayStars(); cout << endl; DisplayStars(5); cout << endl; DisplayStars(7, 3); } /* Definition of function DisplayStars. The default argument for Cols is 10 and for Rows is 1. This function displays a rectangle made of asterisks. */ void DisplayStars(int Cols, int Rows) { /* Nested loop. The outer loop controls the rows and the inner loop controls the columns. */ for (int Down = 0; Down < Rows; Down++) { for (int Across = 0; Across < Cols; Across++) cout << "*"; cout << endl; } } Program 6-23 Program Output ********** ***** ******* ******* *******

10. Using Reference Variables as Parameters • A reference variable is an alias to another variable. • Reference variables are declared with an & in front of the variable name data_type &variable_name; ex. int &Num; • Reference variables in function prototype statements, include the & after the data type return_typefunction-name( data_type & ); ex. Void func ( int & ); Concept - Reference variables allow a function to access the parameters original argument and apply changes to it.

11. /* This program uses a reference variable as a function parameter. */ #include <iostream.h> /* Function prototype. The parameter is a reference variable. */ void DoubleNum(int &); void main(void) { int Value = 4; cout << "In main, Value is " << Value << endl; cout << "Now calling DoubleNum..." << endl; DoubleNum(Value); cout << "Now back in main. Value is " << Value << endl; } /* Definition of DoubleNum. The parameter RefVar is a reference variable. The value in RefVar is doubled. */ void DoubleNum (int &RefVar) { RefVar *= 2; } Program 6-24 Reference Variable Program Output In main, Value is 4 Now calling DoubleNum... Now back in main. Value is 8

12. /* This program uses reference variables as function parameters*/ #include <iostream.h> /* Function prototypes. Both functions use reference variables as parameters*/ void DoubleNum(int &); void GetNum(int &); void main(void) { int Value; GetNum(Value); DoubleNum(Value); cout << "That value doubled is " << Value << endl; } /* Definition of GetNum. The parameter UserNum is a reference variable. The user is asked to enter a number, which is stored in UserNum. */ void GetNum(int &UserNum) { cout << "Enter a number: "; cin >> UserNum; } /* Definition of DoubleNum. The parameter RefVar is a reference variable. The value in RefVar is doubled. */ void DoubleNum (int &RefVar) { RefVar *= 2; } Program 6-25 Program Output Enter a number: 12 [Enter] That value doubled is 24

13. Reference Argument Warning • Don’t get carried away with using reference variables as function parameters. Any time you allow a function to alter a variable that’s outside the function, you are creating potential debugging problems. Reference variables should only be used as parameters when the situation demands them.

14. Overloaded Functions • C++ uses both the function name and the parameter list to determine which function is being called. • C++ will match the argument list of the function call with the parameter list of the functions defined and find a unique match. Concept - Two or more functions may have the same name as long as their parameter lists are different.

15. /* This program uses overloaded functions */ #include <iostream.h> // Function prototypes int Square(int); float Square(float); void main(void) { int UserInt; float UserFloat; cout.precision(2); cout << "Enter an integer and a floating-point value: "; cin >> UserInt >> UserFloat; cout << "Here are their squares: "; cout << Square(UserInt) << " and " << Square(UserFloat); } */ Definition of overloaded function Square. This function uses an int parameter, Number. It returns the square of Number as an int. */ int Square(int Number) { return Number * Number; } /* Definition of overloaded function Square. This function uses a float parameter, Number. It returns the square of Number as a float.*/ float Square(float Number) { return Number * Number; } Program 6-26 Program Output Enter an integer and floating-point value: 12 4.2 [Enter] Here are their squares: 144 and 17.64

16. The exit and atexit Functions • Must #include stdlib.h to use exit() and atexit function • exit returns and integer: ex. exit(0); • this value is returned to the operating system that your program is running within. • EXIT_FAILURE and EXIT_SUCCESS • atexit registers a function to be called when the exit function is executed: ex. atexit(stop); Concept - exit and atexit provides a mechanism for terminating a program while executing in a function.

17. /* This program shows how the exit function causes a program to stop executing.*/ #include <iostream.h> #include <stdlib.h> // For exit void Function(void); // Function prototype void main(void) { Function(); } /* This function simply demonstrates that exit can be used to terminate a program from a function other than main. */ void Function(void) { cout << "This program terminates with the exit function.\n"; cout << "Bye!\n"; exit(0); cout << "This message will never be displayed\n"; cout << "because the program has already terminated.\n"; } Program 6-30 Program Output This program terminates with the exit function. Bye!

18. /* This program demonstrates the exit function. */ #include <iostream.h> #include <stdlib.h> // For exit #include <ctype.h> // For toupper void main(void) { char Response; cout << "This program terminates with the exit function.\n"; cout << "Enter S to terminate with the EXIT_SUCCESS code\n"; cout << "or F to terminate with the EXIT_FAILURE code: "; cin >> Response; switch (Response) {case 's' : case 'S' :cout << "Exiting with EXIT_SUCCESS.\n"; exit(EXIT_SUCCESS); case 'f' : case 'F' : cout << "Exiting with EXIT_FAILURE.\n"; exit(EXIT_FAILURE);} } Program 6-31 Program Output This program terminates with the exit function. Enter S to terminate with the EXIT_SUCCESS code or F to terminate with the EXIT_FAILURE code: s [Enter] Exiting with EXIT_SUCCESS. Program Output This program terminates with the exit function. Enter S to terminate with the EXIT_SUCCESS code or F to terminate with the EXIT_FAILURE code: f [Enter] Exiting with EXIT_FAILURE.

19. Stubs and Drivers • A stub is a dummy function that can be quickly implemented and called in place of the real function • A driver is program that tests a function by calling it with a range of test data passed in as arguments. Concept – Stubs and Drivers are very helpful tools for testing and debugging programs that use functions

20. Stubs • Functionally decompose your program into individual algorithms and subroutines • Write Stubs that allow your top level functions to continue executing • return static or typical values • Display debug messages • Simply return without doing anything • Replace the stubs with the real functions when you have completed debugging the top level functions Concept – Stubs allow you to focus on the logical flow of a program with out having to write all the code.

21. Switch (choice) { case 1 : Adult (months); break; case 2 : Child (months); break; case 3 : Senior (months); break; case 4 : exit(0); break; default: cout <<"Enter a number"; cout <<" between 1 - 4"; } void Adult (int period) { cout << “You have called the Adult function”; } void Adult (int period) { cout << “You have called the Child function”; } void Adult (int period) { cout << “You have called the Senior function”; } Stubs for Menu Calls

22. Drivers • Develop the function based on the written specification • Write a program that calls the function with various arguments as inputs • In range • Out of range • Exercise each path or branch • Use the calling program to display the results Concept – Drivers allow you to develop functions independent of the calling functions