1. CSE 332: C++ functions Review: What = and & Mean In C++ the = symbol means either initialization or assignment –If it’s used with a type declaration, it means initialization –If it’s used without a type declaration, it means assignment int j(7); // j is initialized with value 7 int k = 4; // k is initialized with value 4 j = 3; // j is assigned value 3 In C++ the & symbol also has a similar “dual nature” –If it’s used inside a type declaration, it means a reference (an alias) Arguments to function are always declared along with their types –If it’s used outside a type declaration, it means “address of” int swap (int & i, int & j); // references to int int & s = j; // reference s initialized to refer to j int * p = & j; // pointer p initialized w/ j’s address

2. CSE 332: C++ functions Review: Parameter/Variable Declarations Hint: read parameter and variable declarations right to left int i; “ i is an integer” int & r = i; “ r is a reference to an integer (initialized with i)” int * p; “ p is a pointer to an integer” int * & q = p; “ q is a reference to a pointer to an integer (initialized with p)” Read function declarations inside out “function main takes an integer and an array of pointers to char, and returns an integer” int main (int argc, char * argv[]); “function usage takes a pointer to char, and returns void (nothing)” void usage (char * program_name); “function setstring takes a reference to a (C++) string, and returns void” void setstring (string & s);

3. CSE 332: C++ functions How Function Calls Work A function call uses the “program call stack” 1.Stack frame is “pushed” when the call is made 2.Execution jumps to the function’s code block 3.Function’s code block is executed 4.Execution returns to just after where call was made 5.Stack frame is “popped” (variables in it destroyed) This incurs a (small) performance cost –Copying arguments, other info into the stack frame –Stack frame management –Copying function result back out of the stack frame

4. CSE 332: C++ functions Review: Pass By Value void foo () { int i = 7; baz (i); } void baz (int j) { j = 3; } 7 7 → 3 local variable i (stays 7) parameter variable j (initialized with the value passed to baz, and then is assigned the value 3) Think of this as declaration with initialization, along the lines of: int j = what baz was passed;

5. CSE 332: C++ functions Review: Pass By Reference void foo () { int i = 7; baz (i); } void baz (int & j) { j = 3; } 7 → 3 local variable i j is initialized to refer to the variable that was passed to baz: when j is assigned 3, the passed variable is assigned 3. 7 → 3 again declaration with initialization int & j = what baz was passed; argument variable j

6. CSE 332: C++ functions What About Pointers as By-Value Arguments? void foo () { int i = 7; baz (&i); } void baz (int * j) { *j = 3; } 7 → 3 local variable i dereferencing j gives the location to which it points, so the variable whose address was passed is assigned 3. argument variable j 0x74bead00 dereference operator address-of operator j is initialized with the address (value) that was passed to baz

7. CSE 332: C++ functions What About Passing Pointers By-Reference? void foo () { int i = 7; int j = 4; int *p = &i; baz (p, j); } void baz (int * & q, int & k) { q = &k; } 7 local variable i q references p and k references j: when q is assigned the address of k, the effect is to make p point to j instead of i argument variable q 4 local variable j 0x74bead04 argument variable k 0x74bead00 &i → &k

8. CSE 332: C++ functions Pass By const Reference void foo () { int i = 7; baz (i); } void baz (const int & j) { cout << j << endl; } 7 local variable i j is initialized to refer to the variable that was passed to baz: j can not be changed. 7 again declaration with initialization Const int & j = what baz was passed; and it is read only. argument variable j

9. CSE 332: C++ functions Default Arguments Some functions can take several arguments –Can increase function flexibility –Can reduce proliferation of near-identical functions But, callers must supply all of these arguments –Even for ones that aren’t “important” We can provide defaults for some arguments –Caller doesn’t have to fill these in

10. CSE 332: C++ functions Required vs. Default Arguments Function with required argument // call as foo(2); (prints 2) void foo(int a); void foo(int a) {cout << a << endl;} Function with default argument –Notice only the declaration gives the default value // can call as foo(2); (prints 2) // or can call as foo(); (prints 3) void foo(int a = 3); void foo(int a) {cout << a << endl;}

11. CSE 332: C++ functions Defaults with Multiple Arguments Function with one of two arguments defaulted // can call as foo(2); (prints 2 3) // or can call as foo(2, 4); (prints 2 4) void foo(int a, int b = 3); void foo(int a, int b) {cout << a << “ ” << b << endl;} Same function, with both arguments defaulted // can call as foo(); (prints 1 3) // or can call as foo(2); (prints 2 3) // or can call as foo(2, 4); (prints 2 4) void foo(int a = 1, int b = 3); void foo(int a, int b) {cout << a << “ ” << b << endl;}

12. CSE 332: C++ functions Default Argument Limitations Watch out for ambiguous signatures –foo(); and foo(int a = 2); for example Can only default the rightmost arguments –Can’t declare void foo(int a = 1, int b); Caller must supply leftmost arguments –Even if they’re the same as the defaults

13. CSE 332: C++ functions Varying Parameters initializer_list parameters; void foo(initializer_list coffee){ for (auto beg = coffee.begin(); beg != coffee.end(); ++beg) { cout << *beg << “ ”; } cout << endl; } //print out all 4 coffees foo(“latte”, “mocha”, “eggnog latte”, “peppermint mocha”); //print out only 2 coffees foo(“latte”, “mocha”);

14. CSE 332: C++ functions Function Overload // can call errMsg with 1 or 2 integers or a string void errMsg(int & errCode) {cout << “Error code is: ” << errCode<< endl;} void errMsg(const int & errCode) {cout << “Error code is: ” << errCode<< endl;} void errMsg(int & errCode, string msg) {cout << “Error --” << msg << “Error code: ” errCode << endl;} Void errMsg(string msg) {cout << “Error --” << msg << endl;} int err5 = 5; err1 = 1; const int outOfRange = 3; errMsg (err5); errMsg (err1, “can’t open file”); errMsg (“dividing by 0”); errMsg (outOfRange);