Software Engineering for Students A Programming Approach

15.9 Garbage collection 215
dangerous because it can lead to major errors (or subtle but dangerous errors). The
pointer is often mentioned in the same sentence as the infamous goto statement as a
potential source for obtuse and error-prone code. A number of issues should be considered
when evaluating a language’s implementation of pointers.
Since the same data object may be referenced through more than one pointer variable,
care must be taken not to create a “dangling” pointer. That is, a pointer which
references a location that is no longer in use. Does the language provide any assistance
in reducing the opportunities for such errors?
The security of pointers is enhanced in such languages as Ada and Java, which
require the programmer to bind a pointer variable to reference only objects of a particular
type. Programs written in such languages as C and C++, which allow pointers to
dynamically reference different types of object, are notoriously awkward to debug.
What provisions (e.g. scoping mechanisms, explicit programmer action or garbage
collection procedures) does the language provide for the reclamation of space which is
no longer referenced by any pointer variable? This issue is discussed below.
In Java, the program has no explicit access to memory addresses and it is therefore
impossible for such a program to make the kind of mistake possible in C++. When a
Java program needs memory, it creates a new object. For example, a program can
instantiate an object of type Button by:
Button aButton = new Button("Press here");
This creates a pointer to the new object aButton. In Java this pointer is termed a
reference, but there is no way in which the Java program can misuse this pointer. For
example, arithmetic is not permitted on a reference, nor can the pointer be used to refer
to an object of another class. (Both these operations are allowed in a C++ program.)
Thus the Java program is prevented from causing a whole class of subtle and dangerous
errors.
15.9 ● Garbage collection
A subtle source of errors can arise when memory is freed (or not) after being allocated
to hold some dynamic data structure. In C++, the programmer explicitly issues a function
call to free memory. The memory manager then adds the retrieved memory to its
pool of available memory; this process is termed garbage collection. When used incorrectly,
two types of errors can arise:
1. memory leaks – memory is no longer in use, but has not been reclaimed by the
memory manager
2. memory corruption (dangling pointer) – memory has been returned from use, but
is still in use.
In a memory leak, a program acquires some memory, uses it, but then fails to
return it for garbage collection. This memory is thereby rendered useless. In a program
that only runs for a short time, the memory is reclaimed when the program