1. change to weak_ptr.hpp to compile under Builder C++ 5
2. change to shared_counter.hpp to run under CodeGuard in Builder C++ 5
without error.
3. Proposal for addition to shared/weak pointer library.

Attn: Peter Dimov

 --------------------------- changes to weak_ptr.hpp typename detail::shared_ptr_traits<T>::reference operator* () const // never throws { #ifdef __BORLANDC__ element_type * p = get(); #else T * p = get(); #endif BOOST_ASSERT(p != 0); return *p; } T * operator-> () const // never throws { #ifdef __BORLANDC__ element_type * p = get(); #else T * p = get(); #endif BOOST_ASSERT(p != 0); return p; } --------------------------- Also made changes to shared_count.hpp, not to compile, but to run under Builder C++ 5 native debugger CodeGuard, without reporting error. It was confused by empty deletor. Maybe this could be added with a #define condition for Code Guard? #if defined(__BORLANDC__) && defined (CODE_GUARD) co unted_base_impl(P p, D&, long initial_use_count, long initial_weak_count): counted_base(initial_use_count, initial_weak_count), ptr(p) #else counted_base_impl(P p, D d, long initial_use_count, long initial_weak_count): counted_base(initial_use_count, initial_weak_count), ptr(p), del(d) #endif { } virtual void dispose() // nothrow { #if defined(__BORLANDC__) && defined (CODE_GUARD) del()(ptr); #else del(ptr); #endif } --------------------------- Proposal for addition to shared/weak pointer library.
"eigen_ptr" is embedded in a structure as a base class. Note the constructor/copy/assign semantics #include "boost\smart_ptr.hpp" #include "boost\weak_ptr.hpp" namespace detail { template <class T> struct eigen_ptr_deletor { void operator()(T*& ptr) { ptr=0; } }; } template <class T> class eigen_ptr { protected: typedef boost::shared_ptr<T> own_shared_ptr_type; own_shared_ptr_type sp; // constructor passes pointer to derived class and empt y destructor // copy constructor makes new copy // assign makes new copy eigen_ptr() : sp((T*)this, detail::eigen_ptr_deletor<T>()) {} void renew() { this->~eigen_ptr<T>(); new (this) eigen_ptr<T>(); } eigen_ptr(const eigen_ptr<T>& s) { renew(); } eigen_ptr<T>& operator = (const eigen_ptr<T>& s) { renew(); } public: typedef boost::weak_ptr<T> weak_ptr_type; weak_ptr_type make_weak_ptr() { return sp; } // for test/debug only , derived object should pass pointer to self bool check_eigen_ptr(T* p) { return (sp.get()==p); } };


Usage::
MyClass : ...., public eigen_ptr<MyClass>, ....
{
....
};

MyClass s;
boost::weak_ptr<MyClass> wp = s.make_weak_ptr();

(It's called "eigen_ptr" because self_ptr looks like it could cause a lot of conflicts)