Object Lifetime and Pointers

Object Lifetime and Pointers various languages…

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

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

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

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

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)

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

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

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)

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

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

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;

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.

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

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

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

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++.

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.

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

Object Lifetime and Pointers