2012/7/17 Jeffrey Lee Hellrung, Jr. <jeffrey.hellrung@gmail.com>
[Just a few suggestions...]
[snip] 
This is where the hard part comes in - the conversion constructors and assignment operators. First version looks like this:

{{{
private:

#if !defined(BY_VALUE)

    BOOST_COPYABLE_AND_MOVABLE(ptr)

public:

    // generalized copy ctor for pointers to derived
    template < class U >
    ptr( ptr<U> const& b,
            typename boost::enable_if< boost::is_convertible<U*,T*> >::type* = 0 )
    : p_( clone_me(b.get()) ) { ++ptr_s; std::cout << "Cp "; }

    // generalized move ctor for pointers to derived
    template < class U >
    ptr( BOOST_RV_REF(ptr<U>) b,
            typename boost::enable_if< boost::is_convertible<U*,T*> >::type* = 0 )
    : p_( b.release() ) { ++ptr_s; std::cout << "Mp "; }

I think you'll generally do better with the conversion copy constructor taking by-value and relying on RVO (in C++03). (Implicit) Rvalues of ptr<U> won't be moved into the newly constructed ptr<T> as written above. Note that the RV_REF overload is still useful even if you change the conversion copy constructor to taking by-value. Of course, in C++11, you can't have both by-value and rvalue reference overloads :(

    ptr& operator=( BOOST_COPY_ASSIGN_REF(ptr) b )
    {
        T* tmp = clone_me(b.get()); // this can throw
        boost::checked_delete(p_);
        p_ = tmp;
        return *this;
    }

    ptr& operator=( BOOST_RV_REF(ptr) b )
    {
        boost::checked_delete(p_);
        p_ = b.release();
        return *this;
    }

    template < class U >
    typename boost::enable_if< boost::is_convertible<U*,T*>, ptr& >::type
    operator=( ptr<U> const& b )
    {
        T* tmp = clone_me(b.get()); // this could throw
        boost::checked_delete(p_);
        p_ = tmp;
        return *this;
    }

Probably want to disable this overload when U == T. And, again, by-value is probably what you want in C++03.
 
Oh yeah, right, I will add that condition. Thanks.

    template < class U >
    typename boost::enable_if< boost::is_convertible<U*,T*>, ptr& >::type
    operator=( BOOST_RV_REF(ptr<U>) b )
    {
        boost::checked_delete(p_);
        p_ = b.release();
        return *this;
    }
}}}
This was long, and contains some tricky places, like the one commented 'this could throw'. Did I even get it right? I think so, but I'm just beginning to learn about move semantics here ;-)

I admit, I didn't really look at the bodies, so no comments regarding correctness there :)
[snip] 
And now for the costs. I compiled the attached code with MinGW-4.5.0 in 4 configurations: -std=c++0x disabled/enabled, and version 1/2. I compared the program output to derive the conclusions:

C++03: version 1 vs. version 2:
- whenever a conversion is needed (about half of the use cases above), version 2 introduces an additional temporary ptr<> object (without a deep copy); in one case it's 2 additional temporary ptr<>s;
- the last 4 use cases {{{ ptr<A> b = make_b(); ptr<A> c( make_b() ); a = make_a(); b = make_b(); }}} introduce a deep copy in version 1, while while the deep copy is avoided in version 2.

I'm pretty sure these extraneous deep copies would be avoided if you make the changes I suggested above.

You are right, and the second version (when BY_VALUE is defined) is my attempt at solving that as you suggest. Please, could you have a look again, and let me know if this is what you have in mind:
 
Anyway, next comes the second version: implementing conversion constructors and assignment operators in terms of pass-by-value and swap. Note the use of BOOST_COPYABLE_AND_MOVABLE_ALT macro so that an operator=(ptr&) isn't inserted.
{{{
#else // BY_VALUE

    BOOST_COPYABLE_AND_MOVABLE_ALT(ptr)

public:

    // generalized copy/move constructor implemented by pass-by-value & steal
    template < class U >
    ptr( ptr<U> b,
            typename boost::enable_if< boost::is_convertible<U*,T*> >::type* = 0 )
    : p_( b.release() ) { ++ptr_s; std::cout << "Vp "; }

    // assignment - works for all types convertible to ptr
    ptr& operator=( ptr b )
    {
        swap(*this,b);
        return *this;
    }

#endif // BY_VALUE
}}}
Compared to the first version, this is really simple. I see no tricky parts here.

[snip] 
Hope that provides with additional insight,
- Jeff

Thank you for your reply, Jeff.
Kris