CS 103 Unit 13 Slides C++ References Mark Redekopp 2 Swap Two - PowerPoint PPT Presentation

1 CS 103 Unit 13 Slides C++ References Mark Redekopp

2 Swap Two Variables int main() { int x=5,y=7; • Classic example of issues with local swapit(x,y); cout <<“x,y=“ << x << “,” << variables: y << endl; } – Write a function to swap two variables void swapit(int x, int y) { int temp; • Pass-by-value doesn’t work temp = x; x = y; – Copy is made of x,y from main and y = temp; } passed to x,y of swapit…Swap is program output: x=5,y=7 performed on the copies int main() • Pass-by-reference (pointers) does { int x=5,y=7; swapit(&x,&y); work cout <<“x,y=“ << x << “,” << y << endl; } – Addresses of the actual x,y variables in void swapit(int *x, int *y) main are passed { int temp; – Use those address to change those temp = *x; physical memory locations *x = *y; *y = temp; } program output: x=7,y=5

3 C++ Reference Variables • So you want a function to actually modify a variable from another function but you don’t like pointers and they confuse you? – Too bad. Don’t give up! You CAN understand pointers…keep working at it – BUT… – You can also use C++ Reference variables • C++ reference variables essentially pass arguments via pointer/address but use the syntax of pass-by- value (i.e. no more de-referencing)

4 Using C++ Reference Variables int main() { • To declare a reference variable, use the int y = 3; doit(&y); //address-of oper. ‘&’ operator in a declaration! cout << y << endl; return 0; – Poor choice by C++ because it is confusing since ‘&’ is } already used for the ‘address of operator’ when used int doit(int *x) { in an expression (i.e. non-declaration) *x = *x - 1; Behind the scenes the compiler will essentially • return *x; } access variable with a pointer Using pointers But you get to access it like a normal variable • int main() without dereferencing { int y = 3; Think of a reference variable as an alias • doit(y); cout << y << endl; return 0; With References With References With Pointers } - Physically - Logically int doit(int & x) // Ref. dec. { y y y x x = x - 1; 0x1a0 0x1a0 return x; 3 3 3 } x x Using C++ References 0x1a0 0x1a0 Output: ‘2’ in both programs

5 Swap Two Variables • Pass-by-value => Passes a copy • Pass-by-reference => – Pass-by-pointer/address => Passes address of actual variable – Pass-by-reference => Passes an alias to actual variable int main() int main() int main() { { { int x=5,y=7; int x=5,y=7; int x=5,y=7; swapit(x,y); swapit(&x,&y); swapit(x,y); cout <<“x,y=“<< x<<“,”<< y; cout <<“x,y=“<< x<<“,”<< y; cout <<“x,y=“<< x<<“,”<< y; cout << endl; cout << endl; cout << endl; } } } void swapit(int x, int y) void swapit(int *x, int *y) void swapit(int &x, int &y) { { { int temp; int temp; int temp; temp = x; temp = *x; temp = x; x = y; *x = *y; x = y; y = temp; *y = temp; y = temp; } } } program output: x=5,y=7 program output: x=7,y=5 program output: x=7,y=5

6 When to Use References class GradeBook{ • Whenever you want to public: int grades[8][100]; }; actually modify an input int main() parameter/argument (i.e. { GradeBook gb; a local variable from ... double average = process_it(gb); return 0; another function) } double process_it(GradeBook& mygb) • Great for passing big { double sum = 0; for(int i=0; i < 8; i++) struct or class objects for(int j=0; j < 100; j++) sum += mygb.grades[i][j]; – Because no copy will be mygb.grades[0][0] = 91; made, (pass-by-value would have wasted time sum /= (8*100); return sum; copying contents to new } memory)

7 Const arguments • An aside: class GradeBook{ public: int grades[8][100]; – If we want an extra safety }; precaution for our own int main() { mistakes, we can declare GradeBook gb; arguments as 'const' ... double average = process_it(gb); – The compiler will produce an return 0; } error to tell you that you have double process_it(const GradeBook &mygb) written code that will modify { double sum = 0; the object you said should be for(int i=0; i < 8; i++) for(int j=0; j < 100; j++) constant sum += mygb.grades[i][j]; – Doesn’t protect against back- mygb.grades[0][0] = 91; doors like pointers that // modification of mygb // compiler will produce ERROR! somehow point at these data objects. sum /= (8*100); return sum; }

8 Vector/Deque/String Suggestions • When you pass a vector, deque, #include <iostream> #include <vector> or even C++ string to a function a using namespace std; int main() deep copy will be made which { vector<int> my_vec; takes time for(int i=0; i < 5; i++){ // my_vec[i] = i+50; // doesn’t work my_vec.push_back(i+50); • Copies may be desirable in a } situation to make sure the // can myvec be different upon return? do_something1(myvec); function alter your copy of the // can myvec be different upon return? vector/deque/string do_something2(myvec); return 0; • But passing by const reference } void do_something1( vector<int> v ) saves time and provide the same { // process v; security. } void do_something2( const vector<int>& v ) { // process v; }

9 Reference Gotchas! • Returning a reference to class GradeBook{ public: int grades[8][100]; a dead variable (i.e. a }; int main() local variable of a { GradeBook gb; function that just double& average = process_it(gb); cout << “Avg: “ << average << endl; // Possible seg. fault / prog. crash completed) return 0; } double& process_it(const GradeBook &mygb) • avg was a local variable { double avg = 0; for(int i=0; i < 8; i++) and thus was deallocated for(int j=0; j < 100; j++) avg += mygb.grades[i][j]; when process_it avg /= (8*100); completed return avg; // reference to avg // is returned... }

10 MORE C++ REFERENCE FACTS

11 Using C++ References • Mainly used for parameters, but can int main() use it within the same function { int y = 3, *ptr; ptr = &y; // address-of • A variable declared with an ‘int &’ // operator doesn’t store an int, but stores a int &z; // NO! must assign reference/alias for an actual integer int & x = y; // reference // declaration • MUST assign to the reference variable // we’ve not copied // y into x when you declare it. // we’ve created an alias x++; // y just got incr. With References With References With Pointers cout << y << endl; - Physically - Logically return 0; } y y y x 0x1a0 0x1a0 3 3 3 ptr x 0x1a0 0x1a0 Output: y=4 in both programs