1 #ifndef BOOST_SHARED_PTR_HPP_INCLUDED
2 #define BOOST_SHARED_PTR_HPP_INCLUDED
7 // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
8 // Copyright (c) 2001, 2002 Peter Dimov
10 // Permission to copy, use, modify, sell and distribute this software
11 // is granted provided this copyright notice appears in all copies.
12 // This software is provided "as is" without express or implied
13 // warranty, and with no claim as to its suitability for any purpose.
15 // See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
18 #include <boost/config.hpp> // for broken compiler workarounds
20 #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
21 #include <boost/detail/shared_ptr_nmt.hpp>
24 #include <boost/assert.hpp>
25 #include <boost/checked_delete.hpp>
26 #include <boost/throw_exception.hpp>
27 #include <boost/detail/shared_count.hpp>
29 #include <memory> // for std::auto_ptr
30 #include <algorithm> // for std::swap
31 #include <functional> // for std::less
32 #include <typeinfo> // for std::bad_cast
34 #ifdef BOOST_MSVC // moved here to work around VC++ compiler crash
35 # pragma warning(push)
36 # pragma warning(disable:4284) // odd return type for operator->
45 struct static_cast_tag {};
46 struct dynamic_cast_tag {};
47 struct polymorphic_cast_tag {};
49 template<typename T> struct shared_ptr_traits
51 typedef T & reference;
54 template<> struct shared_ptr_traits<void>
56 typedef void reference;
59 #if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
61 template<> struct shared_ptr_traits<void const>
63 typedef void reference;
74 // An enhanced relative of scoped_ptr with reference counted copy semantics.
75 // The object pointed to is deleted when the last shared_ptr pointing to it
76 // is destroyed or reset.
79 template<typename T> class weak_ptr;
80 template<typename T> class intrusive_ptr;
82 template<typename T> class shared_ptr
86 // Borland 5.5.1 specific workarounds
87 // typedef checked_deleter<T> deleter;
88 typedef shared_ptr<T> this_type;
92 typedef T element_type;
95 shared_ptr(): px(0), pn()
100 explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
105 // Requirements: D's copy constructor must not throw
107 // shared_ptr will release p by calling d(p)
110 template<typename Y, typename D> shared_ptr(Y * p, D d): px(p), pn(p, d)
114 // generated copy constructor, assignment, destructor are fine
117 explicit shared_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // may throw
122 shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
127 shared_ptr(intrusive_ptr<Y> const & r): px(r.get()), pn(r.get()) // never throws
132 shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
137 shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
139 if (px == 0) // need to allocate new counter -- the cast failed
141 pn = detail::shared_count();
146 shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
150 boost::throw_exception(std::bad_cast());
154 #ifndef BOOST_NO_AUTO_PTR
157 explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
163 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
166 shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
169 pn = r.pn; // shared_count::op= doesn't throw
175 #ifndef BOOST_NO_AUTO_PTR
178 shared_ptr & operator=(std::auto_ptr<Y> & r)
180 this_type(r).swap(*this);
188 this_type().swap(*this);
191 template<typename Y> void reset(Y * p) // Y must be complete
193 BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
194 this_type(p).swap(*this);
197 template<typename Y, typename D> void reset(Y * p, D d)
199 this_type(p, d).swap(*this);
202 typename detail::shared_ptr_traits<T>::reference operator* () const // never throws
204 BOOST_ASSERT(px != 0);
208 T * operator-> () const // never throws
210 BOOST_ASSERT(px != 0);
214 T * get() const // never throws
219 // implicit conversion to "bool"
221 typedef T * (this_type::*unspecified_bool_type)() const;
223 operator unspecified_bool_type() const // never throws
225 return px == 0? 0: &this_type::get;
228 bool operator! () const // never throws
233 bool unique() const // never throws
238 long use_count() const // never throws
240 return pn.use_count();
243 void swap(shared_ptr<T> & other) // never throws
245 std::swap(px, other.px);
249 // Tasteless as this may seem, making all members public allows member templates
250 // to work in the absence of member template friends. (Matthew Langston)
252 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
256 template<typename Y> friend class shared_ptr;
257 template<typename Y> friend class weak_ptr;
262 T * px; // contained pointer
263 detail::shared_count pn; // reference counter
267 template<typename T, typename U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
269 return a.get() == b.get();
272 template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
274 return a.get() != b.get();
277 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
279 // Resolve the ambiguity between our op!= and the one in rel_ops
281 template<typename T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
283 return a.get() != b.get();
288 template<typename T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
290 return std::less<T*>()(a.get(), b.get());
293 template<typename T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
298 template<typename T, typename U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
300 return shared_ptr<T>(r, detail::static_cast_tag());
303 template<typename T, typename U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
305 return shared_ptr<T>(r, detail::dynamic_cast_tag());
308 template<typename T, typename U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
310 return shared_ptr<T>(r, detail::polymorphic_cast_tag());
313 template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
315 BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
316 return shared_static_cast<T>(r);
319 // get_pointer() enables boost::mem_fn to recognize shared_ptr
321 template<typename T> inline T * get_pointer(shared_ptr<T> const & p)
326 // shared_from_this() creates a shared_ptr from a raw pointer (usually 'this')
331 inline void sp_assert_counted_base(boost::counted_base const *)
335 template<class T> inline T * sp_remove_const(T const * p)
337 return const_cast<T *>(p);
340 } // namespace detail
342 template<class T> shared_ptr<T> shared_from_this(T * p)
344 detail::sp_assert_counted_base(p);
345 return shared_ptr<T>(detail::sp_remove_const(p));
351 # pragma warning(pop)
354 #endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
356 #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED