libstdc++
bits/shared_ptr.h
Go to the documentation of this file.
1 // shared_ptr and weak_ptr implementation -*- C++ -*-
2 
3 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 // shared_count.hpp
26 // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
27 
28 // shared_ptr.hpp
29 // Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
30 // Copyright (C) 2001, 2002, 2003 Peter Dimov
31 
32 // weak_ptr.hpp
33 // Copyright (C) 2001, 2002, 2003 Peter Dimov
34 
35 // enable_shared_from_this.hpp
36 // Copyright (C) 2002 Peter Dimov
37 
38 // Distributed under the Boost Software License, Version 1.0. (See
39 // accompanying file LICENSE_1_0.txt or copy at
40 // http://www.boost.org/LICENSE_1_0.txt)
41 
42 // GCC Note: based on version 1.32.0 of the Boost library.
43 
44 /** @file bits/shared_ptr.h
45  * This is an internal header file, included by other library headers.
46  * You should not attempt to use it directly.
47  */
48 
49 #ifndef _SHARED_PTR_H
50 #define _SHARED_PTR_H 1
51 
52 #ifndef __GXX_EXPERIMENTAL_CXX0X__
53 # include <c++0x_warning.h>
54 #endif
55 
56 #if defined(_GLIBCXX_INCLUDE_AS_TR1)
57 # error C++0x header cannot be included from TR1 header
58 #endif
59 
60 _GLIBCXX_BEGIN_NAMESPACE(std)
61 
62  /**
63  * @addtogroup pointer_abstractions
64  * @{
65  */
66 
67  // counted ptr with no deleter or allocator support
68  template<typename _Ptr, _Lock_policy _Lp>
69  class _Sp_counted_ptr
70  : public _Sp_counted_base<_Lp>
71  {
72  public:
73  _Sp_counted_ptr(_Ptr __p)
74  : _M_ptr(__p) { }
75 
76  virtual void
77  _M_dispose() // nothrow
78  { delete _M_ptr; }
79 
80  virtual void
81  _M_destroy() // nothrow
82  { delete this; }
83 
84  virtual void*
85  _M_get_deleter(const std::type_info& __ti)
86  { return 0; }
87 
88  _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
89  _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
90 
91  protected:
92  _Ptr _M_ptr; // copy constructor must not throw
93  };
94 
95  // support for custom deleter and/or allocator
96  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
97  class _Sp_counted_deleter
98  : public _Sp_counted_ptr<_Ptr, _Lp>
99  {
100  typedef typename _Alloc::template
101  rebind<_Sp_counted_deleter>::other _My_alloc_type;
102 
103  // Helper class that stores the Deleter and also acts as an allocator.
104  // Used to dispose of the owned pointer and the internal refcount
105  // Requires that copies of _Alloc can free each other's memory.
106  struct _My_Deleter
107  : public _My_alloc_type // copy constructor must not throw
108  {
109  _Deleter _M_del; // copy constructor must not throw
110  _My_Deleter(_Deleter __d, const _Alloc& __a)
111  : _My_alloc_type(__a), _M_del(__d) { }
112  };
113 
114  protected:
115  typedef _Sp_counted_ptr<_Ptr, _Lp> _Base_type;
116 
117  public:
118  /**
119  * @brief
120  * @pre __d(__p) must not throw.
121  */
122  _Sp_counted_deleter(_Ptr __p, _Deleter __d)
123  : _Base_type(__p), _M_del(__d, _Alloc()) { }
124 
125  /**
126  * @brief
127  * @pre __d(__p) must not throw.
128  */
129  _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
130  : _Base_type(__p), _M_del(__d, __a) { }
131 
132  virtual void
133  _M_dispose() // nothrow
134  { _M_del._M_del(_Base_type::_M_ptr); }
135 
136  virtual void
137  _M_destroy() // nothrow
138  {
139  _My_alloc_type __a(_M_del);
140  this->~_Sp_counted_deleter();
141  __a.deallocate(this, 1);
142  }
143 
144  virtual void*
145  _M_get_deleter(const std::type_info& __ti)
146  { return __ti == typeid(_Deleter) ? &_M_del._M_del : 0; }
147 
148  protected:
149  _My_Deleter _M_del; // copy constructor must not throw
150  };
151 
152  // helpers for make_shared / allocate_shared
153 
154  template<typename _Tp>
155  struct _Sp_destroy_inplace
156  {
157  void operator()(_Tp* __p) const { if (__p) __p->~_Tp(); }
158  };
159 
160  struct _Sp_make_shared_tag { };
161 
162  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
163  class _Sp_counted_ptr_inplace
164  : public _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
165  {
166  typedef _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
167  _Base_type;
168 
169  public:
170  _Sp_counted_ptr_inplace(_Alloc __a)
171  : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
172  , _M_storage()
173  {
174  void* __p = &_M_storage;
175  ::new (__p) _Tp(); // might throw
176  _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
177  }
178 
179  template<typename... _Args>
180  _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
181  : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
182  , _M_storage()
183  {
184  void* __p = &_M_storage;
185  ::new (__p) _Tp(std::forward<_Args>(__args)...); // might throw
186  _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
187  }
188 
189  // override because the allocator needs to know the dynamic type
190  virtual void
191  _M_destroy() // nothrow
192  {
193  typedef typename _Alloc::template
194  rebind<_Sp_counted_ptr_inplace>::other _My_alloc_type;
195  _My_alloc_type __a(_Base_type::_M_del);
196  this->~_Sp_counted_ptr_inplace();
197  __a.deallocate(this, 1);
198  }
199 
200  // sneaky trick so __shared_ptr can get the managed pointer
201  virtual void*
202  _M_get_deleter(const std::type_info& __ti)
203  {
204  return __ti == typeid(_Sp_make_shared_tag)
205  ? static_cast<void*>(&_M_storage)
206  : _Base_type::_M_get_deleter(__ti);
207  }
208 
209  private:
210  typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
211  _M_storage;
212  };
213 
214  template<_Lock_policy _Lp = __default_lock_policy>
215  class __weak_count;
216 
217  template<_Lock_policy _Lp = __default_lock_policy>
218  class __shared_count
219  {
220  public:
221  __shared_count()
222  : _M_pi(0) // nothrow
223  { }
224 
225  template<typename _Ptr>
226  __shared_count(_Ptr __p) : _M_pi(0)
227  {
228  __try
229  {
230  _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
231  }
232  __catch(...)
233  {
234  delete __p;
235  __throw_exception_again;
236  }
237  }
238 
239  template<typename _Ptr, typename _Deleter>
240  __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
241  {
242  // allocator's value_type doesn't matter, will rebind it anyway
243  typedef std::allocator<int> _Alloc;
244  typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
245  typedef std::allocator<_Sp_cd_type> _Alloc2;
246  _Alloc2 __a2;
247  __try
248  {
249  _M_pi = __a2.allocate(1);
250  ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d);
251  }
252  __catch(...)
253  {
254  __d(__p); // Call _Deleter on __p.
255  if (_M_pi)
256  __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
257  __throw_exception_again;
258  }
259  }
260 
261  template<typename _Ptr, typename _Deleter, typename _Alloc>
262  __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
263  {
264  typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
265  typedef typename _Alloc::template rebind<_Sp_cd_type>::other _Alloc2;
266  _Alloc2 __a2(__a);
267  __try
268  {
269  _M_pi = __a2.allocate(1);
270  ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d, __a);
271  }
272  __catch(...)
273  {
274  __d(__p); // Call _Deleter on __p.
275  if (_M_pi)
276  __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
277  __throw_exception_again;
278  }
279  }
280 
281  template<typename _Tp, typename _Alloc, typename... _Args>
282  __shared_count(_Sp_make_shared_tag, _Tp*, _Alloc __a, _Args&&... __args)
283  : _M_pi(0)
284  {
285  typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
286  typedef typename _Alloc::template rebind<_Sp_cp_type>::other _Alloc2;
287  _Alloc2 __a2(__a);
288  __try
289  {
290  _M_pi = __a2.allocate(1);
291  ::new(static_cast<void*>(_M_pi)) _Sp_cp_type(__a,
292  std::forward<_Args>(__args)...);
293  }
294  __catch(...)
295  {
296  if (_M_pi)
297  __a2.deallocate(static_cast<_Sp_cp_type*>(_M_pi), 1);
298  __throw_exception_again;
299  }
300  }
301 
302 #if _GLIBCXX_DEPRECATED
303  // Special case for auto_ptr<_Tp> to provide the strong guarantee.
304  template<typename _Tp>
305  explicit
306  __shared_count(std::auto_ptr<_Tp>&& __r)
307  : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
308  { __r.release(); }
309 #endif
310 
311  // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
312  template<typename _Tp, typename _Del>
313  explicit
314  __shared_count(std::unique_ptr<_Tp, _Del>&& __r)
315  : _M_pi(_S_create_from_up(std::move(__r)))
316  { __r.release(); }
317 
318  // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
319  explicit
320  __shared_count(const __weak_count<_Lp>& __r);
321 
322  ~__shared_count() // nothrow
323  {
324  if (_M_pi != 0)
325  _M_pi->_M_release();
326  }
327 
328  __shared_count(const __shared_count& __r)
329  : _M_pi(__r._M_pi) // nothrow
330  {
331  if (_M_pi != 0)
332  _M_pi->_M_add_ref_copy();
333  }
334 
335  __shared_count&
336  operator=(const __shared_count& __r) // nothrow
337  {
338  _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
339  if (__tmp != _M_pi)
340  {
341  if (__tmp != 0)
342  __tmp->_M_add_ref_copy();
343  if (_M_pi != 0)
344  _M_pi->_M_release();
345  _M_pi = __tmp;
346  }
347  return *this;
348  }
349 
350  void
351  _M_swap(__shared_count& __r) // nothrow
352  {
353  _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
354  __r._M_pi = _M_pi;
355  _M_pi = __tmp;
356  }
357 
358  long
359  _M_get_use_count() const // nothrow
360  { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
361 
362  bool
363  _M_unique() const // nothrow
364  { return this->_M_get_use_count() == 1; }
365 
366  void*
367  _M_get_deleter(const std::type_info& __ti) const
368  { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
369 
370  bool
371  _M_less(const __shared_count& __rhs) const
372  { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
373 
374  bool
375  _M_less(const __weak_count<_Lp>& __rhs) const
376  { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
377 
378  // friend function injected into enclosing namespace and found by ADL
379  friend inline bool
380  operator==(const __shared_count& __a, const __shared_count& __b)
381  { return __a._M_pi == __b._M_pi; }
382 
383  private:
384  friend class __weak_count<_Lp>;
385 
386  template<typename _Tp, typename _Del>
387  static _Sp_counted_base<_Lp>*
388  _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
389  typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0)
390  {
391  return new _Sp_counted_deleter<_Tp*, _Del, std::allocator<_Tp>,
392  _Lp>(__r.get(), __r.get_deleter());
393  }
394 
395  template<typename _Tp, typename _Del>
396  static _Sp_counted_base<_Lp>*
397  _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
398  typename std::enable_if<std::is_reference<_Del>::value>::type* = 0)
399  {
400  typedef typename std::remove_reference<_Del>::type _Del1;
401  typedef std::reference_wrapper<_Del1> _Del2;
402  return new _Sp_counted_deleter<_Tp*, _Del2, std::allocator<_Tp>,
403  _Lp>(__r.get(), std::ref(__r.get_deleter()));
404  }
405 
406  _Sp_counted_base<_Lp>* _M_pi;
407  };
408 
409 
410  template<_Lock_policy _Lp>
411  class __weak_count
412  {
413  public:
414  __weak_count()
415  : _M_pi(0) // nothrow
416  { }
417 
418  __weak_count(const __shared_count<_Lp>& __r)
419  : _M_pi(__r._M_pi) // nothrow
420  {
421  if (_M_pi != 0)
422  _M_pi->_M_weak_add_ref();
423  }
424 
425  __weak_count(const __weak_count<_Lp>& __r)
426  : _M_pi(__r._M_pi) // nothrow
427  {
428  if (_M_pi != 0)
429  _M_pi->_M_weak_add_ref();
430  }
431 
432  ~__weak_count() // nothrow
433  {
434  if (_M_pi != 0)
435  _M_pi->_M_weak_release();
436  }
437 
438  __weak_count<_Lp>&
439  operator=(const __shared_count<_Lp>& __r) // nothrow
440  {
441  _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
442  if (__tmp != 0)
443  __tmp->_M_weak_add_ref();
444  if (_M_pi != 0)
445  _M_pi->_M_weak_release();
446  _M_pi = __tmp;
447  return *this;
448  }
449 
450  __weak_count<_Lp>&
451  operator=(const __weak_count<_Lp>& __r) // nothrow
452  {
453  _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
454  if (__tmp != 0)
455  __tmp->_M_weak_add_ref();
456  if (_M_pi != 0)
457  _M_pi->_M_weak_release();
458  _M_pi = __tmp;
459  return *this;
460  }
461 
462  void
463  _M_swap(__weak_count<_Lp>& __r) // nothrow
464  {
465  _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
466  __r._M_pi = _M_pi;
467  _M_pi = __tmp;
468  }
469 
470  long
471  _M_get_use_count() const // nothrow
472  { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
473 
474  bool
475  _M_less(const __weak_count& __rhs) const
476  { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
477 
478  bool
479  _M_less(const __shared_count<_Lp>& __rhs) const
480  { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
481 
482  // friend function injected into enclosing namespace and found by ADL
483  friend inline bool
484  operator==(const __weak_count& __a, const __weak_count& __b)
485  { return __a._M_pi == __b._M_pi; }
486 
487  private:
488  friend class __shared_count<_Lp>;
489 
490  _Sp_counted_base<_Lp>* _M_pi;
491  };
492 
493  // now that __weak_count is defined we can define this constructor:
494  template<_Lock_policy _Lp>
495  inline
496  __shared_count<_Lp>::
497  __shared_count(const __weak_count<_Lp>& __r)
498  : _M_pi(__r._M_pi)
499  {
500  if (_M_pi != 0)
501  _M_pi->_M_add_ref_lock();
502  else
503  __throw_bad_weak_ptr();
504  }
505 
506  // Forward declarations.
507  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
508  class __shared_ptr;
509 
510  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
511  class __weak_ptr;
512 
513  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
514  class __enable_shared_from_this;
515 
516  template<typename _Tp>
517  class shared_ptr;
518 
519  template<typename _Tp>
520  class weak_ptr;
521 
522  template<typename _Tp>
523  class enable_shared_from_this;
524 
525  // Support for enable_shared_from_this.
526 
527  // Friend of __enable_shared_from_this.
528  template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
529  void
530  __enable_shared_from_this_helper(const __shared_count<_Lp>&,
531  const __enable_shared_from_this<_Tp1,
532  _Lp>*, const _Tp2*);
533 
534  // Friend of enable_shared_from_this.
535  template<typename _Tp1, typename _Tp2>
536  void
537  __enable_shared_from_this_helper(const __shared_count<>&,
538  const enable_shared_from_this<_Tp1>*,
539  const _Tp2*);
540 
541  template<_Lock_policy _Lp>
542  inline void
543  __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...)
544  { }
545 
546 
547  template<typename _Tp, _Lock_policy _Lp>
548  class __shared_ptr
549  {
550  public:
551  typedef _Tp element_type;
552 
553  /** @brief Construct an empty %__shared_ptr.
554  * @post use_count()==0 && get()==0
555  */
556  __shared_ptr()
557  : _M_ptr(0), _M_refcount() // never throws
558  { }
559 
560  /** @brief Construct a %__shared_ptr that owns the pointer @a __p.
561  * @param __p A pointer that is convertible to element_type*.
562  * @post use_count() == 1 && get() == __p
563  * @throw std::bad_alloc, in which case @c delete @a __p is called.
564  */
565  template<typename _Tp1>
566  explicit
567  __shared_ptr(_Tp1* __p)
568  : _M_ptr(__p), _M_refcount(__p)
569  {
570  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
571  // __glibcxx_function_requires(_CompleteConcept<_Tp1*>)
572  __enable_shared_from_this_helper(_M_refcount, __p, __p);
573  }
574 
575  //
576  // Requirements: _Deleter's copy constructor and destructor must
577  // not throw
578  //
579  // __shared_ptr will release __p by calling __d(__p)
580  //
581  /** @brief Construct a %__shared_ptr that owns the pointer @a __p
582  * and the deleter @a __d.
583  * @param __p A pointer.
584  * @param __d A deleter.
585  * @post use_count() == 1 && get() == __p
586  * @throw std::bad_alloc, in which case @a __d(__p) is called.
587  */
588  template<typename _Tp1, typename _Deleter>
589  __shared_ptr(_Tp1* __p, _Deleter __d)
590  : _M_ptr(__p), _M_refcount(__p, __d)
591  {
592  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
593  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
594  __enable_shared_from_this_helper(_M_refcount, __p, __p);
595  }
596 
597  //
598  // Requirements: _Deleter's copy constructor and destructor must
599  // not throw _Alloc's copy constructor and destructor must not
600  // throw.
601  //
602  // __shared_ptr will release __p by calling __d(__p)
603  //
604  /** @brief Construct a %__shared_ptr that owns the pointer @a __p
605  * and the deleter @a __d.
606  * @param __p A pointer.
607  * @param __d A deleter.
608  * @param __a An allocator.
609  * @post use_count() == 1 && get() == __p
610  * @throw std::bad_alloc, in which case @a __d(__p) is called.
611  */
612  template<typename _Tp1, typename _Deleter, typename _Alloc>
613  __shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
614  : _M_ptr(__p), _M_refcount(__p, __d, __a)
615  {
616  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
617  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
618  __enable_shared_from_this_helper(_M_refcount, __p, __p);
619  }
620 
621  /** @brief Constructs a %__shared_ptr instance that stores @a __p
622  * and shares ownership with @a __r.
623  * @param __r A %__shared_ptr.
624  * @param __p A pointer that will remain valid while @a *__r is valid.
625  * @post get() == __p && use_count() == __r.use_count()
626  *
627  * This can be used to construct a @c shared_ptr to a sub-object
628  * of an object managed by an existing @c shared_ptr.
629  *
630  * @code
631  * shared_ptr< pair<int,int> > pii(new pair<int,int>());
632  * shared_ptr<int> pi(pii, &pii->first);
633  * assert(pii.use_count() == 2);
634  * @endcode
635  */
636  template<typename _Tp1>
637  __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p)
638  : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
639  { }
640 
641  // generated copy constructor, assignment, destructor are fine.
642 
643  /** @brief If @a __r is empty, constructs an empty %__shared_ptr;
644  * otherwise construct a %__shared_ptr that shares ownership
645  * with @a __r.
646  * @param __r A %__shared_ptr.
647  * @post get() == __r.get() && use_count() == __r.use_count()
648  */
649  template<typename _Tp1>
650  __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
651  : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
652  { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
653 
654  /** @brief Move-constructs a %__shared_ptr instance from @a __r.
655  * @param __r A %__shared_ptr rvalue.
656  * @post *this contains the old value of @a __r, @a __r is empty.
657  */
658  __shared_ptr(__shared_ptr&& __r)
659  : _M_ptr(__r._M_ptr), _M_refcount() // never throws
660  {
661  _M_refcount._M_swap(__r._M_refcount);
662  __r._M_ptr = 0;
663  }
664 
665  /** @brief Move-constructs a %__shared_ptr instance from @a __r.
666  * @param __r A %__shared_ptr rvalue.
667  * @post *this contains the old value of @a __r, @a __r is empty.
668  */
669  template<typename _Tp1>
670  __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r)
671  : _M_ptr(__r._M_ptr), _M_refcount() // never throws
672  {
673  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
674  _M_refcount._M_swap(__r._M_refcount);
675  __r._M_ptr = 0;
676  }
677 
678  /** @brief Constructs a %__shared_ptr that shares ownership with @a __r
679  * and stores a copy of the pointer stored in @a __r.
680  * @param __r A weak_ptr.
681  * @post use_count() == __r.use_count()
682  * @throw bad_weak_ptr when __r.expired(),
683  * in which case the constructor has no effect.
684  */
685  template<typename _Tp1>
686  explicit
687  __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
688  : _M_refcount(__r._M_refcount) // may throw
689  {
690  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
691  // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount)
692  // did not throw.
693  _M_ptr = __r._M_ptr;
694  }
695 
696  template<typename _Tp1, typename _Del>
697  explicit
698  __shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete;
699 
700  /**
701  * If an exception is thrown this constructor has no effect.
702  */
703  template<typename _Tp1, typename _Del>
704  explicit
705  __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
706  : _M_ptr(__r.get()), _M_refcount()
707  {
708  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
709  _Tp1* __tmp = __r.get();
710  _M_refcount = __shared_count<_Lp>(std::move(__r));
711  __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
712  }
713 
714 #if _GLIBCXX_DEPRECATED
715  /**
716  * @post use_count() == 1 and __r.get() == 0
717  */
718  template<typename _Tp1>
719  explicit
720  __shared_ptr(std::auto_ptr<_Tp1>&& __r)
721  : _M_ptr(__r.get()), _M_refcount()
722  {
723  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
724  // TODO requires _Tp1 is complete, delete __r.release() well-formed
725  _Tp1* __tmp = __r.get();
726  _M_refcount = __shared_count<_Lp>(std::move(__r));
727  __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
728  }
729 #endif
730 
731  template<typename _Tp1>
732  __shared_ptr&
733  operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
734  {
735  _M_ptr = __r._M_ptr;
736  _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
737  return *this;
738  }
739 
740 #if _GLIBCXX_DEPRECATED
741  template<typename _Tp1>
742  __shared_ptr&
743  operator=(std::auto_ptr<_Tp1>&& __r)
744  {
745  __shared_ptr(std::move(__r)).swap(*this);
746  return *this;
747  }
748 #endif
749 
750  __shared_ptr&
751  operator=(__shared_ptr&& __r)
752  {
753  __shared_ptr(std::move(__r)).swap(*this);
754  return *this;
755  }
756 
757  template<class _Tp1>
758  __shared_ptr&
759  operator=(__shared_ptr<_Tp1, _Lp>&& __r)
760  {
761  __shared_ptr(std::move(__r)).swap(*this);
762  return *this;
763  }
764 
765  template<typename _Tp1, typename _Del>
766  __shared_ptr&
767  operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete;
768 
769  template<typename _Tp1, typename _Del>
770  __shared_ptr&
771  operator=(std::unique_ptr<_Tp1, _Del>&& __r)
772  {
773  __shared_ptr(std::move(__r)).swap(*this);
774  return *this;
775  }
776 
777  void
778  reset() // never throws
779  { __shared_ptr().swap(*this); }
780 
781  template<typename _Tp1>
782  void
783  reset(_Tp1* __p) // _Tp1 must be complete.
784  {
785  // Catch self-reset errors.
786  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
787  __shared_ptr(__p).swap(*this);
788  }
789 
790  template<typename _Tp1, typename _Deleter>
791  void
792  reset(_Tp1* __p, _Deleter __d)
793  { __shared_ptr(__p, __d).swap(*this); }
794 
795  template<typename _Tp1, typename _Deleter, typename _Alloc>
796  void
797  reset(_Tp1* __p, _Deleter __d, const _Alloc& __a)
798  { __shared_ptr(__p, __d, __a).swap(*this); }
799 
800  // Allow class instantiation when _Tp is [cv-qual] void.
801  typename std::add_lvalue_reference<_Tp>::type
802  operator*() const // never throws
803  {
804  _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
805  return *_M_ptr;
806  }
807 
808  _Tp*
809  operator->() const // never throws
810  {
811  _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
812  return _M_ptr;
813  }
814 
815  _Tp*
816  get() const // never throws
817  { return _M_ptr; }
818 
819  // Implicit conversion to "bool"
820  private:
821  typedef _Tp* __shared_ptr::*__unspecified_bool_type;
822 
823  public:
824  operator __unspecified_bool_type() const // never throws
825  { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; }
826 
827  bool
828  unique() const // never throws
829  { return _M_refcount._M_unique(); }
830 
831  long
832  use_count() const // never throws
833  { return _M_refcount._M_get_use_count(); }
834 
835  void
836  swap(__shared_ptr<_Tp, _Lp>&& __other) // never throws
837  {
838  std::swap(_M_ptr, __other._M_ptr);
839  _M_refcount._M_swap(__other._M_refcount);
840  }
841 
842  template<typename _Tp1>
843  bool
844  owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
845  { return _M_refcount._M_less(__rhs._M_refcount); }
846 
847  template<typename _Tp1>
848  bool
849  owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
850  { return _M_refcount._M_less(__rhs._M_refcount); }
851 
852  protected:
853  // This constructor is non-standard, it is used by allocate_shared.
854  template<typename _Alloc, typename... _Args>
855  __shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
856  : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
857  std::forward<_Args>(__args)...)
858  {
859  // _M_ptr needs to point to the newly constructed object.
860  // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
861  void* __p = _M_refcount._M_get_deleter(typeid(__tag));
862  _M_ptr = static_cast<_Tp*>(__p);
863  __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
864  }
865 
866  template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
867  typename... _Args>
868  friend __shared_ptr<_Tp1, _Lp1>
869  __allocate_shared(_Alloc __a, _Args&&... __args);
870 
871  private:
872  void*
873  _M_get_deleter(const std::type_info& __ti) const
874  { return _M_refcount._M_get_deleter(__ti); }
875 
876  template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
877  template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
878 
879  template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
880  friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&);
881 
882  _Tp* _M_ptr; // Contained pointer.
883  __shared_count<_Lp> _M_refcount; // Reference counter.
884  };
885 
886  // 20.8.13.2.7 shared_ptr comparisons
887  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
888  inline bool
889  operator==(const __shared_ptr<_Tp1, _Lp>& __a,
890  const __shared_ptr<_Tp2, _Lp>& __b)
891  { return __a.get() == __b.get(); }
892 
893  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
894  inline bool
895  operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
896  const __shared_ptr<_Tp2, _Lp>& __b)
897  { return __a.get() != __b.get(); }
898 
899  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
900  inline bool
901  operator<(const __shared_ptr<_Tp1, _Lp>& __a,
902  const __shared_ptr<_Tp2, _Lp>& __b)
903  { return __a.get() < __b.get(); }
904 
905  template<typename _Sp>
906  struct _Sp_less : public binary_function<_Sp, _Sp, bool>
907  {
908  bool
909  operator()(const _Sp& __lhs, const _Sp& __rhs) const
910  {
911  return std::less<typename _Sp::element_type*>()(__lhs.get(),
912  __rhs.get());
913  }
914  };
915 
916  template<typename _Tp, _Lock_policy _Lp>
917  struct less<__shared_ptr<_Tp, _Lp>>
918  : public _Sp_less<__shared_ptr<_Tp, _Lp>>
919  { };
920 
921  // XXX LessThanComparable<_Tp> concept should provide >, >= and <=
922  template<typename _Tp, _Lock_policy _Lp>
923  inline bool
924  operator>(const __shared_ptr<_Tp, _Lp>& __a,
925  const __shared_ptr<_Tp, _Lp>& __b)
926  { return __a.get() > __b.get(); }
927 
928  template<typename _Tp, _Lock_policy _Lp>
929  inline bool
930  operator>=(const __shared_ptr<_Tp, _Lp>& __a,
931  const __shared_ptr<_Tp, _Lp>& __b)
932  { return __a.get() >= __b.get(); }
933 
934  template<typename _Tp, _Lock_policy _Lp>
935  inline bool
936  operator<=(const __shared_ptr<_Tp, _Lp>& __a,
937  const __shared_ptr<_Tp, _Lp>& __b)
938  { return __a.get() <= __b.get(); }
939 
940  // 2.2.3.8 shared_ptr specialized algorithms.
941  template<typename _Tp, _Lock_policy _Lp>
942  inline void
943  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b)
944  { __a.swap(__b); }
945 
946  template<typename _Tp, _Lock_policy _Lp>
947  inline void
948  swap(__shared_ptr<_Tp, _Lp>&& __a, __shared_ptr<_Tp, _Lp>& __b)
949  { __a.swap(__b); }
950 
951  template<typename _Tp, _Lock_policy _Lp>
952  inline void
953  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>&& __b)
954  { __a.swap(__b); }
955 
956  // 2.2.3.9 shared_ptr casts
957  /** @warning The seemingly equivalent
958  * <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code>
959  * will eventually result in undefined behaviour,
960  * attempting to delete the same object twice.
961  */
962  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
963  inline __shared_ptr<_Tp, _Lp>
964  static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
965  { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
966 
967  /** @warning The seemingly equivalent
968  * <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code>
969  * will eventually result in undefined behaviour,
970  * attempting to delete the same object twice.
971  */
972  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
973  inline __shared_ptr<_Tp, _Lp>
974  const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
975  { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
976 
977  /** @warning The seemingly equivalent
978  * <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code>
979  * will eventually result in undefined behaviour,
980  * attempting to delete the same object twice.
981  */
982  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
983  inline __shared_ptr<_Tp, _Lp>
984  dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
985  {
986  if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
987  return __shared_ptr<_Tp, _Lp>(__r, __p);
988  return __shared_ptr<_Tp, _Lp>();
989  }
990 
991  // 2.2.3.7 shared_ptr I/O
992  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
994  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
995  const __shared_ptr<_Tp, _Lp>& __p)
996  {
997  __os << __p.get();
998  return __os;
999  }
1000 
1001  // 2.2.3.10 shared_ptr get_deleter (experimental)
1002  template<typename _Del, typename _Tp, _Lock_policy _Lp>
1003  inline _Del*
1004  get_deleter(const __shared_ptr<_Tp, _Lp>& __p)
1005  { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); }
1006 
1007 
1008  template<typename _Tp, _Lock_policy _Lp>
1009  class __weak_ptr
1010  {
1011  public:
1012  typedef _Tp element_type;
1013 
1014  __weak_ptr()
1015  : _M_ptr(0), _M_refcount() // never throws
1016  { }
1017 
1018  // Generated copy constructor, assignment, destructor are fine.
1019 
1020  // The "obvious" converting constructor implementation:
1021  //
1022  // template<typename _Tp1>
1023  // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1024  // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1025  // { }
1026  //
1027  // has a serious problem.
1028  //
1029  // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
1030  // conversion may require access to *__r._M_ptr (virtual inheritance).
1031  //
1032  // It is not possible to avoid spurious access violations since
1033  // in multithreaded programs __r._M_ptr may be invalidated at any point.
1034  template<typename _Tp1>
1035  __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1036  : _M_refcount(__r._M_refcount) // never throws
1037  {
1038  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
1039  _M_ptr = __r.lock().get();
1040  }
1041 
1042  template<typename _Tp1>
1043  __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
1044  : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1045  { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
1046 
1047  template<typename _Tp1>
1048  __weak_ptr&
1049  operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws
1050  {
1051  _M_ptr = __r.lock().get();
1052  _M_refcount = __r._M_refcount;
1053  return *this;
1054  }
1055 
1056  template<typename _Tp1>
1057  __weak_ptr&
1058  operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
1059  {
1060  _M_ptr = __r._M_ptr;
1061  _M_refcount = __r._M_refcount;
1062  return *this;
1063  }
1064 
1065  __shared_ptr<_Tp, _Lp>
1066  lock() const // never throws
1067  {
1068 #ifdef __GTHREADS
1069  // Optimization: avoid throw overhead.
1070  if (expired())
1071  return __shared_ptr<element_type, _Lp>();
1072 
1073  __try
1074  {
1075  return __shared_ptr<element_type, _Lp>(*this);
1076  }
1077  __catch(const bad_weak_ptr&)
1078  {
1079  // Q: How can we get here?
1080  // A: Another thread may have invalidated r after the
1081  // use_count test above.
1082  return __shared_ptr<element_type, _Lp>();
1083  }
1084 
1085 #else
1086  // Optimization: avoid try/catch overhead when single threaded.
1087  return expired() ? __shared_ptr<element_type, _Lp>()
1088  : __shared_ptr<element_type, _Lp>(*this);
1089 
1090 #endif
1091  } // XXX MT
1092 
1093  long
1094  use_count() const // never throws
1095  { return _M_refcount._M_get_use_count(); }
1096 
1097  bool
1098  expired() const // never throws
1099  { return _M_refcount._M_get_use_count() == 0; }
1100 
1101  template<typename _Tp1>
1102  bool
1103  owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
1104  { return _M_refcount._M_less(__rhs._M_refcount); }
1105 
1106  template<typename _Tp1>
1107  bool
1108  owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
1109  { return _M_refcount._M_less(__rhs._M_refcount); }
1110 
1111  void
1112  reset() // never throws
1113  { __weak_ptr().swap(*this); }
1114 
1115  void
1116  swap(__weak_ptr& __s) // never throws
1117  {
1118  std::swap(_M_ptr, __s._M_ptr);
1119  _M_refcount._M_swap(__s._M_refcount);
1120  }
1121 
1122  // comparisons
1123  template<typename _Tp1>
1124  bool operator<(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1125  template<typename _Tp1>
1126  bool operator<=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1127  template<typename _Tp1>
1128  bool operator>(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1129  template<typename _Tp1>
1130  bool operator>=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1131 
1132  private:
1133  // Used by __enable_shared_from_this.
1134  void
1135  _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount)
1136  {
1137  _M_ptr = __ptr;
1138  _M_refcount = __refcount;
1139  }
1140 
1141  template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1142  template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1143  friend class __enable_shared_from_this<_Tp, _Lp>;
1144  friend class enable_shared_from_this<_Tp>;
1145 
1146  _Tp* _M_ptr; // Contained pointer.
1147  __weak_count<_Lp> _M_refcount; // Reference counter.
1148  };
1149 
1150  // 20.8.13.3.7 weak_ptr specialized algorithms.
1151  template<typename _Tp, _Lock_policy _Lp>
1152  inline void
1153  swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b)
1154  { __a.swap(__b); }
1155 
1156  /// owner_less
1157  template<typename _Tp> struct owner_less;
1158 
1159  template<typename _Tp, typename _Tp1>
1160  struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
1161  {
1162  bool
1163  operator()(const _Tp& __lhs, const _Tp& __rhs) const
1164  { return __lhs.owner_before(__rhs); }
1165  bool
1166  operator()(const _Tp& __lhs, const _Tp1& __rhs) const
1167  { return __lhs.owner_before(__rhs); }
1168  bool
1169  operator()(const _Tp1& __lhs, const _Tp& __rhs) const
1170  { return __lhs.owner_before(__rhs); }
1171  };
1172 
1173  template<typename _Tp, _Lock_policy _Lp>
1174  struct owner_less<__shared_ptr<_Tp, _Lp>>
1175  : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
1176  { };
1177 
1178  template<typename _Tp, _Lock_policy _Lp>
1179  struct owner_less<__weak_ptr<_Tp, _Lp>>
1180  : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
1181  {
1182  };
1183 
1184 
1185  template<typename _Tp, _Lock_policy _Lp>
1186  class __enable_shared_from_this
1187  {
1188  protected:
1189  __enable_shared_from_this() { }
1190 
1191  __enable_shared_from_this(const __enable_shared_from_this&) { }
1192 
1193  __enable_shared_from_this&
1194  operator=(const __enable_shared_from_this&)
1195  { return *this; }
1196 
1197  ~__enable_shared_from_this() { }
1198 
1199  public:
1200  __shared_ptr<_Tp, _Lp>
1201  shared_from_this()
1202  { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
1203 
1204  __shared_ptr<const _Tp, _Lp>
1205  shared_from_this() const
1206  { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
1207 
1208  private:
1209  template<typename _Tp1>
1210  void
1211  _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const
1212  { _M_weak_this._M_assign(__p, __n); }
1213 
1214  template<typename _Tp1>
1215  friend void
1216  __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
1217  const __enable_shared_from_this* __pe,
1218  const _Tp1* __px)
1219  {
1220  if (__pe != 0)
1221  __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1222  }
1223 
1224  mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
1225  };
1226 
1227  /**
1228  * @brief A smart pointer with reference-counted copy semantics.
1229  *
1230  * The object pointed to is deleted when the last shared_ptr pointing to
1231  * it is destroyed or reset.
1232  */
1233  template<typename _Tp>
1234  class shared_ptr
1235  : public __shared_ptr<_Tp>
1236  {
1237  public:
1238  shared_ptr()
1239  : __shared_ptr<_Tp>() { }
1240 
1241  template<typename _Tp1>
1242  explicit
1243  shared_ptr(_Tp1* __p)
1244  : __shared_ptr<_Tp>(__p) { }
1245 
1246  template<typename _Tp1, typename _Deleter>
1247  shared_ptr(_Tp1* __p, _Deleter __d)
1248  : __shared_ptr<_Tp>(__p, __d) { }
1249 
1250  template<typename _Tp1, typename _Deleter, typename _Alloc>
1251  shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
1252  : __shared_ptr<_Tp>(__p, __d, __a) { }
1253 
1254  // Aliasing constructor
1255  template<typename _Tp1>
1256  shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p)
1257  : __shared_ptr<_Tp>(__r, __p) { }
1258 
1259  template<typename _Tp1>
1260  shared_ptr(const shared_ptr<_Tp1>& __r)
1261  : __shared_ptr<_Tp>(__r) { }
1262 
1263  shared_ptr(shared_ptr&& __r)
1264  : __shared_ptr<_Tp>(std::move(__r)) { }
1265 
1266  template<typename _Tp1>
1267  shared_ptr(shared_ptr<_Tp1>&& __r)
1268  : __shared_ptr<_Tp>(std::move(__r)) { }
1269 
1270  template<typename _Tp1>
1271  explicit
1272  shared_ptr(const weak_ptr<_Tp1>& __r)
1273  : __shared_ptr<_Tp>(__r) { }
1274 
1275 #if _GLIBCXX_DEPRECATED
1276  template<typename _Tp1>
1277  explicit
1278  shared_ptr(std::auto_ptr<_Tp1>&& __r)
1279  : __shared_ptr<_Tp>(std::move(__r)) { }
1280 #endif
1281 
1282  template<typename _Tp1, typename _Del>
1283  explicit
1284  shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete;
1285 
1286  template<typename _Tp1, typename _Del>
1287  explicit
1288  shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
1289  : __shared_ptr<_Tp>(std::move(__r)) { }
1290 
1291  template<typename _Tp1>
1292  shared_ptr&
1293  operator=(const shared_ptr<_Tp1>& __r) // never throws
1294  {
1295  this->__shared_ptr<_Tp>::operator=(__r);
1296  return *this;
1297  }
1298 
1299 #if _GLIBCXX_DEPRECATED
1300  template<typename _Tp1>
1301  shared_ptr&
1302  operator=(std::auto_ptr<_Tp1>&& __r)
1303  {
1304  this->__shared_ptr<_Tp>::operator=(std::move(__r));
1305  return *this;
1306  }
1307 #endif
1308 
1309  shared_ptr&
1310  operator=(shared_ptr&& __r)
1311  {
1312  this->__shared_ptr<_Tp>::operator=(std::move(__r));
1313  return *this;
1314  }
1315 
1316  template<class _Tp1>
1317  shared_ptr&
1318  operator=(shared_ptr<_Tp1>&& __r)
1319  {
1320  this->__shared_ptr<_Tp>::operator=(std::move(__r));
1321  return *this;
1322  }
1323 
1324  template<typename _Tp1, typename _Del>
1325  shared_ptr&
1326  operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete;
1327 
1328  template<typename _Tp1, typename _Del>
1329  shared_ptr&
1330  operator=(std::unique_ptr<_Tp1, _Del>&& __r)
1331  {
1332  this->__shared_ptr<_Tp>::operator=(std::move(__r));
1333  return *this;
1334  }
1335 
1336  private:
1337  // This constructor is non-standard, it is used by allocate_shared.
1338  template<typename _Alloc, typename... _Args>
1339  shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
1340  : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
1341  { }
1342 
1343  template<typename _Tp1, typename _Alloc, typename... _Args>
1344  friend shared_ptr<_Tp1>
1345  allocate_shared(_Alloc __a, _Args&&... __args);
1346  };
1347 
1348  // 20.8.13.2.7 shared_ptr comparisons
1349  template<typename _Tp1, typename _Tp2>
1350  inline bool
1351  operator==(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1352  { return __a.get() == __b.get(); }
1353 
1354  template<typename _Tp1, typename _Tp2>
1355  inline bool
1356  operator!=(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1357  { return __a.get() != __b.get(); }
1358 
1359  template<typename _Tp1, typename _Tp2>
1360  inline bool
1361  operator<(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1362  { return __a.get() < __b.get(); }
1363 
1364  template<typename _Tp>
1365  struct less<shared_ptr<_Tp>>
1366  : public _Sp_less<shared_ptr<_Tp>>
1367  { };
1368 
1369  // 20.8.13.2.9 shared_ptr specialized algorithms.
1370  template<typename _Tp>
1371  inline void
1372  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b)
1373  { __a.swap(__b); }
1374 
1375  template<typename _Tp>
1376  inline void
1377  swap(shared_ptr<_Tp>&& __a, shared_ptr<_Tp>& __b)
1378  { __a.swap(__b); }
1379 
1380  template<typename _Tp>
1381  inline void
1382  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>&& __b)
1383  { __a.swap(__b); }
1384 
1385  // 20.8.13.2.10 shared_ptr casts.
1386  template<typename _Tp, typename _Tp1>
1387  inline shared_ptr<_Tp>
1388  static_pointer_cast(const shared_ptr<_Tp1>& __r)
1389  { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
1390 
1391  template<typename _Tp, typename _Tp1>
1392  inline shared_ptr<_Tp>
1393  const_pointer_cast(const shared_ptr<_Tp1>& __r)
1394  { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
1395 
1396  template<typename _Tp, typename _Tp1>
1397  inline shared_ptr<_Tp>
1398  dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
1399  {
1400  if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
1401  return shared_ptr<_Tp>(__r, __p);
1402  return shared_ptr<_Tp>();
1403  }
1404 
1405 
1406  /**
1407  * @brief A smart pointer with weak semantics.
1408  *
1409  * With forwarding constructors and assignment operators.
1410  */
1411  template<typename _Tp>
1412  class weak_ptr
1413  : public __weak_ptr<_Tp>
1414  {
1415  public:
1416  weak_ptr()
1417  : __weak_ptr<_Tp>() { }
1418 
1419  template<typename _Tp1>
1420  weak_ptr(const weak_ptr<_Tp1>& __r)
1421  : __weak_ptr<_Tp>(__r) { }
1422 
1423  template<typename _Tp1>
1424  weak_ptr(const shared_ptr<_Tp1>& __r)
1425  : __weak_ptr<_Tp>(__r) { }
1426 
1427  template<typename _Tp1>
1428  weak_ptr&
1429  operator=(const weak_ptr<_Tp1>& __r) // never throws
1430  {
1431  this->__weak_ptr<_Tp>::operator=(__r);
1432  return *this;
1433  }
1434 
1435  template<typename _Tp1>
1436  weak_ptr&
1437  operator=(const shared_ptr<_Tp1>& __r) // never throws
1438  {
1439  this->__weak_ptr<_Tp>::operator=(__r);
1440  return *this;
1441  }
1442 
1443  shared_ptr<_Tp>
1444  lock() const // never throws
1445  {
1446 #ifdef __GTHREADS
1447  if (this->expired())
1448  return shared_ptr<_Tp>();
1449 
1450  __try
1451  {
1452  return shared_ptr<_Tp>(*this);
1453  }
1454  __catch(const bad_weak_ptr&)
1455  {
1456  return shared_ptr<_Tp>();
1457  }
1458 #else
1459  return this->expired() ? shared_ptr<_Tp>()
1460  : shared_ptr<_Tp>(*this);
1461 #endif
1462  }
1463 
1464  // comparisons
1465  template<typename _Tp1>
1466  bool operator<(const weak_ptr<_Tp1>&) const = delete;
1467  template<typename _Tp1>
1468  bool operator<=(const weak_ptr<_Tp1>&) const = delete;
1469  template<typename _Tp1>
1470  bool operator>(const weak_ptr<_Tp1>&) const = delete;
1471  template<typename _Tp1>
1472  bool operator>=(const weak_ptr<_Tp1>&) const = delete;
1473  };
1474 
1475  // 20.8.13.3.7 weak_ptr specialized algorithms.
1476  template<typename _Tp>
1477  inline void
1478  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b)
1479  { __a.swap(__b); }
1480 
1481  /// owner_less
1482  template<typename _Tp>
1483  struct owner_less<shared_ptr<_Tp>>
1484  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
1485  { };
1486 
1487  template<typename _Tp>
1488  struct owner_less<weak_ptr<_Tp>>
1489  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
1490  { };
1491 
1492  /**
1493  * @brief Base class allowing use of member function shared_from_this.
1494  */
1495  template<typename _Tp>
1496  class enable_shared_from_this
1497  {
1498  protected:
1499  enable_shared_from_this() { }
1500 
1501  enable_shared_from_this(const enable_shared_from_this&) { }
1502 
1503  enable_shared_from_this&
1504  operator=(const enable_shared_from_this&)
1505  { return *this; }
1506 
1507  ~enable_shared_from_this() { }
1508 
1509  public:
1510  shared_ptr<_Tp>
1511  shared_from_this()
1512  { return shared_ptr<_Tp>(this->_M_weak_this); }
1513 
1514  shared_ptr<const _Tp>
1515  shared_from_this() const
1516  { return shared_ptr<const _Tp>(this->_M_weak_this); }
1517 
1518  private:
1519  template<typename _Tp1>
1520  void
1521  _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
1522  { _M_weak_this._M_assign(__p, __n); }
1523 
1524  template<typename _Tp1>
1525  friend void
1526  __enable_shared_from_this_helper(const __shared_count<>& __pn,
1527  const enable_shared_from_this* __pe,
1528  const _Tp1* __px)
1529  {
1530  if (__pe != 0)
1531  __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1532  }
1533 
1534  mutable weak_ptr<_Tp> _M_weak_this;
1535  };
1536 
1537  template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
1538  inline __shared_ptr<_Tp, _Lp>
1539  __allocate_shared(_Alloc __a, _Args&&... __args)
1540  {
1541  return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(),
1542  std::forward<_Alloc>(__a), std::forward<_Args>(__args)...);
1543  }
1544 
1545  template<typename _Tp, _Lock_policy _Lp, typename... _Args>
1546  inline __shared_ptr<_Tp, _Lp>
1547  __make_shared(_Args&&... __args)
1548  {
1549  typedef typename std::remove_const<_Tp>::type _Tp_nc;
1550  return __allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
1551  std::forward<_Args>(__args)...);
1552  }
1553 
1554  /** @brief Create an object that is owned by a shared_ptr.
1555  * @param __a An allocator.
1556  * @param __args Arguments for the @a _Tp object's constructor.
1557  * @return A shared_ptr that owns the newly created object.
1558  * @throw An exception thrown from @a _Alloc::allocate or from the
1559  * constructor of @a _Tp.
1560  *
1561  * A copy of @a __a will be used to allocate memory for the shared_ptr
1562  * and the new object.
1563  */
1564  template<typename _Tp, typename _Alloc, typename... _Args>
1565  inline shared_ptr<_Tp>
1566  allocate_shared(_Alloc __a, _Args&&... __args)
1567  {
1568  return shared_ptr<_Tp>(_Sp_make_shared_tag(), std::forward<_Alloc>(__a),
1569  std::forward<_Args>(__args)...);
1570  }
1571 
1572  /** @brief Create an object that is owned by a shared_ptr.
1573  * @param __args Arguments for the @a _Tp object's constructor.
1574  * @return A shared_ptr that owns the newly created object.
1575  * @throw std::bad_alloc, or an exception thrown from the
1576  * constructor of @a _Tp.
1577  */
1578  template<typename _Tp, typename... _Args>
1579  inline shared_ptr<_Tp>
1580  make_shared(_Args&&... __args)
1581  {
1582  typedef typename std::remove_const<_Tp>::type _Tp_nc;
1583  return allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
1584  std::forward<_Args>(__args)...);
1585  }
1586 
1587  // @} group pointer_abstractions
1588 
1589 _GLIBCXX_END_NAMESPACE
1590 
1591 #endif // _SHARED_PTR_H
20.7.12.2 unique_ptr for single objects.
Definition: unique_ptr.h:85
void lock(_L1 &, _L2 &, _L3 &...)
lock
The "standard" allocator, as per [20.4].Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manu...
Definition: allocator.h:60
is_reference
Definition: type_traits:88
reference_wrapper
Controlling output.This is the base class for all output streams. It provides text formatting of all ...
Definition: iosfwd:56
A simple smart pointer providing strict ownership semantics.
Definition: auto_ptr.h:85
Part of RTTI.
Definition: typeinfo:88
One of the comparison functors.
Definition: stl_function.h:226