Understanding User-Defined Functions: Passing by Value and Reference in C++

1. User-Defined Functions (cont’d) - Reference Parameters

2. Outline • Exercise • Passing by value • Scope of variables • Reference parameters (section 6.1) CSCE 106

3. Tracing Exercise #include <iostream> using namespace std; int Blend( int red, int green ); // prototype void main() { int red = 5, blue = 3; blue = Blend(blue, red); cout << red << ' ' << blue << '\n'; blue = Blend(red, blue); cout << red << ' ' << blue << '\n'; } int Blend( int red, int green ) // parameters passed by value { int yellow; // local variable in Blend function cout << “enter Blend “ << red <<‘ ‘ << green << ‘\n’; yellow = red + green; cout << “leave Blend “ << red <<‘ ‘ << green << ‘\n’; return (yellow + 1); } Execution CSCE 106

4. Passing by Value Blend function data area (1st call) main function data area formal arguments: red 3 green 5 Local arguments: yellow 8 actual arguments: red 5 blue 3 CSCE 106

5. Tracing Exercise (cont’d) main Blend (1st call) Blend (2nd call) Output: enter Blend 3 5 leave Blend 3 5 5 9 enter Blend 5 9 leave Blend 5 9 5 15 CSCE 106

6. Scope of Variables • Scope - where a particular meaning of a variable identifier is visible or can be referenced • Local - can be referred to only within a program segment or function • In a program segment (localized declarations of variables) for(int i = 1; i <= 10; ++i) cout<< “*”; • Commonly used for loop control variables • Declared at point of first reference • Value has meaning (i.e. can be referenced) only inside loop segment. CSCE 106

7. Scope of Variables (cont’d) • In a function this applies to • formal argument names • constants and variables declared within the function • Global - can be referred to within all functions • useful especially for constants • must be used with care CSCE 106

8. Listing 3.15Outline of program for studying scope of variables CSCE 106

9. Scope of Variables (cont’d) • Global variables MAX & LIMIT are visible to main, one, funTwo functions • Local variable localVar in main function visible only to main function • Local variables anArg, second & oneLocal in one function are visible only to one function • Local variables one, anArg & localVar in funTwo function are visible only to funTwo function CSCE 106

10. Passing by Reference Example #include <iostream> using namespace std; int Blend( int& red, int green ); // prototype void main() { int red = 5, blue = 3; Blend(blue, red); cout << red << ' ' << blue << '\n'; Blend(red, blue); cout << red << ' ' << blue << '\n'; } void Blend(int& red, int green) // green parameter passed by value, // while red parameter passed by reference { int yellow; // local variable in Blend function cout << “enter Blend “ << red <<‘ ‘ << green << ‘\n’; yellow = red + green; cout << “leave Blend “ << red <<‘ ‘ << green << ‘\n’; red = yellow + 1; } CSCE 106

11. Passing by Reference Blend function data area (1st call) main function data area formal arguments: red address of blue green 5 Local arguments: yellow 8 actual arguments: red 5 blue 3 CSCE 106

12. Passing by Reference Example (cont’d) main Blend (1st call) Blend (2nd call) Output: enter Blend 3 5 leave Blend 3 5 5 9 enter Blend 5 9 leave Blend 5 9 15 9 CSCE 106

13. User Defined Functions Can: • return no value • type void • return exactly one value • function type • return statement • return more than one value • type void or function type • reference parameters CSCE 106

14. Reference Parameters • Formal parameter data type directly followed by & indicate a parameter passed by reference CSCE 106

15. Listing 6.1Function to compute sum and average CSCE 106

16. Listing 6.1Function to compute sum and average (continued) CSCE 106

17. User-Defined Function computeSumAve • Two function input parameters • num1, num2 • Two function output parameters • sum, average • & indicates function output parameters • Function call computeSumAve(x, y, sum, mean); CSCE 106

18. Argument Correspondence Corresponds to Formal Argument num1 (fn. input) num2 (fn. input) sum (fn. output) average (fn. output) Actual Argument x y sum mean CSCE 106

19. Call-by-Value and Call-by-Reference Parameters • & between type and identifier defines a parameter as function output mode (pass by reference) • no & in a parameter’s declaration identifies parameter as fuction input mode (pass by value) • Compiler uses information in parameter declaration list to set up correct argument-passing mechanism CSCE 106

20. Figure 6.1Data areas after call to computeSumAve (before execution) CSCE 106

21. Figure 6.2Data areas after execution of computeSumAve CSCE 106

22. Notes on Call-by-Reference • Place the & only in the formal parameter list - not in the actual parameter list • Place the & also in the prototype: void computeSumAve(float, float, float&, float&); • Note that this is a void function CSCE 106

23. When to Use a Reference or a Value Parameter • If information is to be passed into a function and doesn’t have to be returned or passed out of the function, then the formal parameter representing that information should be a value parameter (function input parameter). • If information is to be returned to the calling function through a parameter, then the formal parameter representing that information must be a reference parameter (function output parameter). CSCE 106

24. When to Use a Reference or a Value Parameter (cont’d) • If information is to be passed into a function, perhaps modified, and a new value returned, then the formal parameter representing that information must be a reference parameter (input/output parameter) CSCE 106

25. Next lecture we will talk more about Value and Reference Parameters CSCE 106