[boost] Re: Small linked_ptr improvements

From: Borgerding, Mark A. (MarkAB_at_[hidden])
Date: 2000-03-15 16:30:47

> -----Original Message-----
> From: Miki Jovanovic [mailto:miki_at_[hidden]]
> Sent: Wednesday, March 15, 2000 4:02 PM
> To: boost_at_[hidden]
> Subject: [boost] Small linked_ptr improvements
> 
> 
> 
> Hi all, hi Mark,
> 
> I've been spending some serious time in the linked_ptr and I basically
> have two small suggestions:
> 
> 1) dynamic_cast_from might behave little better is written as below.
> What I did not like with the previous version was that if the 
> contained
> object destructor threw an exception, the value of the smart pointer
> would have beed NULL. Version below would actually do the assignment
> correctly, even if the exception was thrown. Also, I there should be a
> small performance improvement.
> 
> template <class T2>
> element_type * dynamic_cast_from(const linked_ptr<T2> & other) {
>    if (ptr != other.get()) {// also checks for assignment to self
>       element_type *pToDelete = ptr;
>       ptr = dynamic_cast<element_type*>(other.get());
>       if (ptr) {
>          if (leave_list(&other))
>             delete pToDelete;
>       }
>       else if (leave_list(this))
>          delete pToDelete;
>    }
>    return get();
> }

Nice catch.  I can't see any downside to this.  Do you want to change the
version in the vault, or shall I?

> 
> 2) This second suggestion is way more contraversial. The idea is to
> improve slightly the performance of linked_ptr. How slightly? Very
> slightly. What I like in the shared_ptr is that the contained 
> object is
> actually at the same address as the shared_ptr:

This was my original implementation I sent to the group on 1/28.  I admit I
didn't consider the performance characteristics of having an offset from the
"this" pointer.  My original hope was to be able to nicely integrate into
varargs C code that took pointers ,e.g. printf("%s",...) .  But I realized
that this would probably not work since the the sizeof(linked_ptr<T>) is not
the same as sizeof(T*).  

The main reason I moved the ptr down into the typed subclass was to avoid
the static_cast.  I think it is more readable, better organized and safer
without the void*.  The safety concern comes from relying on the subclass to
verify type safety.  If a malicious or clueless user subclassed the
linked_base, they could introduce different types into the mix.

As you point out, the performance difference is very slight.  I doubt it
would be noticeable even in benchmarks.

In short, I prefer keeping the ptr in the subclass.