156	Part II Understanding the C# Language

Note You can use the ref and out modifiers on reference type parameters as well as on value type parameters. The effect is exactly the same. The parameter becomes an alias for the argument. If you reassigned the parameter to a newly constructed object, you would also actually be reassigning the argument to the newly constructed object.

How Computer Memory Is Organized

Computers use memory to hold programs being executed and the data that these programs use. To understand the differences between value and reference types, it is helpful to understand how data is organized in memory.

Operating systems and runtimes frequently divide the memory used for holding data in two

separate chunks, each of which is managed in a distinct manner. These two chunks of memory are traditionally called the stack and the heap. The stack and the heap serve very different

purposes:

QWhen you call a method, the memory required for its parameters and its local variables is always acquired from the stack. When the method finishes (because it either returns or throws an exception), the memory acquired for the parameters and local variables is automatically released back to the stack and is available for reuse when another method is called.

QWhen you create an object (an instance of a class) by using the new keyword, the memory required to build the object is always acquired from the heap. You have seen that the same object can be referenced from several places by using reference variables. When the last reference to an object disappears, the memory used by the object becomes available for reuse (although it might not be reclaimed immediately). Chapter 14 includes a more detailed discussion of how heap memory is reclaimed.

Note All value types are created on the stack. All reference types (objects) are created on the heap (although the reference itself is on the stack). Nullable types are actually reference types, and they are created on the heap.

The names stack and heap come from the way in which the runtime manages the memory:

QStack memory is organized like a stack of boxes piled on top of one another. When a method is called, each parameter is put in a box that is placed on top of the stack. Each local variable is likewise assigned a box, and these are placed on top of the boxes already on the stack. When a method finishes, all its boxes are removed from the stack.

Chapter 8 Understanding Values and References

157

QHeap memory is like a large pile of boxes strewn around a room rather than stacked neatly on top of each other. Each box has a label indicating whether it is in use. When a new object is created, the runtime searches for an empty box and allocates it to the object. The reference to the object is stored in a local variable on the stack. The runtime keeps track of the number of references to each box (remember that two variables can refer to the same object). When the last reference disappears, the runtime marks the box as not in use, and at some point in the future it will empty the box and make it available for reuse.

Using the Stack and the Heap

Now let’s examine what happens when the following Method is called:

void Method(int param)

{

Circle c;

c = new Circle(param);

...

}

Suppose the value passed into param is the value 42. When the method is called, a block of memory (just enough for an int) is allocated from the stack and initialized with the value 42. As execution moves inside the method, another block of memory big enough to hold a refer-

ence (a memory address) is also allocated from the stack but left uninitialized (this is for the Circle variable, c). Next, another piece of memory big enough for a Circle object is allocated from the heap. This is what the new keyword does. The Circle constructor runs to convert this raw heap memory to a Circle object. A reference to this Circle object is stored in the variable

c. The following graphic illustrates the situation:

At this point, you should note two things:

QAlthough the object is stored on the heap, the reference to the object (the variable c) is stored on the stack.

QHeap memory is not infinite. If heap memory is exhausted, the new operator will throw an OutOfMemoryException and the object will not be created.