Understanding Data Structures: Call by Value/Reference in C++

1. Short C++ Review CS 302 – Data Structures

2. Call by value/reference

3. Formal Parameters • The argument names in the function header are referred to as formal parameters. int FindMax(int x, int y) { int maximum; if(x>=y) maximum = x; else maximum = y; return maximum; } x,yare called “formal parameters”

4. Actual Parameters • The argument names in the function call are referred to as actual parameters int FindMax(int, int); // function prototype int main() { int firstnum, secnum, max; cout << "\nEnter two numbers: "; cin >> firstnum >> secnum; max=FindMax( firstnum, secnum); // the function is called here cout << "The maximum is " << max << endl; return 0; } firstnum,secnumare called “actual parameters”

5. Calling a function by value void newval(float, float); // function prototype int main() { float firstnum, secnum; cout << "Enter two numbers: "; cin >> firstnum >> secnum; newval(firstnum, secnum); cout << firstnum << secnum << endl; return 0; } void newval(float xnum, float ynum) { xnum = 89.5; ynum = 99.5; } Formal parameters receive a “copy” of the actual parameters!

6. Calling a function by reference void newval(float&, float&); // function prototype int main() { float firstnum, secnum; cout << "Enter two numbers: "; cin >> firstnum >> secnum; newval(firstnum, secnum); cout << firstnum << secnum << endl; return 0; } void newval(float& xnum, float& ynum) { xnum = 89.5; ynum = 99.5; } Formal parameters become an “alias” of the actual parameters!

7. Static vs Dynamic Array Allocation

8. 1D Static Array Allocation short arr[6]; • &arr[i] := &arr[0] + (i * sizeof(short)) offset

9. Static 1D arrays as function arguments float find_average(int [], int); void main() { const numElems = 5; int arr[numElems] = {2, 18, 1, 27, 16}; cout << "The average is " << find_average(arr, numElems) << endl; }

10. Static 1D arrays as function arguments float find_average(int vals[], int n) { int i; float avg; avg=0.0; for(i=0; i<n; i++) avg += vals[i]; avg = avg/n; return avg; }

11. 2D Static Array Allocation • Static 2D arrays are always stored in memory as 1D arrays in contiguous memory. short arr2D[3][4];

12. Static 2D arrays as function arguments float find_average(int [][2], int, int); void main() { const numRows = 2; const numCols = 2; int arr2D[numRows][numCols] = {2, 18, 1, 27}; float average; average = find_average(arr2D, numRows, numCols); cout << "The average is " << average << endl; }

13. Static 2D arrays as function arguments float find_average(int vals[][2], int n, int m) { int i,j; float avg; avg=0.0; for(i=0; i<n; i++) for(j=0; j<m; j++) avg += vals[i][j]; avg = avg/(n*m); return avg; }

14. Dynamic 1D Array Allocation/ Deallocation int *arr; arr = newint[N]; delete [] arr;

15. Dynamic 1D arrays as function arguments float find_average(int *, int); void main() {  int *arr, numElems; float average; cin << numElems; arr = new int[numElems]; // initialize array  average = find_average(arr, numElems); cout << "The average is " << average << endl; }

16. Dynamic 1D arrays as function arguments float find_average(int *vals, int n) { int i; float avg; avg=0.0; for(i=0; i<n; i++) avg += vals[i]; avg = avg/n; return avg; }

17. Dynamic 2D Array Allocation arr[2][6] 480 482 484 486 488 490

18. Dynamic 2D Array Allocation/Deallocation int **arr2D; arr2D = new int* [numRows]; // allocation  for(i=0; i<numRows; i++) arr2D[i] = new int[numCols]; for(i=0; i<numRows; i++) // deallocation delete [] arr2D[i]; delete [] arr2D;

19. Dynamic 2D arrays as function arguments float find_average(int **, int, int); void main() {  int **arr2D; float average; arr2D = new int*[numRows]; for(i=0; i<numRows; i++) arr2D[i] = new int[numCols]; // initialize array average = find_average(arr2D, numRows, numCols); cout << "The average is " << average << endl; }

20. 2D Dynamic arrays as function arguments float find_average(int **vals, int n, int m) { int i, j; float avg; avg=0.0; for(i=0; i<n; i++) for(j=0; j<m; j++) avg += vals[i][j]; avg = avg/(n*m); return avg; }

21. Object Composition

22. class rectangle { private: float height; float width; int xpos; int ypos; public: rectangle(float, float); // constructor void draw(); void posn(int, int); void move(int, int); }; rectangle::rectangle(float h, float w) { height = h; width = w; xpos = 0; ypos = 0; }

23. Object Composition: objects as members of classes class rectangle { private: float height; float width; int xpos; int ypos; properties pr; public: rectangle(float, float, int, int ); // constructor void draw(); void posn(int, int); void move(int, int); }; A class may have objects of other classes as members.

24. Object Composition (cont.) class properties { private: int color; int line; public: properties(int, int); // constructor }; properties::properties(int c, int l) { color = c; line = l; }

25. Object Composition (cont.) rectangle::rectangle(float h, float w, int c, int l):pr(c, l) { height = h; width = w; xpos = 0; ypos = 0; }; void main() { rectangle rc(3.0, 2.0, 1, 3); ……… }

26. Deep vs shallow copy

27. #include <iostream.h> #include <string.h> class string { private: char *s; int size; public: string(char *); ~string(); void print(); void copy(char *); }; void string::print() { cout << s << endl; } Note: no user defined copy constructor provided! void string::copy(char *c) { strcpy(s, c); }

28. Constructor/Destructor string::string(char *c) // constructor { size = strlen(c); s = new char[size+1]; strcpy(s,c); } string::~string() // destructor { delete []s; }

29. void main() { string str1("George"); string str2(str1); // shallow copy! str1.print(); // what is the output ? str2.print(); str2.copy("Mary"); str1.print(); // what is the output now ? str2.print(); }

30. Copy-Constructor string::string(const string& old_str) { size = old_str.size; s = new char[size+1]; strcpy(s,old_str.s); }

31. Overloading Assignment

32. Overloading Assignment • Default overloading is not enough for classes with pointer members (i.e., shallow copy) class string { private: char *s; int size; public: string(char *); ~string(); void operator=(string&); void print(); void copy(char *); };

33. Overloading Assignment void string::operator=(string& old_str) { delete [] s; //release previously assigned memory size = old_str.size; s = new char[size+1]; //assign new memory strcpy(s, old_str.s); }

34. Handling multiple assignments(e.g., x=y=z;) string& string::operator=(const string& old_str) { if (this != &old_str) { delete [] s; size = old_str.size; s = new char[size+1]; strcpy(s, old_str.s); } return *this; // return ref for multiple assignment }

35. Difference between copy constructor and assignment • The copy constructor creates a new object. • The assignment operator works on an already valid object.