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 #ifndef 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;
65 // An enhanced relative of scoped_ptr with reference counted copy semantics.
66 // The object pointed to is deleted when the last shared_ptr pointing to it
67 // is destroyed or reset.
70 template<typename T> class weak_ptr;
71 template<typename T> class intrusive_ptr;
73 template<typename T> class shared_ptr
77 // Borland 5.5.1 specific workarounds
78 // typedef checked_deleter<T> deleter;
79 typedef shared_ptr<T> this_type;
83 typedef T element_type;
85 shared_ptr(): px(0), pn()
90 explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
95 // Requirements: D's copy constructor must not throw
97 // shared_ptr will release p by calling d(p)
100 template<typename Y, typename D> shared_ptr(Y * p, D d): px(p), pn(p, d)
104 // generated copy constructor, assignment, destructor are fine
107 explicit shared_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // may throw
112 shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
117 shared_ptr(intrusive_ptr<Y> const & r): px(r.get()), pn(r.get()) // never throws
122 shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
127 shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
129 if (px == 0) // need to allocate new counter -- the cast failed
131 pn = detail::shared_count();
136 shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
140 throw std::bad_cast();
144 #ifndef BOOST_NO_AUTO_PTR
147 explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
153 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
156 shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
159 pn = r.pn; // shared_count::op= doesn't throw
165 #ifndef BOOST_NO_AUTO_PTR
168 shared_ptr & operator=(std::auto_ptr<Y> & r)
170 this_type(r).swap(*this);
178 this_type().swap(*this);
181 template<typename Y> void reset(Y * p) // Y must be complete
183 BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
184 this_type(p).swap(*this);
187 template<typename Y, typename D> void reset(Y * p, D d)
189 this_type(p, d).swap(*this);
192 typename detail::shared_ptr_traits<T>::reference operator* () const // never throws
194 BOOST_ASSERT(px != 0);
198 T * operator-> () const // never throws
200 BOOST_ASSERT(px != 0);
204 T * get() const // never throws
209 bool unique() const // never throws
214 long use_count() const // never throws
216 return pn.use_count();
219 // implicit conversion to "bool"
221 typedef long (this_type::*bool_type)() const;
223 operator bool_type() const // never throws
225 return px == 0? 0: &this_type::use_count;
228 bool operator! () const // never throws
233 void swap(shared_ptr<T> & other) // never throws
235 std::swap(px, other.px);
239 // Tasteless as this may seem, making all members public allows member templates
240 // to work in the absence of member template friends. (Matthew Langston)
242 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
246 template<typename Y> friend class shared_ptr;
247 template<typename Y> friend class weak_ptr;
252 T * px; // contained pointer
253 detail::shared_count pn; // reference counter
257 template<typename T, typename U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
259 return a.get() == b.get();
262 template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
264 return a.get() != b.get();
267 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
269 // Resolve the ambiguity between our op!= and the one in rel_ops
271 template<typename T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
273 return a.get() != b.get();
278 template<typename T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
280 return std::less<T*>()(a.get(), b.get());
283 template<typename T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
288 template<typename T, typename U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
290 return shared_ptr<T>(r, detail::static_cast_tag());
293 template<typename T, typename U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
295 return shared_ptr<T>(r, detail::dynamic_cast_tag());
298 template<typename T, typename U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
300 return shared_ptr<T>(r, detail::polymorphic_cast_tag());
303 template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
305 BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
306 return shared_static_cast<T>(r);
309 // get_pointer() enables boost::mem_fn to recognize shared_ptr
311 template<typename T> inline T * get_pointer(shared_ptr<T> const & p)
319 # pragma warning(pop)
322 #endif // #ifndef BOOST_MSVC6_MEMBER_TEMPLATES
324 #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED