Object Lifetime and Pointers

1. Object Lifetime and Pointers various languages…

2. Why do we care? Could affect performance Could affect reliability Could affect language choice

3. Object lifetime The lifetime of a variable is the time during which it is bound to a particular memory cell Ruby built-in objects created when values assigned (e.g., x=5) Other classes created with new factory methods also create objects Ruby uses garbage collection to destroy objects that are no longer reachable

4. Variables by Lifetime: Static void myFn() { static int count=0; count++; cout << count; } myFn(); myFn(); myFn(); Quick Ex: Trace! Static • bound to memory cells before execution begins • remains bound to the same memory cell throughout execution • all FORTRAN 77 variables, C static variables (not C++ class variables) • Advantages: • efficiency (direct addressing) • history-sensitive subprogram support • Disadvantage: • lack of flexibility (no recursion) • storage can't be shared among subprograms

5. Where is static stored? p temp temp2 command-line args & environment variables high address stack heap initialized by exec (block started by symbol) uninitialized data (BSS) initialized data text read from program file by exec low address From: http://stackoverflow.com/questions/93039/where-are-static-variables-stored-in-c-c Assuming C/C++ DATA segment subdivided into parts when loaded into memory

6. Variables by Lifetime: Stack Dynamic void myFn2(intparm) { int temp; … int temp2; } How? Compared to what? parm temp temp2 sp local Stack-dynamic • Created when execution reaches code • Allocated from the run-time stack • Variables may be allocated at the beginning of a method, even though declarations may be spread throughout • Advantages: • allows recursion • conserves storage • Disadvantages: • Overhead of allocation and deallocation (not too bad, since all memory allocated/ deallocated together) • Subprograms cannot be history sensitive, • Inefficient references (indirect addressing)

7. Variables by Lifetime: Explicit Heap Dynamic void myFn3() { int* nums = new int[5]; … } public void myFn4() { Point point = new Point(); } Explicit heap-dynamic • Allocated (and deallocated) by explicit directives during runtime • new/delete, malloc/free etc. • Accessed only through pointers or references • Dynamic objects in C++, all objects in Java • Advantage: • provides for dynamic storage management • Disadvantages: • inefficient and unreliable • C# methods that define a pointer must include reserved word unsafe

8. Variables by Lifetime: Implicit Heap Dynamic list = [2, 4.33, 6, 8]; Which lifetimes are used in Ruby? Implicit heap-dynamic • Allocation and deallocation caused by assignment statements • No new/delete… these are implied! • all variables in APL; all strings and arrays in Perl and JavaScript • Advantage: • flexibility • Disadvantages: • Inefficient because all attributes are dynamic • loss of error detection

9. Pointers vs References In C++, is it necessary for all pointers to access heap? A pointer type variable has a range of values that consists of memory addresses and a special value, nil or NULL Provide a way to manage dynamic memory A pointer can be used to access a location in the area where storage is dynamically created (usually called a heap)

10. Pointer Operations – (review) • Two fundamental operations: assignment and dereferencing • Assignment is used to set a pointer variable’s value to some useful address • Dereferencing yields the value stored at the location represented by the pointer’s value • Dereferencing can be explicit or implicit • C++ uses an explicit operation via * j = *ptr; sets j to the value located at ptr

11. Pointer Assignment Illustrated (review) Provide the power of indirect addressing (access variable via address stored in another variable, may not be dynamic) ptr = new int; // assignment *ptr = 206; // dereferencing j = *ptr; // dereferencing

12. Pointer Arithmetic in C and C++ 0 1 2 3 4 5 6 7 8 stuff 0x100 p 0x100 p is an aliasfor stuff *(p+5) is equivalent tostuff[5] and p[5] *(p+i) is equivalent tostuff[i] and p[i] float stuff[100]; float *p; p = &stuff; inti=3;

13. Pointers in C and C++: void* • Domain type need not be fixed (void *) • void * can point to any type. Use type casts. • void * cannot be de-referenced • void * often used in C to pass as arguments. • In C++, generally better to use templates so compiler can do appropriate type checking.

14. Problems with Pointers (review) Point p = new Point(3,4); delete p; // dangling – p still has address! cout << p.getX(); // bad!! • Dangling pointers (dangerous) • A pointer points to a heap-dynamic variable that has been de-allocated • may have been reallocated • values no longer meaningful • writing to it could cause storage manager to fail. • Example

15. Problems with Pointers (review) int[] p = new int[5000]; p = new int[10000]; • Memory Leak(dangerous) • Memory has not been deleted (returned to heap manager) • No variables contain the address (so not accessible) • When is this a problem? • Example

16. Reference Types • void myFun(int &y) • { • y = y + 1; • } What does this mean, “constant pointer”? • C++ includes a special kind of pointer type called a reference type that is used primarily for formal parameters • Constant pointer that is always implicitly dereferenced

17. Reference Types (point of confusion) • Java extends C++’s reference variables and allows them to replace pointers entirely • References refer to object instances – not necessarily constant • Implicitly derefenced (i.e., no * required) • No pointer arithmetic • Java does NOT have pointers! But references as implemented in Java have many similarities. • C# includes both the references of Java and the pointers of C++.

18. What about Ruby? What problem does garbage collection solve? http://stackoverflow.com/questions/7208768/is-it-possible-to-use-pointers-in-ruby Does Ruby have references or pointers? Ruby has garbage collection.

19. Objects s1 = "Wazzup!" s2 = s1 s2[-1] = "?" puts s1 • classes covered in detail later • Not covered: frozen or tainted objects Compare to Java/C++ Ruby is pure object-oriented BasicObject is superclass Work with object references