various languages…

 Could affect performance  Could affect reliability  Could affect language choice

 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

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 void myFn() { static int count=0; count++; cout << count; } myFn(); Quick Ex: Trace! Discuss bullets

Assuming C/C++  DATA segment subdivided into parts when loaded into memory From: p temp temp2 high address low address command-line args & environment variables stack heap uninitialized data (BSS) initialized by exec (block started by symbol) initialized data text read from program file by exec

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) void myFn2(int parm) { int temp; … int temp2; } parm temp temp2 sp local How? Compared to what?

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 void myFn3() { int* nums = new int[5]; … } public void myFn4() { Point point = new Point(); }

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 list = [2, 4.33, 6, 8]; Which lifetimes are used in Ruby?

 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) In C++, is it necessary for all pointers to access heap?

 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 C++ also does implicit dereferencing void myFun(int& x) { x = 5; } What about Java?

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

float stuff[100]; float *p; p = &stuff; int i=3; p is an alias for stuff *(p+5) is equivalent to stuff[5] and p[5] *(p+i) is equivalent to stuff[i] and p[i] stuff 0x100 p 0x

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

 Do you remember the difference between a dangling pointer and a memory leak?

 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 Point p = new Point(3,4); delete p; // dangling – p still has address! cout << p.getX(); // bad!!

 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 int[] p = new int[5000]; p = new int[10000];

 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 void myFun(int &y) { y = y + 1; } What does this mean, “constant pointer”?

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

 Does Ruby have references or pointers?  Ruby has garbage collection. What problem does garbage collection solve?