QPointer
====================
QPointer is a guarded pointer for QObjects, so it automatically becomes 0 when
the data it points to is deleted. If you have a member variable that's a QObject
and are ever worried that it might be dangling, make it a QPointer. There's
really no reason not to for variables that stick around, it adds little
overhead.

KSharedPtr
====================
Unlike QPointer, KSharedPtr is dangerous and must be used carefully. 

== Undercounting ==
KSharedPtr uses reference counting. When a KSharedPtr is in scope, it adds one
to the reference counter. When a KSharedPtr loses scope, it deletes one from the
reference count. When the reference count become 0 it deletes the object. So if
there were any normal pointers to that data and all the KSharedPtrs are deleted,
then the object is deleted and the normal pointers dangle. Segfaults ensue.

The solution is to just make sure that any normal pointers are temporary and
everything else is a KSharedPtr if reference counting is required for your class. Even
if the pointer is temporary, but is then handed off to some other class that
might keep it around, thats a potentional crash now or in the future.


== Reference Cycles ==
One issue with reference counting in general is the creation of a reference
cycle. If class A has a KSharedPtr<B> property and class B has a KSharedPtr<A>
property and two objects of A and B point to each other and the KSharedPtrs
loose scope, a reference cycle is created. Despite not being accessible from
anywhere in the program, the reference counter of KSharedPtr<A> and
KSharedPtr<B> will never go to 0. Memory leaks. The solution is to be careful.

== Dreaded Diamonds ==
Since the objects KSharedPtr point to must derive from QSharedData, it's not
uncommon for a "dreaded diamond" inheritance issue to arise. Basically if A and
B both inherit QSharedData and C inherits A and B, then C inherits QSharedData
twice. The solution is really easy, just add a 'virtual' keyword when A and B
inherit QSharedData. Eg class A : public virtual QSharedData.  Details at:
http://www.parashift.com/c++-faq-lite/multiple-inheritance.html#faq-25.8
