1. Memory and C++ Pointers

2.  C++ objects and memory  C++ primitive types and memory  Note: “primitive types” = int, long, float, double, char, … January 2010Greg Mori2

3. // Java code // in function, f … int arr[]; arr = getOrdArray(5); // … …arr f …null … n getOrdArray 5 stack (static) public int[] getOrdArray(int n){ int arr[] = new int[n]; for (int i = 0; i < arr.length; ++i){ arr[i] = i * 2 + 1; } return arr; } heap (dynamic) 13579 arr January 20103Greg Mori

4. // in function, f … // C++ code int *arr; arr = getOrdArray(5); // … …arr f …null … n getOrdArray 5 stack int * getOrdArray(int n){ int *arr = new int[n]; for (int i = 0; i < n; ++i){ arr[i] = i * 2 + 1; } return arr; } heap 13579 arr

5. January 2010Greg Mori5

6.  In C++:  Both primitive types and objects can be allocated either on the stack or on the heap  Both primitive type and object value and reference variables are allowed ▪Hence, there needs to be C++ notation to distinguish between the two January 2010Greg Mori6

7.  There are two ways to refer to things in C++  The first is pointers  The * character is used to denote a pointer January 2010Greg Mori7 // n is a Node object Node n; // n is a pointer to a Node object Node *n; // i is an integer variable int i; // i is pointer to an integer variable int *i;

8.  Variables in methods are allocated in stack memory  C++ uses the keyword new to allocate space in the heap Greg Mori8 // n is a Node object, in stack Node n; // np is a pointer to a Node variable, np is in stack Node *np; // new creates a Node object, in heap // np points to this object np = new Node(); January 2010

9. nnp f null … stack heap Node object // n is a Node object, in stack Node n; // np is a pointer to a Node variable, np is in stack Node *np; // new creates a Node object, in heap // np points to this object np = new Node(); January 20109Greg Mori

10.  In C++, you can do the same with primitive types, e.g.: int Greg Mori10 // i is an integer variable, in stack int i; // ip is pointer to an integer variable, in stack int *ip; // new creates an integer variable, in heap ip = new int; January 2010

11. iip f null … stack heap ? // i is an integer variable, in stack int i; // ip is pointer to an integer variable, in stack int *ip; // new creates an integer variable, in heap ip = new int; January 201011Greg Mori

12.  How do we access the contents of the thing a pointer points to?  This is called “dereferencing” a pointer ▪The * notation is used again January 2010Greg Mori12 // ip is pointer to an integer variable, in stack int *ip; // new creates an integer variable, in heap ip = new int; // *ip is the contents of the new integer *ip = 5; int i = *ip;

13. iip f null … stack heap ? // ip is pointer to an integer variable, in stack int *ip; // new creates an integer variable, in heap ip = new int; // *ip is the contents of the new integer *ip = 5; int i = *ip; 5 5 January 201013Greg Mori

14.  There is a shorthand for following pointers and accessing object methods / variables  Uses the -> characters January 2010Greg Mori14 // np is a pointer to a Node variable, np is in stack // new creates a Node object, in heap // np points to this object Node *np = new Node(5); // both of these run the getData method on the Node object int i = (*np).getData(); int i = np -> getData();

15.  C++ allows one to obtain the address of an existing object / variable  This is called “referencing” ▪Uses the & operator (“address of”) January 2010Greg Mori15 // i is an integer variable, in stack int i; // ip is pointer to an integer variable, in stack int *ip; // ip refers to the memory where i resides ip = &i;

16. iip f null … stack heap 5 // i is an integer variable, in stack int i; // ip is pointer to an integer variable, in stack int *ip; // ip refers to the memory where i resides ip = &i; *ip = 5; January 201016Greg Mori

17. January 2010Greg Mori17

18.  Java does Garbage Collection for you  C++ you need to do it yourself  If you don’t want an object any longer, call delete ▪If it’s an array, call delete [ ], which calls delete on all array elements  Bugs result if mistakes are made January 2010Greg Mori18

19. np f null … stack heap // np is a pointer to a Node variable, np is in stack // new creates a Node object, in heap, np points to this object Node *np = new Node(); // delete frees the heap memory referred to by np delete np; Node object January 201019Greg Mori

20.  In C++ objects can be in stack memory (unlike Java)  Delete is automatically called on them when a method returns  Don’t manually delete them January 2010Greg Mori20

21. // in function, f … Node n; g(); // … … n f … null … stack (static) void g (){ Node m; Node r; } heap (dynamic) nodeObj m g r … … delete is called on m and r January 201021Greg Mori

22.  Two major bug types can result if mistakes are made  Memory leaks  Dangling pointers January 2010Greg Mori22

23.  Memory leaks occur if there is heap memory which is not pointed to by any variable (at any scope)  No pointers to the memory in the current method nor any below it on the stack ▪Including global variables  There is no way to access the memory  The system will not use the memory for another object/variable  Eventually, you might run out of memory January 2010Greg Mori23

24. // in function, f … g(); // … … f … … stack (static) void g (){ Node *m = new Node(); } heap (dynamic) m g … … This memory is not accessible Node object January 201024Greg Mori

25. // in function, f … Node *n; n = g(); // … … f … … stack (static) Node * g (){ Node *m = new Node(); return m; } heap (dynamic) m g … … Node object n January 201025Greg Mori

26.  Once you call delete, or a method returns, memory is gone  If you try to refer to this memory you will get an error*  If it is being used by something else ▪Which will likely happen, but the error symptoms can be confusing January 2010Greg Mori26

27. // in function, f … int *ip = new int; int *jp = ip; *ip = 5 delete ip; // … *jp = 6; … f … … stack (static) heap (dynamic) This memory is not available 5 ipjp January 201027Greg Mori

28. // in function, f … Node *n; n = g(); // … … f … … stack (static) Node * g (){ Node m; return &m; } heap (dynamic) m g nodeObj … … n This memory is not available January 201028Greg Mori

29. January 2010Greg Mori29

30.  There are two ways to do refer to things in C++:  Pointers ▪Which we just did  References January 2010Greg Mori30

31.  C++ also has references in addition to pointers  References can be thought of as a restricted form of pointer  A few differences, key ones: ▪References cannot be NULL, pointers can ▪References cannot be reassigned, pointers can ▪This means they must be assigned at declaration time ▪Different syntax for access ▪Leads to cleaner code (but perhaps harder to understand) January 2010Greg Mori31

32.  The & character is used to denote references ▪Yes, the same character as address-of January 2010Greg Mori32 // n is a Node object, in stack Node n; // nr is a reference to a Node object, in stack // nr refers to the object n Node &nr = n;

33. nnr f null … stack heap Node object // n is a Node object, in stack Node n; // nr is a reference to a Node object, in stack // nr refers to the object n Node &nr = n; January 201033Greg Mori

34.  References are used with same syntax as Java  Use the. character January 2010Greg Mori34 // n is a Node object, in stack Node n; // nr is a reference to a Node object, in stack // nr refers to the object n Node &nr = n; // both of these call the getData() method on the Node int i = n.getData(); int i = nr.getData();

35.  Often used for function / method parameters  “Pass by reference” vs. “Pass by value” 35 void foo (int x) { x=2; } int main () { int y = 4; foo(y); cout << y; return 0; } void foo (int& x) { x=2; } int main () { int y = 4; foo(y); cout << y; return 0; }

36. January 2010Greg Mori36

37.  Where do variables go?  C++ ▪If it’s a variable declaration, in stack ▪If it’s a new statement, in heap ▪In C++, both primitive types and objects can go in either stack or heap January 2010Greg Mori37

38.  How do I refer to variables?  C++ ▪Pointers ▪* notation  * in type to denote "it's a pointer to a"  * in usage to denote "follow this pointer to" ▪References ▪& notation January 2010Greg Mori38

39.  How do I manage memory?  C++ ▪Call delete manually (or delete [ ] for arrays) ▪Watch out for bugs  Memory leaks (forgot to delete)  Dangling pointers/references (deleted when you shouldn't have) January 2010Greg Mori39

40.  Carrano  Ch. 4.1 January 2010Greg Mori40