libstdc++
shared_ptr.h
Go to the documentation of this file.
1 // shared_ptr and weak_ptr implementation -*- C++ -*-
2 
3 // Copyright (C) 2007-2015 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 // GCC Note: Based on files from version 1.32.0 of the Boost library.
26 
27 // shared_count.hpp
28 // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
29 
30 // shared_ptr.hpp
31 // Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32 // Copyright (C) 2001, 2002, 2003 Peter Dimov
33 
34 // weak_ptr.hpp
35 // Copyright (C) 2001, 2002, 2003 Peter Dimov
36 
37 // enable_shared_from_this.hpp
38 // Copyright (C) 2002 Peter Dimov
39 
40 // Distributed under the Boost Software License, Version 1.0. (See
41 // accompanying file LICENSE_1_0.txt or copy at
42 // http://www.boost.org/LICENSE_1_0.txt)
43 
44 /** @file bits/shared_ptr.h
45  * This is an internal header file, included by other library headers.
46  * Do not attempt to use it directly. @headername{memory}
47  */
48 
49 #ifndef _SHARED_PTR_H
50 #define _SHARED_PTR_H 1
51 
52 #include <bits/shared_ptr_base.h>
53 
54 namespace std _GLIBCXX_VISIBILITY(default)
55 {
56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
57 
58  /**
59  * @addtogroup pointer_abstractions
60  * @{
61  */
62 
63  /// 20.7.2.2.11 shared_ptr I/O
64  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
66  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
67  const __shared_ptr<_Tp, _Lp>& __p)
68  {
69  __os << __p.get();
70  return __os;
71  }
72 
73  /// 20.7.2.2.10 shared_ptr get_deleter
74  template<typename _Del, typename _Tp, _Lock_policy _Lp>
75  inline _Del*
76  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
77  {
78 #if __cpp_rtti
79  return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
80 #else
81  return 0;
82 #endif
83  }
84 
85 
86  /**
87  * @brief A smart pointer with reference-counted copy semantics.
88  *
89  * The object pointed to is deleted when the last shared_ptr pointing to
90  * it is destroyed or reset.
91  */
92  template<typename _Tp>
93  class shared_ptr : public __shared_ptr<_Tp>
94  {
95  template<typename _Ptr>
96  using _Convertible
97  = typename enable_if<is_convertible<_Ptr, _Tp*>::value>::type;
98 
99  public:
100  /**
101  * @brief Construct an empty %shared_ptr.
102  * @post use_count()==0 && get()==0
103  */
104  constexpr shared_ptr() noexcept
105  : __shared_ptr<_Tp>() { }
106 
107  shared_ptr(const shared_ptr&) noexcept = default;
108 
109  /**
110  * @brief Construct a %shared_ptr that owns the pointer @a __p.
111  * @param __p A pointer that is convertible to element_type*.
112  * @post use_count() == 1 && get() == __p
113  * @throw std::bad_alloc, in which case @c delete @a __p is called.
114  */
115  template<typename _Tp1>
116  explicit shared_ptr(_Tp1* __p)
117  : __shared_ptr<_Tp>(__p) { }
118 
119  /**
120  * @brief Construct a %shared_ptr that owns the pointer @a __p
121  * and the deleter @a __d.
122  * @param __p A pointer.
123  * @param __d A deleter.
124  * @post use_count() == 1 && get() == __p
125  * @throw std::bad_alloc, in which case @a __d(__p) is called.
126  *
127  * Requirements: _Deleter's copy constructor and destructor must
128  * not throw
129  *
130  * __shared_ptr will release __p by calling __d(__p)
131  */
132  template<typename _Tp1, typename _Deleter>
133  shared_ptr(_Tp1* __p, _Deleter __d)
134  : __shared_ptr<_Tp>(__p, __d) { }
135 
136  /**
137  * @brief Construct a %shared_ptr that owns a null pointer
138  * and the deleter @a __d.
139  * @param __p A null pointer constant.
140  * @param __d A deleter.
141  * @post use_count() == 1 && get() == __p
142  * @throw std::bad_alloc, in which case @a __d(__p) is called.
143  *
144  * Requirements: _Deleter's copy constructor and destructor must
145  * not throw
146  *
147  * The last owner will call __d(__p)
148  */
149  template<typename _Deleter>
150  shared_ptr(nullptr_t __p, _Deleter __d)
151  : __shared_ptr<_Tp>(__p, __d) { }
152 
153  /**
154  * @brief Construct a %shared_ptr that owns the pointer @a __p
155  * and the deleter @a __d.
156  * @param __p A pointer.
157  * @param __d A deleter.
158  * @param __a An allocator.
159  * @post use_count() == 1 && get() == __p
160  * @throw std::bad_alloc, in which case @a __d(__p) is called.
161  *
162  * Requirements: _Deleter's copy constructor and destructor must
163  * not throw _Alloc's copy constructor and destructor must not
164  * throw.
165  *
166  * __shared_ptr will release __p by calling __d(__p)
167  */
168  template<typename _Tp1, typename _Deleter, typename _Alloc>
169  shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
170  : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
171 
172  /**
173  * @brief Construct a %shared_ptr that owns a null pointer
174  * and the deleter @a __d.
175  * @param __p A null pointer constant.
176  * @param __d A deleter.
177  * @param __a An allocator.
178  * @post use_count() == 1 && get() == __p
179  * @throw std::bad_alloc, in which case @a __d(__p) is called.
180  *
181  * Requirements: _Deleter's copy constructor and destructor must
182  * not throw _Alloc's copy constructor and destructor must not
183  * throw.
184  *
185  * The last owner will call __d(__p)
186  */
187  template<typename _Deleter, typename _Alloc>
188  shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
189  : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
190 
191  // Aliasing constructor
192 
193  /**
194  * @brief Constructs a %shared_ptr instance that stores @a __p
195  * and shares ownership with @a __r.
196  * @param __r A %shared_ptr.
197  * @param __p A pointer that will remain valid while @a *__r is valid.
198  * @post get() == __p && use_count() == __r.use_count()
199  *
200  * This can be used to construct a @c shared_ptr to a sub-object
201  * of an object managed by an existing @c shared_ptr.
202  *
203  * @code
204  * shared_ptr< pair<int,int> > pii(new pair<int,int>());
205  * shared_ptr<int> pi(pii, &pii->first);
206  * assert(pii.use_count() == 2);
207  * @endcode
208  */
209  template<typename _Tp1>
210  shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
211  : __shared_ptr<_Tp>(__r, __p) { }
212 
213  /**
214  * @brief If @a __r is empty, constructs an empty %shared_ptr;
215  * otherwise construct a %shared_ptr that shares ownership
216  * with @a __r.
217  * @param __r A %shared_ptr.
218  * @post get() == __r.get() && use_count() == __r.use_count()
219  */
220  template<typename _Tp1, typename = _Convertible<_Tp1*>>
221  shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
222  : __shared_ptr<_Tp>(__r) { }
223 
224  /**
225  * @brief Move-constructs a %shared_ptr instance from @a __r.
226  * @param __r A %shared_ptr rvalue.
227  * @post *this contains the old value of @a __r, @a __r is empty.
228  */
229  shared_ptr(shared_ptr&& __r) noexcept
230  : __shared_ptr<_Tp>(std::move(__r)) { }
231 
232  /**
233  * @brief Move-constructs a %shared_ptr instance from @a __r.
234  * @param __r A %shared_ptr rvalue.
235  * @post *this contains the old value of @a __r, @a __r is empty.
236  */
237  template<typename _Tp1, typename = _Convertible<_Tp1*>>
238  shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
239  : __shared_ptr<_Tp>(std::move(__r)) { }
240 
241  /**
242  * @brief Constructs a %shared_ptr that shares ownership with @a __r
243  * and stores a copy of the pointer stored in @a __r.
244  * @param __r A weak_ptr.
245  * @post use_count() == __r.use_count()
246  * @throw bad_weak_ptr when __r.expired(),
247  * in which case the constructor has no effect.
248  */
249  template<typename _Tp1>
250  explicit shared_ptr(const weak_ptr<_Tp1>& __r)
251  : __shared_ptr<_Tp>(__r) { }
252 
253 #if _GLIBCXX_USE_DEPRECATED
254  template<typename _Tp1>
256 #endif
257 
258  // _GLIBCXX_RESOLVE_LIB_DEFECTS
259  // 2399. shared_ptr's constructor from unique_ptr should be constrained
260  template<typename _Tp1, typename _Del, typename
261  = _Convertible<typename unique_ptr<_Tp1, _Del>::pointer>>
263  : __shared_ptr<_Tp>(std::move(__r)) { }
264 
265  /**
266  * @brief Construct an empty %shared_ptr.
267  * @post use_count() == 0 && get() == nullptr
268  */
269  constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
270 
271  shared_ptr& operator=(const shared_ptr&) noexcept = default;
272 
273  template<typename _Tp1>
274  shared_ptr&
275  operator=(const shared_ptr<_Tp1>& __r) noexcept
276  {
277  this->__shared_ptr<_Tp>::operator=(__r);
278  return *this;
279  }
280 
281 #if _GLIBCXX_USE_DEPRECATED
282  template<typename _Tp1>
283  shared_ptr&
284  operator=(std::auto_ptr<_Tp1>&& __r)
285  {
286  this->__shared_ptr<_Tp>::operator=(std::move(__r));
287  return *this;
288  }
289 #endif
290 
291  shared_ptr&
292  operator=(shared_ptr&& __r) noexcept
293  {
294  this->__shared_ptr<_Tp>::operator=(std::move(__r));
295  return *this;
296  }
297 
298  template<class _Tp1>
299  shared_ptr&
300  operator=(shared_ptr<_Tp1>&& __r) noexcept
301  {
302  this->__shared_ptr<_Tp>::operator=(std::move(__r));
303  return *this;
304  }
305 
306  template<typename _Tp1, typename _Del>
307  shared_ptr&
308  operator=(std::unique_ptr<_Tp1, _Del>&& __r)
309  {
310  this->__shared_ptr<_Tp>::operator=(std::move(__r));
311  return *this;
312  }
313 
314  private:
315  // This constructor is non-standard, it is used by allocate_shared.
316  template<typename _Alloc, typename... _Args>
317  shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
318  _Args&&... __args)
319  : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
320  { }
321 
322  template<typename _Tp1, typename _Alloc, typename... _Args>
323  friend shared_ptr<_Tp1>
324  allocate_shared(const _Alloc& __a, _Args&&... __args);
325 
326  // This constructor is non-standard, it is used by weak_ptr::lock().
327  shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
328  : __shared_ptr<_Tp>(__r, std::nothrow) { }
329 
330  friend class weak_ptr<_Tp>;
331  };
332 
333  // 20.7.2.2.7 shared_ptr comparisons
334  template<typename _Tp1, typename _Tp2>
335  inline bool
336  operator==(const shared_ptr<_Tp1>& __a,
337  const shared_ptr<_Tp2>& __b) noexcept
338  { return __a.get() == __b.get(); }
339 
340  template<typename _Tp>
341  inline bool
342  operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
343  { return !__a; }
344 
345  template<typename _Tp>
346  inline bool
347  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
348  { return !__a; }
349 
350  template<typename _Tp1, typename _Tp2>
351  inline bool
352  operator!=(const shared_ptr<_Tp1>& __a,
353  const shared_ptr<_Tp2>& __b) noexcept
354  { return __a.get() != __b.get(); }
355 
356  template<typename _Tp>
357  inline bool
358  operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
359  { return (bool)__a; }
360 
361  template<typename _Tp>
362  inline bool
363  operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
364  { return (bool)__a; }
365 
366  template<typename _Tp1, typename _Tp2>
367  inline bool
368  operator<(const shared_ptr<_Tp1>& __a,
369  const shared_ptr<_Tp2>& __b) noexcept
370  {
371  typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
372  return std::less<_CT>()(__a.get(), __b.get());
373  }
374 
375  template<typename _Tp>
376  inline bool
377  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
378  { return std::less<_Tp*>()(__a.get(), nullptr); }
379 
380  template<typename _Tp>
381  inline bool
382  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
383  { return std::less<_Tp*>()(nullptr, __a.get()); }
384 
385  template<typename _Tp1, typename _Tp2>
386  inline bool
387  operator<=(const shared_ptr<_Tp1>& __a,
388  const shared_ptr<_Tp2>& __b) noexcept
389  { return !(__b < __a); }
390 
391  template<typename _Tp>
392  inline bool
393  operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
394  { return !(nullptr < __a); }
395 
396  template<typename _Tp>
397  inline bool
398  operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
399  { return !(__a < nullptr); }
400 
401  template<typename _Tp1, typename _Tp2>
402  inline bool
403  operator>(const shared_ptr<_Tp1>& __a,
404  const shared_ptr<_Tp2>& __b) noexcept
405  { return (__b < __a); }
406 
407  template<typename _Tp>
408  inline bool
409  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
410  { return std::less<_Tp*>()(nullptr, __a.get()); }
411 
412  template<typename _Tp>
413  inline bool
414  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
415  { return std::less<_Tp*>()(__a.get(), nullptr); }
416 
417  template<typename _Tp1, typename _Tp2>
418  inline bool
419  operator>=(const shared_ptr<_Tp1>& __a,
420  const shared_ptr<_Tp2>& __b) noexcept
421  { return !(__a < __b); }
422 
423  template<typename _Tp>
424  inline bool
425  operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
426  { return !(__a < nullptr); }
427 
428  template<typename _Tp>
429  inline bool
430  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
431  { return !(nullptr < __a); }
432 
433  template<typename _Tp>
434  struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
435  { };
436 
437  // 20.7.2.2.8 shared_ptr specialized algorithms.
438  template<typename _Tp>
439  inline void
440  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
441  { __a.swap(__b); }
442 
443  // 20.7.2.2.9 shared_ptr casts.
444  template<typename _Tp, typename _Tp1>
445  inline shared_ptr<_Tp>
446  static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
447  { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
448 
449  template<typename _Tp, typename _Tp1>
450  inline shared_ptr<_Tp>
451  const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
452  { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
453 
454  template<typename _Tp, typename _Tp1>
455  inline shared_ptr<_Tp>
456  dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
457  {
458  if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
459  return shared_ptr<_Tp>(__r, __p);
460  return shared_ptr<_Tp>();
461  }
462 
463 
464  /**
465  * @brief A smart pointer with weak semantics.
466  *
467  * With forwarding constructors and assignment operators.
468  */
469  template<typename _Tp>
470  class weak_ptr : public __weak_ptr<_Tp>
471  {
472  template<typename _Ptr>
473  using _Convertible
474  = typename enable_if<is_convertible<_Ptr, _Tp*>::value>::type;
475 
476  public:
477  constexpr weak_ptr() noexcept = default;
478 
479  template<typename _Tp1, typename = _Convertible<_Tp1*>>
480  weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
481  : __weak_ptr<_Tp>(__r) { }
482 
483  weak_ptr(const weak_ptr&) noexcept = default;
484 
485  template<typename _Tp1, typename = _Convertible<_Tp1*>>
486  weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
487  : __weak_ptr<_Tp>(__r) { }
488 
489  weak_ptr(weak_ptr&&) noexcept = default;
490 
491  template<typename _Tp1, typename = _Convertible<_Tp1*>>
492  weak_ptr(weak_ptr<_Tp1>&& __r) noexcept
493  : __weak_ptr<_Tp>(std::move(__r)) { }
494 
495  weak_ptr&
496  operator=(const weak_ptr& __r) noexcept = default;
497 
498  template<typename _Tp1>
499  weak_ptr&
500  operator=(const weak_ptr<_Tp1>& __r) noexcept
501  {
502  this->__weak_ptr<_Tp>::operator=(__r);
503  return *this;
504  }
505 
506  template<typename _Tp1>
507  weak_ptr&
508  operator=(const shared_ptr<_Tp1>& __r) noexcept
509  {
510  this->__weak_ptr<_Tp>::operator=(__r);
511  return *this;
512  }
513 
514  weak_ptr&
515  operator=(weak_ptr&& __r) noexcept = default;
516 
517  template<typename _Tp1>
518  weak_ptr&
519  operator=(weak_ptr<_Tp1>&& __r) noexcept
520  {
521  this->__weak_ptr<_Tp>::operator=(std::move(__r));
522  return *this;
523  }
524 
526  lock() const noexcept
527  { return shared_ptr<_Tp>(*this, std::nothrow); }
528  };
529 
530  // 20.7.2.3.6 weak_ptr specialized algorithms.
531  template<typename _Tp>
532  inline void
533  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
534  { __a.swap(__b); }
535 
536 
537  /// Primary template owner_less
538  template<typename _Tp>
539  struct owner_less;
540 
541  /// Partial specialization of owner_less for shared_ptr.
542  template<typename _Tp>
543  struct owner_less<shared_ptr<_Tp>>
544  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
545  { };
546 
547  /// Partial specialization of owner_less for weak_ptr.
548  template<typename _Tp>
549  struct owner_less<weak_ptr<_Tp>>
550  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
551  { };
552 
553  /**
554  * @brief Base class allowing use of member function shared_from_this.
555  */
556  template<typename _Tp>
558  {
559  protected:
560  constexpr enable_shared_from_this() noexcept { }
561 
563 
565  operator=(const enable_shared_from_this&) noexcept
566  { return *this; }
567 
569 
570  public:
572  shared_from_this()
573  { return shared_ptr<_Tp>(this->_M_weak_this); }
574 
576  shared_from_this() const
577  { return shared_ptr<const _Tp>(this->_M_weak_this); }
578 
579  private:
580  template<typename _Tp1>
581  void
582  _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
583  { _M_weak_this._M_assign(__p, __n); }
584 
585  template<typename _Tp1, typename _Tp2>
586  friend void
587  __enable_shared_from_this_helper(const __shared_count<>&,
589  const _Tp2*) noexcept;
590 
591  mutable weak_ptr<_Tp> _M_weak_this;
592  };
593 
594  template<typename _Tp1, typename _Tp2>
595  inline void
596  __enable_shared_from_this_helper(const __shared_count<>& __pn,
598  __pe, const _Tp2* __px) noexcept
599  {
600  if (__pe != nullptr)
601  __pe->_M_weak_assign(const_cast<_Tp2*>(__px), __pn);
602  }
603 
604  /**
605  * @brief Create an object that is owned by a shared_ptr.
606  * @param __a An allocator.
607  * @param __args Arguments for the @a _Tp object's constructor.
608  * @return A shared_ptr that owns the newly created object.
609  * @throw An exception thrown from @a _Alloc::allocate or from the
610  * constructor of @a _Tp.
611  *
612  * A copy of @a __a will be used to allocate memory for the shared_ptr
613  * and the new object.
614  */
615  template<typename _Tp, typename _Alloc, typename... _Args>
616  inline shared_ptr<_Tp>
617  allocate_shared(const _Alloc& __a, _Args&&... __args)
618  {
619  return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
620  std::forward<_Args>(__args)...);
621  }
622 
623  /**
624  * @brief Create an object that is owned by a shared_ptr.
625  * @param __args Arguments for the @a _Tp object's constructor.
626  * @return A shared_ptr that owns the newly created object.
627  * @throw std::bad_alloc, or an exception thrown from the
628  * constructor of @a _Tp.
629  */
630  template<typename _Tp, typename... _Args>
631  inline shared_ptr<_Tp>
632  make_shared(_Args&&... __args)
633  {
634  typedef typename std::remove_const<_Tp>::type _Tp_nc;
635  return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
636  std::forward<_Args>(__args)...);
637  }
638 
639  /// std::hash specialization for shared_ptr.
640  template<typename _Tp>
641  struct hash<shared_ptr<_Tp>>
642  : public __hash_base<size_t, shared_ptr<_Tp>>
643  {
644  size_t
645  operator()(const shared_ptr<_Tp>& __s) const noexcept
646  { return std::hash<_Tp*>()(__s.get()); }
647  };
648 
649  // @} group pointer_abstractions
650 
651 _GLIBCXX_END_NAMESPACE_VERSION
652 } // namespace
653 
654 #endif // _SHARED_PTR_H
shared_ptr(const shared_ptr< _Tp1 > &__r, _Tp *__p) noexcept
Constructs a shared_ptr instance that stores __p and shares ownership with __r.
Definition: shared_ptr.h:210
_Del * get_deleter(const __shared_ptr< _Tp, _Lp > &__p) noexcept
20.7.2.2.10 shared_ptr get_deleter
Definition: shared_ptr.h:76
shared_ptr(_Tp1 *__p, _Deleter __d, _Alloc __a)
Construct a shared_ptr that owns the pointer __p and the deleter __d.
Definition: shared_ptr.h:169
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
Construct a shared_ptr that owns a null pointer and the deleter __d.
Definition: shared_ptr.h:188
friend shared_ptr< _Tp1 > allocate_shared(const _Alloc &__a, _Args &&...__args)
Create an object that is owned by a shared_ptr.
Definition: shared_ptr.h:617
The standard allocator, as per [20.4].
Definition: allocator.h:92
Template class basic_ostream.
Definition: iosfwd:86
shared_ptr(nullptr_t __p, _Deleter __d)
Construct a shared_ptr that owns a null pointer and the deleter __d.
Definition: shared_ptr.h:150
Partial specializations for pointer types.
A smart pointer with reference-counted copy semantics.
Definition: shared_ptr.h:93
One of the comparison functors.
Definition: stl_function.h:341
Primary class template hash.
Definition: system_error:134
shared_ptr(const shared_ptr< _Tp1 > &__r) noexcept
If __r is empty, constructs an empty shared_ptr; otherwise construct a shared_ptr that shares ownersh...
Definition: shared_ptr.h:221
shared_ptr(_Tp1 *__p, _Deleter __d)
Construct a shared_ptr that owns the pointer __p and the deleter __d.
Definition: shared_ptr.h:133
constexpr shared_ptr(nullptr_t) noexcept
Construct an empty shared_ptr.
Definition: shared_ptr.h:269
A smart pointer with weak semantics.
Definition: shared_ptr.h:470
shared_ptr(shared_ptr &&__r) noexcept
Move-constructs a shared_ptr instance from __r.
Definition: shared_ptr.h:229
shared_ptr< _Tp > make_shared(_Args &&...__args)
Create an object that is owned by a shared_ptr.
Definition: shared_ptr.h:632
20.7.1.2 unique_ptr for single objects.
Definition: unique_ptr.h:129
A simple smart pointer providing strict ownership semantics.
Definition: auto_ptr.h:87
Primary template owner_less.
Definition: shared_ptr.h:539
shared_ptr(const weak_ptr< _Tp1 > &__r)
Constructs a shared_ptr that shares ownership with __r and stores a copy of the pointer stored in __r...
Definition: shared_ptr.h:250
shared_ptr(_Tp1 *__p)
Construct a shared_ptr that owns the pointer __p.
Definition: shared_ptr.h:116
void lock(_L1 &__l1, _L2 &__l2, _L3 &...__l3)
Generic lock.
Definition: mutex:659
constexpr shared_ptr() noexcept
Construct an empty shared_ptr.
Definition: shared_ptr.h:104
ISO C++ entities toplevel namespace is std.
Base class allowing use of member function shared_from_this.
Definition: shared_ptr.h:557
shared_ptr(shared_ptr< _Tp1 > &&__r) noexcept
Move-constructs a shared_ptr instance from __r.
Definition: shared_ptr.h:238