The best thing about pointers (and objects, for that matter) is that the
heap data they reference is global and persistent, but doesn't suffer
from the limitations of the common block.  In fact, the treadworn common
block had new life breathed into by pointers: finally something to stick
into it which doesn't bloat your code and cause redefinition headaches.  

One feature I use all the time with pointers is as follows: when saving
a data snapshot (actually, an object!) of interest, I can "detach" those
fragents of member data I don't need or want to save.  Simply do
something like:

saved_ptr=self.BigAndUselessDataPtr ; detach
self.BigAndUselessDataPtr=ptr_new() ; a null pointer
save, self
self.BigAndUselessDataPtr=saved_ptr  ; reattach

I actually wrap the whole thing in some error catching code to avoid
losing data but you get the point.  This way, I can avoid saving class
definitions and member data of subsidiary objects and data structures I
don't want or need, and can keep my saved files relevant.  And what
could be easier for saving a giant nested structure of structures of
pointers to arrays of structures containing pointer arrays (etc.) --
certainly I don't want to follow that mess along myself and save it bit
by bit.  

(By the way, if you actually want to use this technique, please search
the archives for a thread entitled "Restoring Objects from file" or some
such.... there are a few issues to deal with -- not all of which David
has documented on his website.  But nothing is more exciting than
replacing an object's "self" from one restored in place from file.  It's
like reincarnation or identity transmogrification.  Very kharmic.)

I could go on and on, but basically, the more you use pointers, the
happier you'll be (reminding me of a camp song there...)

Good Luck,

JD