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>
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;
94 shared_ptr(): px(0), pn()
99 explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
104 // Requirements: D's copy constructor must not throw
106 // shared_ptr will release p by calling d(p)
109 template<typename Y, typename D> shared_ptr(Y * p, D d): px(p), pn(p, d)
113 // generated copy constructor, assignment, destructor are fine
116 explicit shared_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // may throw
121 shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
126 shared_ptr(intrusive_ptr<Y> const & r): px(r.get()), pn(r.get()) // never throws
131 shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
136 shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
138 if (px == 0) // need to allocate new counter -- the cast failed
140 pn = detail::shared_count();
145 shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
149 throw std::bad_cast();
153 #ifndef BOOST_NO_AUTO_PTR
156 explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
162 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
165 shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
168 pn = r.pn; // shared_count::op= doesn't throw
174 #ifndef BOOST_NO_AUTO_PTR
177 shared_ptr & operator=(std::auto_ptr<Y> & r)
179 this_type(r).swap(*this);
187 this_type().swap(*this);
190 template<typename Y> void reset(Y * p) // Y must be complete
192 BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
193 this_type(p).swap(*this);
196 template<typename Y, typename D> void reset(Y * p, D d)
198 this_type(p, d).swap(*this);
201 typename detail::shared_ptr_traits<T>::reference operator* () const // never throws
203 BOOST_ASSERT(px != 0);
207 T * operator-> () const // never throws
209 BOOST_ASSERT(px != 0);
213 T * get() const // never throws
218 // implicit conversion to "bool"
220 typedef T * (this_type::*unspecified_bool_type)() const;
222 operator unspecified_bool_type() const // never throws
224 return px == 0? 0: &this_type::get;
227 bool operator! () const // never throws
232 bool unique() const // never throws
237 long use_count() const // never throws
239 return pn.use_count();
242 void swap(shared_ptr<T> & other) // never throws
244 std::swap(px, other.px);
248 // Tasteless as this may seem, making all members public allows member templates
249 // to work in the absence of member template friends. (Matthew Langston)
251 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
255 template<typename Y> friend class shared_ptr;
256 template<typename Y> friend class weak_ptr;
261 T * px; // contained pointer
262 detail::shared_count pn; // reference counter
266 template<typename T, typename U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
268 return a.get() == b.get();
271 template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
273 return a.get() != b.get();
276 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
278 // Resolve the ambiguity between our op!= and the one in rel_ops
280 template<typename T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
282 return a.get() != b.get();
287 template<typename T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
289 return std::less<T*>()(a.get(), b.get());
292 template<typename T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
297 template<typename T, typename U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
299 return shared_ptr<T>(r, detail::static_cast_tag());
302 template<typename T, typename U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
304 return shared_ptr<T>(r, detail::dynamic_cast_tag());
307 template<typename T, typename U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
309 return shared_ptr<T>(r, detail::polymorphic_cast_tag());
312 template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
314 BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
315 return shared_static_cast<T>(r);
318 // get_pointer() enables boost::mem_fn to recognize shared_ptr
320 template<typename T> inline T * get_pointer(shared_ptr<T> const & p)
325 // shared_from_this() creates a shared_ptr from a raw pointer (usually 'this')
330 inline void sp_assert_counted_base(boost::counted_base const *)
334 template<class T> inline T * sp_remove_const(T const * p)
336 return const_cast<T *>(p);
339 } // namespace detail
341 template<class T> shared_ptr<T> shared_from_this(T * p)
343 detail::sp_assert_counted_base(p);
344 return shared_ptr<T>(detail::sp_remove_const(p));
350 # pragma warning(pop)
353 #endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
355 #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED