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-2018 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
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  template<typename _Del, typename _Tp, _Lock_policy _Lp>
74  inline _Del*
75  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
76  {
77 #if __cpp_rtti
78  return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
79 #else
80  return 0;
81 #endif
82  }
83 
84  /// 20.7.2.2.10 shared_ptr get_deleter
85  template<typename _Del, typename _Tp>
86  inline _Del*
87  get_deleter(const shared_ptr<_Tp>& __p) noexcept
88  {
89 #if __cpp_rtti
90  return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
91 #else
92  return 0;
93 #endif
94  }
95 
96  /**
97  * @brief A smart pointer with reference-counted copy semantics.
98  *
99  * The object pointed to is deleted when the last shared_ptr pointing to
100  * it is destroyed or reset.
101  */
102  template<typename _Tp>
103  class shared_ptr : public __shared_ptr<_Tp>
104  {
105  template<typename... _Args>
106  using _Constructible = typename enable_if<
107  is_constructible<__shared_ptr<_Tp>, _Args...>::value
108  >::type;
109 
110  template<typename _Arg>
111  using _Assignable = typename enable_if<
113  >::type;
114 
115  public:
116 
117  using element_type = typename __shared_ptr<_Tp>::element_type;
118 
119 #if __cplusplus > 201402L
120 # define __cpp_lib_shared_ptr_weak_type 201606
121  using weak_type = weak_ptr<_Tp>;
122 #endif
123  /**
124  * @brief Construct an empty %shared_ptr.
125  * @post use_count()==0 && get()==0
126  */
127  constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }
128 
129  shared_ptr(const shared_ptr&) noexcept = default;
130 
131  /**
132  * @brief Construct a %shared_ptr that owns the pointer @a __p.
133  * @param __p A pointer that is convertible to element_type*.
134  * @post use_count() == 1 && get() == __p
135  * @throw std::bad_alloc, in which case @c delete @a __p is called.
136  */
137  template<typename _Yp, typename = _Constructible<_Yp*>>
138  explicit
139  shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }
140 
141  /**
142  * @brief Construct a %shared_ptr that owns the pointer @a __p
143  * and the deleter @a __d.
144  * @param __p A pointer.
145  * @param __d A deleter.
146  * @post use_count() == 1 && get() == __p
147  * @throw std::bad_alloc, in which case @a __d(__p) is called.
148  *
149  * Requirements: _Deleter's copy constructor and destructor must
150  * not throw
151  *
152  * __shared_ptr will release __p by calling __d(__p)
153  */
154  template<typename _Yp, typename _Deleter,
155  typename = _Constructible<_Yp*, _Deleter>>
156  shared_ptr(_Yp* __p, _Deleter __d)
157  : __shared_ptr<_Tp>(__p, std::move(__d)) { }
158 
159  /**
160  * @brief Construct a %shared_ptr that owns a null pointer
161  * and the deleter @a __d.
162  * @param __p A null pointer constant.
163  * @param __d A deleter.
164  * @post use_count() == 1 && get() == __p
165  * @throw std::bad_alloc, in which case @a __d(__p) is called.
166  *
167  * Requirements: _Deleter's copy constructor and destructor must
168  * not throw
169  *
170  * The last owner will call __d(__p)
171  */
172  template<typename _Deleter>
173  shared_ptr(nullptr_t __p, _Deleter __d)
174  : __shared_ptr<_Tp>(__p, std::move(__d)) { }
175 
176  /**
177  * @brief Construct a %shared_ptr that owns the pointer @a __p
178  * and the deleter @a __d.
179  * @param __p A pointer.
180  * @param __d A deleter.
181  * @param __a An allocator.
182  * @post use_count() == 1 && get() == __p
183  * @throw std::bad_alloc, in which case @a __d(__p) is called.
184  *
185  * Requirements: _Deleter's copy constructor and destructor must
186  * not throw _Alloc's copy constructor and destructor must not
187  * throw.
188  *
189  * __shared_ptr will release __p by calling __d(__p)
190  */
191  template<typename _Yp, typename _Deleter, typename _Alloc,
192  typename = _Constructible<_Yp*, _Deleter, _Alloc>>
193  shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
194  : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
195 
196  /**
197  * @brief Construct a %shared_ptr that owns a null pointer
198  * and the deleter @a __d.
199  * @param __p A null pointer constant.
200  * @param __d A deleter.
201  * @param __a An allocator.
202  * @post use_count() == 1 && get() == __p
203  * @throw std::bad_alloc, in which case @a __d(__p) is called.
204  *
205  * Requirements: _Deleter's copy constructor and destructor must
206  * not throw _Alloc's copy constructor and destructor must not
207  * throw.
208  *
209  * The last owner will call __d(__p)
210  */
211  template<typename _Deleter, typename _Alloc>
212  shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
213  : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
214 
215  // Aliasing constructor
216 
217  /**
218  * @brief Constructs a %shared_ptr instance that stores @a __p
219  * and shares ownership with @a __r.
220  * @param __r A %shared_ptr.
221  * @param __p A pointer that will remain valid while @a *__r is valid.
222  * @post get() == __p && use_count() == __r.use_count()
223  *
224  * This can be used to construct a @c shared_ptr to a sub-object
225  * of an object managed by an existing @c shared_ptr.
226  *
227  * @code
228  * shared_ptr< pair<int,int> > pii(new pair<int,int>());
229  * shared_ptr<int> pi(pii, &pii->first);
230  * assert(pii.use_count() == 2);
231  * @endcode
232  */
233  template<typename _Yp>
234  shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
235  : __shared_ptr<_Tp>(__r, __p) { }
236 
237  /**
238  * @brief If @a __r is empty, constructs an empty %shared_ptr;
239  * otherwise construct a %shared_ptr that shares ownership
240  * with @a __r.
241  * @param __r A %shared_ptr.
242  * @post get() == __r.get() && use_count() == __r.use_count()
243  */
244  template<typename _Yp,
245  typename = _Constructible<const shared_ptr<_Yp>&>>
246  shared_ptr(const shared_ptr<_Yp>& __r) noexcept
247  : __shared_ptr<_Tp>(__r) { }
248 
249  /**
250  * @brief Move-constructs a %shared_ptr instance from @a __r.
251  * @param __r A %shared_ptr rvalue.
252  * @post *this contains the old value of @a __r, @a __r is empty.
253  */
254  shared_ptr(shared_ptr&& __r) noexcept
255  : __shared_ptr<_Tp>(std::move(__r)) { }
256 
257  /**
258  * @brief Move-constructs a %shared_ptr instance from @a __r.
259  * @param __r A %shared_ptr rvalue.
260  * @post *this contains the old value of @a __r, @a __r is empty.
261  */
262  template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
263  shared_ptr(shared_ptr<_Yp>&& __r) noexcept
264  : __shared_ptr<_Tp>(std::move(__r)) { }
265 
266  /**
267  * @brief Constructs a %shared_ptr that shares ownership with @a __r
268  * and stores a copy of the pointer stored in @a __r.
269  * @param __r A weak_ptr.
270  * @post use_count() == __r.use_count()
271  * @throw bad_weak_ptr when __r.expired(),
272  * in which case the constructor has no effect.
273  */
274  template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
275  explicit shared_ptr(const weak_ptr<_Yp>& __r)
276  : __shared_ptr<_Tp>(__r) { }
277 
278 #if _GLIBCXX_USE_DEPRECATED
279 #pragma GCC diagnostic push
280 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
281  template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
282  shared_ptr(auto_ptr<_Yp>&& __r);
283 #pragma GCC diagnostic pop
284 #endif
285 
286  // _GLIBCXX_RESOLVE_LIB_DEFECTS
287  // 2399. shared_ptr's constructor from unique_ptr should be constrained
288  template<typename _Yp, typename _Del,
289  typename = _Constructible<unique_ptr<_Yp, _Del>>>
291  : __shared_ptr<_Tp>(std::move(__r)) { }
292 
293 #if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED
294  // This non-standard constructor exists to support conversions that
295  // were possible in C++11 and C++14 but are ill-formed in C++17.
296  // If an exception is thrown this constructor has no effect.
297  template<typename _Yp, typename _Del,
298  _Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
299  shared_ptr(unique_ptr<_Yp, _Del>&& __r)
300  : __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
301 #endif
302 
303  /**
304  * @brief Construct an empty %shared_ptr.
305  * @post use_count() == 0 && get() == nullptr
306  */
307  constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
308 
309  shared_ptr& operator=(const shared_ptr&) noexcept = default;
310 
311  template<typename _Yp>
312  _Assignable<const shared_ptr<_Yp>&>
313  operator=(const shared_ptr<_Yp>& __r) noexcept
314  {
315  this->__shared_ptr<_Tp>::operator=(__r);
316  return *this;
317  }
318 
319 #if _GLIBCXX_USE_DEPRECATED
320 #pragma GCC diagnostic push
321 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
322  template<typename _Yp>
323  _Assignable<auto_ptr<_Yp>>
324  operator=(auto_ptr<_Yp>&& __r)
325  {
326  this->__shared_ptr<_Tp>::operator=(std::move(__r));
327  return *this;
328  }
329 #pragma GCC diagnostic pop
330 #endif
331 
332  shared_ptr&
333  operator=(shared_ptr&& __r) noexcept
334  {
335  this->__shared_ptr<_Tp>::operator=(std::move(__r));
336  return *this;
337  }
338 
339  template<class _Yp>
340  _Assignable<shared_ptr<_Yp>>
341  operator=(shared_ptr<_Yp>&& __r) noexcept
342  {
343  this->__shared_ptr<_Tp>::operator=(std::move(__r));
344  return *this;
345  }
346 
347  template<typename _Yp, typename _Del>
348  _Assignable<unique_ptr<_Yp, _Del>>
349  operator=(unique_ptr<_Yp, _Del>&& __r)
350  {
351  this->__shared_ptr<_Tp>::operator=(std::move(__r));
352  return *this;
353  }
354 
355  private:
356  // This constructor is non-standard, it is used by allocate_shared.
357  template<typename _Alloc, typename... _Args>
358  shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
359  _Args&&... __args)
360  : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
361  { }
362 
363  template<typename _Yp, typename _Alloc, typename... _Args>
364  friend shared_ptr<_Yp>
365  allocate_shared(const _Alloc& __a, _Args&&... __args);
366 
367  // This constructor is non-standard, it is used by weak_ptr::lock().
368  shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
369  : __shared_ptr<_Tp>(__r, std::nothrow) { }
370 
371  friend class weak_ptr<_Tp>;
372  };
373 
374 #if __cpp_deduction_guides >= 201606
375  template<typename _Tp>
376  shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
377  template<typename _Tp, typename _Del>
378  shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>;
379 #endif
380 
381  // 20.7.2.2.7 shared_ptr comparisons
382  template<typename _Tp, typename _Up>
383  inline bool
384  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
385  { return __a.get() == __b.get(); }
386 
387  template<typename _Tp>
388  inline bool
389  operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
390  { return !__a; }
391 
392  template<typename _Tp>
393  inline bool
394  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
395  { return !__a; }
396 
397  template<typename _Tp, typename _Up>
398  inline bool
399  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
400  { return __a.get() != __b.get(); }
401 
402  template<typename _Tp>
403  inline bool
404  operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
405  { return (bool)__a; }
406 
407  template<typename _Tp>
408  inline bool
409  operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
410  { return (bool)__a; }
411 
412  template<typename _Tp, typename _Up>
413  inline bool
414  operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
415  {
416  using _Tp_elt = typename shared_ptr<_Tp>::element_type;
417  using _Up_elt = typename shared_ptr<_Up>::element_type;
418  using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
419  return less<_Vp>()(__a.get(), __b.get());
420  }
421 
422  template<typename _Tp>
423  inline bool
424  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
425  {
426  using _Tp_elt = typename shared_ptr<_Tp>::element_type;
427  return less<_Tp_elt*>()(__a.get(), nullptr);
428  }
429 
430  template<typename _Tp>
431  inline bool
432  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
433  {
434  using _Tp_elt = typename shared_ptr<_Tp>::element_type;
435  return less<_Tp_elt*>()(nullptr, __a.get());
436  }
437 
438  template<typename _Tp, typename _Up>
439  inline bool
440  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
441  { return !(__b < __a); }
442 
443  template<typename _Tp>
444  inline bool
445  operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
446  { return !(nullptr < __a); }
447 
448  template<typename _Tp>
449  inline bool
450  operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
451  { return !(__a < nullptr); }
452 
453  template<typename _Tp, typename _Up>
454  inline bool
455  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
456  { return (__b < __a); }
457 
458  template<typename _Tp>
459  inline bool
460  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
461  { return nullptr < __a; }
462 
463  template<typename _Tp>
464  inline bool
465  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
466  { return __a < nullptr; }
467 
468  template<typename _Tp, typename _Up>
469  inline bool
470  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
471  { return !(__a < __b); }
472 
473  template<typename _Tp>
474  inline bool
475  operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
476  { return !(__a < nullptr); }
477 
478  template<typename _Tp>
479  inline bool
480  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
481  { return !(nullptr < __a); }
482 
483  template<typename _Tp>
484  struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
485  { };
486 
487  // 20.7.2.2.8 shared_ptr specialized algorithms.
488  template<typename _Tp>
489  inline void
490  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
491  { __a.swap(__b); }
492 
493  // 20.7.2.2.9 shared_ptr casts.
494  template<typename _Tp, typename _Up>
495  inline shared_ptr<_Tp>
496  static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
497  {
498  using _Sp = shared_ptr<_Tp>;
499  return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
500  }
501 
502  template<typename _Tp, typename _Up>
503  inline shared_ptr<_Tp>
504  const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
505  {
506  using _Sp = shared_ptr<_Tp>;
507  return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
508  }
509 
510  template<typename _Tp, typename _Up>
511  inline shared_ptr<_Tp>
512  dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
513  {
514  using _Sp = shared_ptr<_Tp>;
515  if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
516  return _Sp(__r, __p);
517  return _Sp();
518  }
519 
520 #if __cplusplus > 201402L
521  template<typename _Tp, typename _Up>
522  inline shared_ptr<_Tp>
523  reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
524  {
525  using _Sp = shared_ptr<_Tp>;
526  return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
527  }
528 #endif
529 
530  /**
531  * @brief A smart pointer with weak semantics.
532  *
533  * With forwarding constructors and assignment operators.
534  */
535  template<typename _Tp>
536  class weak_ptr : public __weak_ptr<_Tp>
537  {
538  template<typename _Arg>
539  using _Constructible = typename enable_if<
541  >::type;
542 
543  template<typename _Arg>
544  using _Assignable = typename enable_if<
545  is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
546  >::type;
547 
548  public:
549  constexpr weak_ptr() noexcept = default;
550 
551  template<typename _Yp,
552  typename = _Constructible<const shared_ptr<_Yp>&>>
553  weak_ptr(const shared_ptr<_Yp>& __r) noexcept
554  : __weak_ptr<_Tp>(__r) { }
555 
556  weak_ptr(const weak_ptr&) noexcept = default;
557 
558  template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
559  weak_ptr(const weak_ptr<_Yp>& __r) noexcept
560  : __weak_ptr<_Tp>(__r) { }
561 
562  weak_ptr(weak_ptr&&) noexcept = default;
563 
564  template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
565  weak_ptr(weak_ptr<_Yp>&& __r) noexcept
566  : __weak_ptr<_Tp>(std::move(__r)) { }
567 
568  weak_ptr&
569  operator=(const weak_ptr& __r) noexcept = default;
570 
571  template<typename _Yp>
572  _Assignable<const weak_ptr<_Yp>&>
573  operator=(const weak_ptr<_Yp>& __r) noexcept
574  {
575  this->__weak_ptr<_Tp>::operator=(__r);
576  return *this;
577  }
578 
579  template<typename _Yp>
580  _Assignable<const shared_ptr<_Yp>&>
581  operator=(const shared_ptr<_Yp>& __r) noexcept
582  {
583  this->__weak_ptr<_Tp>::operator=(__r);
584  return *this;
585  }
586 
587  weak_ptr&
588  operator=(weak_ptr&& __r) noexcept = default;
589 
590  template<typename _Yp>
591  _Assignable<weak_ptr<_Yp>>
592  operator=(weak_ptr<_Yp>&& __r) noexcept
593  {
594  this->__weak_ptr<_Tp>::operator=(std::move(__r));
595  return *this;
596  }
597 
599  lock() const noexcept
600  { return shared_ptr<_Tp>(*this, std::nothrow); }
601  };
602 
603 #if __cpp_deduction_guides >= 201606
604  template<typename _Tp>
606 #endif
607 
608  // 20.7.2.3.6 weak_ptr specialized algorithms.
609  template<typename _Tp>
610  inline void
611  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
612  { __a.swap(__b); }
613 
614 
615  /// Primary template owner_less
616  template<typename _Tp = void>
617  struct owner_less;
618 
619  /// Void specialization of owner_less
620  template<>
621  struct owner_less<void> : _Sp_owner_less<void, void>
622  { };
623 
624  /// Partial specialization of owner_less for shared_ptr.
625  template<typename _Tp>
626  struct owner_less<shared_ptr<_Tp>>
627  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
628  { };
629 
630  /// Partial specialization of owner_less for weak_ptr.
631  template<typename _Tp>
632  struct owner_less<weak_ptr<_Tp>>
633  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
634  { };
635 
636  /**
637  * @brief Base class allowing use of member function shared_from_this.
638  */
639  template<typename _Tp>
641  {
642  protected:
643  constexpr enable_shared_from_this() noexcept { }
644 
646 
648  operator=(const enable_shared_from_this&) noexcept
649  { return *this; }
650 
652 
653  public:
655  shared_from_this()
656  { return shared_ptr<_Tp>(this->_M_weak_this); }
657 
659  shared_from_this() const
660  { return shared_ptr<const _Tp>(this->_M_weak_this); }
661 
662 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
663 #define __cpp_lib_enable_shared_from_this 201603
665  weak_from_this() noexcept
666  { return this->_M_weak_this; }
667 
669  weak_from_this() const noexcept
670  { return this->_M_weak_this; }
671 #endif
672 
673  private:
674  template<typename _Tp1>
675  void
676  _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
677  { _M_weak_this._M_assign(__p, __n); }
678 
679  // Found by ADL when this is an associated class.
680  friend const enable_shared_from_this*
681  __enable_shared_from_this_base(const __shared_count<>&,
682  const enable_shared_from_this* __p)
683  { return __p; }
684 
685  template<typename, _Lock_policy>
686  friend class __shared_ptr;
687 
688  mutable weak_ptr<_Tp> _M_weak_this;
689  };
690 
691  /**
692  * @brief Create an object that is owned by a shared_ptr.
693  * @param __a An allocator.
694  * @param __args Arguments for the @a _Tp object's constructor.
695  * @return A shared_ptr that owns the newly created object.
696  * @throw An exception thrown from @a _Alloc::allocate or from the
697  * constructor of @a _Tp.
698  *
699  * A copy of @a __a will be used to allocate memory for the shared_ptr
700  * and the new object.
701  */
702  template<typename _Tp, typename _Alloc, typename... _Args>
703  inline shared_ptr<_Tp>
704  allocate_shared(const _Alloc& __a, _Args&&... __args)
705  {
706  return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
707  std::forward<_Args>(__args)...);
708  }
709 
710  /**
711  * @brief Create an object that is owned by a shared_ptr.
712  * @param __args Arguments for the @a _Tp object's constructor.
713  * @return A shared_ptr that owns the newly created object.
714  * @throw std::bad_alloc, or an exception thrown from the
715  * constructor of @a _Tp.
716  */
717  template<typename _Tp, typename... _Args>
718  inline shared_ptr<_Tp>
719  make_shared(_Args&&... __args)
720  {
721  typedef typename std::remove_const<_Tp>::type _Tp_nc;
722  return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
723  std::forward<_Args>(__args)...);
724  }
725 
726  /// std::hash specialization for shared_ptr.
727  template<typename _Tp>
728  struct hash<shared_ptr<_Tp>>
729  : public __hash_base<size_t, shared_ptr<_Tp>>
730  {
731  size_t
732  operator()(const shared_ptr<_Tp>& __s) const noexcept
733  {
735  }
736  };
737 
738  // @} group pointer_abstractions
739 
740 _GLIBCXX_END_NAMESPACE_VERSION
741 } // namespace
742 
743 #endif // _SHARED_PTR_H
is_assignable
Definition: type_traits:1060
shared_ptr(shared_ptr &&__r) noexcept
Move-constructs a shared_ptr instance from __r.
A smart pointer with weak semantics.
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
Construct a shared_ptr that owns a null pointer and the deleter __d.
Define a member typedef type only if a boolean constant is true.
Definition: type_traits:1987
shared_ptr< _Tp > allocate_shared(const _Alloc &__a, _Args &&... __args)
Create an object that is owned by a shared_ptr.
Primary class template hash.
Definition: system_error:142
Base class allowing use of member function shared_from_this.
friend shared_ptr< _Yp > allocate_shared(const _Alloc &__a, _Args &&... __args)
Create an object that is owned by a shared_ptr.
shared_ptr(_Yp *__p, _Deleter __d, _Alloc __a)
Construct a shared_ptr that owns the pointer __p and the deleter __d.
shared_ptr< _Tp > make_shared(_Args &&... __args)
Create an object that is owned by a shared_ptr.
shared_ptr(const shared_ptr< _Yp > &__r) noexcept
If __r is empty, constructs an empty shared_ptr; otherwise construct a shared_ptr that shares ownersh...
shared_ptr(const shared_ptr< _Yp > &__r, element_type *__p) noexcept
Constructs a shared_ptr instance that stores __p and shares ownership with __r.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition: move.h:74
shared_ptr(_Yp *__p)
Construct a shared_ptr that owns the pointer __p.
ISO C++ entities toplevel namespace is std.
is_constructible
Definition: type_traits:932
The standard allocator, as per [20.4].
Definition: allocator.h:108
shared_ptr(nullptr_t __p, _Deleter __d)
Construct a shared_ptr that owns a null pointer and the deleter __d.
shared_ptr(shared_ptr< _Yp > &&__r) noexcept
Move-constructs a shared_ptr instance from __r.
constexpr shared_ptr() noexcept
Construct an empty shared_ptr.
shared_ptr(const weak_ptr< _Yp > &__r)
Constructs a shared_ptr that shares ownership with __r and stores a copy of the pointer stored in __r...
shared_ptr(_Yp *__p, _Deleter __d)
Construct a shared_ptr that owns the pointer __p and the deleter __d.
20.7.1.2 unique_ptr for single objects.
Definition: unique_ptr.h:160
constexpr shared_ptr(nullptr_t) noexcept
Construct an empty shared_ptr.
A simple smart pointer providing strict ownership semantics.
Definition: auto_ptr.h:89
Primary template owner_less.
A smart pointer with reference-counted copy semantics.
Template class basic_ostream.
Definition: iosfwd:86