Invalid references are a GOOD thing.  The problem is that the C++ language does not allow sane behavior for the common case of objects going away.<p>The C++ language creates the impression that holding a reference is stable, when in fact it is still possible for a reference to point to bogus memory (same as a dangling pointer).  The C++ reference starts out on the right track with some nice compile-time guarantees like required initialization but then messes everything up by being immutable.  The memory can be deallocated, and people with references are screwed; they <i>cannot possibly change their own state</i> to reflect the fact that the object is now gone.  And C++ has some inconsistent hacks, such as the fact that a &quot;const&quot; reference to a temporary object will prevent object deallocation until scope exit but this is not the case for other uses of references.<p>Compare that behavior to something like Objective-C&#x27;s &quot;weak&quot; properties, where ANY weak pointer to an object is set to 0 when the target object is destroyed.  This guarantees that the property values will have one of two values: a pointer to valid memory, or &quot;nil&quot;; <i>never</i> a bogus pointer.  In addition, Objective-C ignores messages sent to &quot;nil&quot;.  While clearly this can still create hurdles for debugging, it is fantastic for end users because the program itself is quite stable.  The language created facilities for making invalid references <i>hard</i>, and mostly eliminated the penalty for screwing up.