libstdc++
unique_ptr.h
Go to the documentation of this file.
1 // unique_ptr implementation -*- C++ -*-
2 
3 // Copyright (C) 2008-2017 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 /** @file bits/unique_ptr.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{memory}
28  */
29 
30 #ifndef _UNIQUE_PTR_H
31 #define _UNIQUE_PTR_H 1
32 
33 #include <bits/c++config.h>
34 #include <debug/assertions.h>
35 #include <type_traits>
36 #include <utility>
37 #include <tuple>
38 #include <bits/stl_function.h>
39 #include <bits/functional_hash.h>
40 
41 namespace std _GLIBCXX_VISIBILITY(default)
42 {
43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 
45  /**
46  * @addtogroup pointer_abstractions
47  * @{
48  */
49 
50 #if _GLIBCXX_USE_DEPRECATED
51  template<typename> class auto_ptr;
52 #endif
53 
54  /// Primary template of default_delete, used by unique_ptr
55  template<typename _Tp>
57  {
58  /// Default constructor
59  constexpr default_delete() noexcept = default;
60 
61  /** @brief Converting constructor.
62  *
63  * Allows conversion from a deleter for arrays of another type, @p _Up,
64  * only if @p _Up* is convertible to @p _Tp*.
65  */
66  template<typename _Up, typename = typename
67  enable_if<is_convertible<_Up*, _Tp*>::value>::type>
68  default_delete(const default_delete<_Up>&) noexcept { }
69 
70  /// Calls @c delete @p __ptr
71  void
72  operator()(_Tp* __ptr) const
73  {
74  static_assert(!is_void<_Tp>::value,
75  "can't delete pointer to incomplete type");
76  static_assert(sizeof(_Tp)>0,
77  "can't delete pointer to incomplete type");
78  delete __ptr;
79  }
80  };
81 
82  // _GLIBCXX_RESOLVE_LIB_DEFECTS
83  // DR 740 - omit specialization for array objects with a compile time length
84  /// Specialization for arrays, default_delete.
85  template<typename _Tp>
86  struct default_delete<_Tp[]>
87  {
88  public:
89  /// Default constructor
90  constexpr default_delete() noexcept = default;
91 
92  /** @brief Converting constructor.
93  *
94  * Allows conversion from a deleter for arrays of another type, such as
95  * a const-qualified version of @p _Tp.
96  *
97  * Conversions from types derived from @c _Tp are not allowed because
98  * it is unsafe to @c delete[] an array of derived types through a
99  * pointer to the base type.
100  */
101  template<typename _Up, typename = typename
102  enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
103  default_delete(const default_delete<_Up[]>&) noexcept { }
104 
105  /// Calls @c delete[] @p __ptr
106  template<typename _Up>
107  typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
108  operator()(_Up* __ptr) const
109  {
110  static_assert(sizeof(_Tp)>0,
111  "can't delete pointer to incomplete type");
112  delete [] __ptr;
113  }
114  };
115 
116  template <typename _Tp, typename _Dp>
117  class __uniq_ptr_impl
118  {
119  template <typename _Up, typename _Ep, typename = void>
120  struct _Ptr
121  {
122  using type = _Up*;
123  };
124 
125  template <typename _Up, typename _Ep>
126  struct
127  _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
128  {
129  using type = typename remove_reference<_Ep>::type::pointer;
130  };
131 
132  public:
133  using _DeleterConstraint = enable_if<
134  __and_<__not_<is_pointer<_Dp>>,
135  is_default_constructible<_Dp>>::value>;
136 
137  using pointer = typename _Ptr<_Tp, _Dp>::type;
138 
139  __uniq_ptr_impl() = default;
140  __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
141 
142  template<typename _Del>
143  __uniq_ptr_impl(pointer __p, _Del&& __d)
144  : _M_t(__p, std::forward<_Del>(__d)) { }
145 
146  pointer& _M_ptr() { return std::get<0>(_M_t); }
147  pointer _M_ptr() const { return std::get<0>(_M_t); }
148  _Dp& _M_deleter() { return std::get<1>(_M_t); }
149  const _Dp& _M_deleter() const { return std::get<1>(_M_t); }
150 
151  private:
152  tuple<pointer, _Dp> _M_t;
153  };
154 
155  /// 20.7.1.2 unique_ptr for single objects.
156  template <typename _Tp, typename _Dp = default_delete<_Tp>>
158  {
159  template <class _Up>
160  using _DeleterConstraint =
161  typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
162 
163  __uniq_ptr_impl<_Tp, _Dp> _M_t;
164 
165  public:
166  using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167  using element_type = _Tp;
168  using deleter_type = _Dp;
169 
170  // helper template for detecting a safe conversion from another
171  // unique_ptr
172  template<typename _Up, typename _Ep>
173  using __safe_conversion_up = __and_<
174  is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
175  __not_<is_array<_Up>>
176  >;
177 
178  // Constructors.
179 
180  /// Default constructor, creates a unique_ptr that owns nothing.
181  template <typename _Up = _Dp,
182  typename = _DeleterConstraint<_Up>>
183  constexpr unique_ptr() noexcept
184  : _M_t()
185  { }
186 
187  /** Takes ownership of a pointer.
188  *
189  * @param __p A pointer to an object of @c element_type
190  *
191  * The deleter will be value-initialized.
192  */
193  template <typename _Up = _Dp,
194  typename = _DeleterConstraint<_Up>>
195  explicit
196  unique_ptr(pointer __p) noexcept
197  : _M_t(__p)
198  { }
199 
200  /** Takes ownership of a pointer.
201  *
202  * @param __p A pointer to an object of @c element_type
203  * @param __d A reference to a deleter.
204  *
205  * The deleter will be initialized with @p __d
206  */
207  unique_ptr(pointer __p,
208  typename conditional<is_reference<deleter_type>::value,
209  deleter_type, const deleter_type&>::type __d) noexcept
210  : _M_t(__p, __d) { }
211 
212  /** Takes ownership of a pointer.
213  *
214  * @param __p A pointer to an object of @c element_type
215  * @param __d An rvalue reference to a deleter.
216  *
217  * The deleter will be initialized with @p std::move(__d)
218  */
219  unique_ptr(pointer __p,
220  typename remove_reference<deleter_type>::type&& __d) noexcept
221  : _M_t(std::move(__p), std::move(__d))
223  "rvalue deleter bound to reference"); }
224 
225  /// Creates a unique_ptr that owns nothing.
226  template <typename _Up = _Dp,
227  typename = _DeleterConstraint<_Up>>
228  constexpr unique_ptr(nullptr_t) noexcept : _M_t() { }
229 
230  // Move constructors.
231 
232  /// Move constructor.
233  unique_ptr(unique_ptr&& __u) noexcept
234  : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
235 
236  /** @brief Converting constructor from another type
237  *
238  * Requires that the pointer owned by @p __u is convertible to the
239  * type of pointer owned by this object, @p __u does not own an array,
240  * and @p __u has a compatible deleter type.
241  */
242  template<typename _Up, typename _Ep, typename = _Require<
243  __safe_conversion_up<_Up, _Ep>,
244  typename conditional<is_reference<_Dp>::value,
245  is_same<_Ep, _Dp>,
246  is_convertible<_Ep, _Dp>>::type>>
248  : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
249  { }
250 
251 #if _GLIBCXX_USE_DEPRECATED
252  /// Converting constructor from @c auto_ptr
253  template<typename _Up, typename = _Require<
254  is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
255  unique_ptr(auto_ptr<_Up>&& __u) noexcept;
256 #endif
257 
258  /// Destructor, invokes the deleter if the stored pointer is not null.
259  ~unique_ptr() noexcept
260  {
261  auto& __ptr = _M_t._M_ptr();
262  if (__ptr != nullptr)
263  get_deleter()(__ptr);
264  __ptr = pointer();
265  }
266 
267  // Assignment.
268 
269  /** @brief Move assignment operator.
270  *
271  * @param __u The object to transfer ownership from.
272  *
273  * Invokes the deleter first if this object owns a pointer.
274  */
275  unique_ptr&
276  operator=(unique_ptr&& __u) noexcept
277  {
278  reset(__u.release());
279  get_deleter() = std::forward<deleter_type>(__u.get_deleter());
280  return *this;
281  }
282 
283  /** @brief Assignment from another type.
284  *
285  * @param __u The object to transfer ownership from, which owns a
286  * convertible pointer to a non-array object.
287  *
288  * Invokes the deleter first if this object owns a pointer.
289  */
290  template<typename _Up, typename _Ep>
291  typename enable_if< __and_<
292  __safe_conversion_up<_Up, _Ep>,
293  is_assignable<deleter_type&, _Ep&&>
294  >::value,
295  unique_ptr&>::type
297  {
298  reset(__u.release());
299  get_deleter() = std::forward<_Ep>(__u.get_deleter());
300  return *this;
301  }
302 
303  /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
304  unique_ptr&
305  operator=(nullptr_t) noexcept
306  {
307  reset();
308  return *this;
309  }
310 
311  // Observers.
312 
313  /// Dereference the stored pointer.
314  typename add_lvalue_reference<element_type>::type
315  operator*() const
316  {
317  __glibcxx_assert(get() != pointer());
318  return *get();
319  }
320 
321  /// Return the stored pointer.
322  pointer
323  operator->() const noexcept
324  {
325  _GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
326  return get();
327  }
328 
329  /// Return the stored pointer.
330  pointer
331  get() const noexcept
332  { return _M_t._M_ptr(); }
333 
334  /// Return a reference to the stored deleter.
335  deleter_type&
336  get_deleter() noexcept
337  { return _M_t._M_deleter(); }
338 
339  /// Return a reference to the stored deleter.
340  const deleter_type&
341  get_deleter() const noexcept
342  { return _M_t._M_deleter(); }
343 
344  /// Return @c true if the stored pointer is not null.
345  explicit operator bool() const noexcept
346  { return get() == pointer() ? false : true; }
347 
348  // Modifiers.
349 
350  /// Release ownership of any stored pointer.
351  pointer
352  release() noexcept
353  {
354  pointer __p = get();
355  _M_t._M_ptr() = pointer();
356  return __p;
357  }
358 
359  /** @brief Replace the stored pointer.
360  *
361  * @param __p The new pointer to store.
362  *
363  * The deleter will be invoked if a pointer is already owned.
364  */
365  void
366  reset(pointer __p = pointer()) noexcept
367  {
368  using std::swap;
369  swap(_M_t._M_ptr(), __p);
370  if (__p != pointer())
371  get_deleter()(__p);
372  }
373 
374  /// Exchange the pointer and deleter with another object.
375  void
376  swap(unique_ptr& __u) noexcept
377  {
378  using std::swap;
379  swap(_M_t, __u._M_t);
380  }
381 
382  // Disable copy from lvalue.
383  unique_ptr(const unique_ptr&) = delete;
384  unique_ptr& operator=(const unique_ptr&) = delete;
385  };
386 
387  /// 20.7.1.3 unique_ptr for array objects with a runtime length
388  // [unique.ptr.runtime]
389  // _GLIBCXX_RESOLVE_LIB_DEFECTS
390  // DR 740 - omit specialization for array objects with a compile time length
391  template<typename _Tp, typename _Dp>
392  class unique_ptr<_Tp[], _Dp>
393  {
394  template <typename _Up>
395  using _DeleterConstraint =
396  typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
397 
398  __uniq_ptr_impl<_Tp, _Dp> _M_t;
399 
400  template<typename _Up>
401  using __remove_cv = typename remove_cv<_Up>::type;
402 
403  // like is_base_of<_Tp, _Up> but false if unqualified types are the same
404  template<typename _Up>
405  using __is_derived_Tp
406  = __and_< is_base_of<_Tp, _Up>,
407  __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
408 
409  public:
410  using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
411  using element_type = _Tp;
412  using deleter_type = _Dp;
413 
414  // helper template for detecting a safe conversion from another
415  // unique_ptr
416  template<typename _Up, typename _Ep,
417  typename _UPtr = unique_ptr<_Up, _Ep>,
418  typename _UP_pointer = typename _UPtr::pointer,
419  typename _UP_element_type = typename _UPtr::element_type>
420  using __safe_conversion_up = __and_<
422  is_same<pointer, element_type*>,
423  is_same<_UP_pointer, _UP_element_type*>,
424  is_convertible<_UP_element_type(*)[], element_type(*)[]>
425  >;
426 
427  // helper template for detecting a safe conversion from a raw pointer
428  template<typename _Up>
429  using __safe_conversion_raw = __and_<
430  __or_<__or_<is_same<_Up, pointer>,
431  is_same<_Up, nullptr_t>>,
432  __and_<is_pointer<_Up>,
433  is_same<pointer, element_type*>,
434  is_convertible<
435  typename remove_pointer<_Up>::type(*)[],
436  element_type(*)[]>
437  >
438  >
439  >;
440 
441  // Constructors.
442 
443  /// Default constructor, creates a unique_ptr that owns nothing.
444  template <typename _Up = _Dp,
445  typename = _DeleterConstraint<_Up>>
446  constexpr unique_ptr() noexcept
447  : _M_t()
448  { }
449 
450  /** Takes ownership of a pointer.
451  *
452  * @param __p A pointer to an array of a type safely convertible
453  * to an array of @c element_type
454  *
455  * The deleter will be value-initialized.
456  */
457  template<typename _Up,
458  typename _Vp = _Dp,
459  typename = _DeleterConstraint<_Vp>,
460  typename = typename enable_if<
461  __safe_conversion_raw<_Up>::value, bool>::type>
462  explicit
463  unique_ptr(_Up __p) noexcept
464  : _M_t(__p)
465  { }
466 
467  /** Takes ownership of a pointer.
468  *
469  * @param __p A pointer to an array of a type safely convertible
470  * to an array of @c element_type
471  * @param __d A reference to a deleter.
472  *
473  * The deleter will be initialized with @p __d
474  */
475  template<typename _Up,
476  typename = typename enable_if<
477  __safe_conversion_raw<_Up>::value, bool>::type>
478  unique_ptr(_Up __p,
479  typename conditional<is_reference<deleter_type>::value,
480  deleter_type, const deleter_type&>::type __d) noexcept
481  : _M_t(__p, __d) { }
482 
483  /** Takes ownership of a pointer.
484  *
485  * @param __p A pointer to an array of a type safely convertible
486  * to an array of @c element_type
487  * @param __d A reference to a deleter.
488  *
489  * The deleter will be initialized with @p std::move(__d)
490  */
491  template<typename _Up,
492  typename = typename enable_if<
493  __safe_conversion_raw<_Up>::value, bool>::type>
494  unique_ptr(_Up __p, typename
495  remove_reference<deleter_type>::type&& __d) noexcept
496  : _M_t(std::move(__p), std::move(__d))
497  { static_assert(!is_reference<deleter_type>::value,
498  "rvalue deleter bound to reference"); }
499 
500  /// Move constructor.
501  unique_ptr(unique_ptr&& __u) noexcept
502  : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
503 
504  /// Creates a unique_ptr that owns nothing.
505  template <typename _Up = _Dp,
506  typename = _DeleterConstraint<_Up>>
507  constexpr unique_ptr(nullptr_t) noexcept : _M_t() { }
508 
509  template<typename _Up, typename _Ep, typename = _Require<
510  __safe_conversion_up<_Up, _Ep>,
511  typename conditional<is_reference<_Dp>::value,
512  is_same<_Ep, _Dp>,
513  is_convertible<_Ep, _Dp>>::type>>
514  unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
515  : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
516  { }
517 
518  /// Destructor, invokes the deleter if the stored pointer is not null.
520  {
521  auto& __ptr = _M_t._M_ptr();
522  if (__ptr != nullptr)
523  get_deleter()(__ptr);
524  __ptr = pointer();
525  }
526 
527  // Assignment.
528 
529  /** @brief Move assignment operator.
530  *
531  * @param __u The object to transfer ownership from.
532  *
533  * Invokes the deleter first if this object owns a pointer.
534  */
535  unique_ptr&
536  operator=(unique_ptr&& __u) noexcept
537  {
538  reset(__u.release());
539  get_deleter() = std::forward<deleter_type>(__u.get_deleter());
540  return *this;
541  }
542 
543  /** @brief Assignment from another type.
544  *
545  * @param __u The object to transfer ownership from, which owns a
546  * convertible pointer to an array object.
547  *
548  * Invokes the deleter first if this object owns a pointer.
549  */
550  template<typename _Up, typename _Ep>
551  typename
552  enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
553  is_assignable<deleter_type&, _Ep&&>
554  >::value,
555  unique_ptr&>::type
557  {
558  reset(__u.release());
559  get_deleter() = std::forward<_Ep>(__u.get_deleter());
560  return *this;
561  }
562 
563  /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
564  unique_ptr&
565  operator=(nullptr_t) noexcept
566  {
567  reset();
568  return *this;
569  }
570 
571  // Observers.
572 
573  /// Access an element of owned array.
574  typename std::add_lvalue_reference<element_type>::type
575  operator[](size_t __i) const
576  {
577  __glibcxx_assert(get() != pointer());
578  return get()[__i];
579  }
580 
581  /// Return the stored pointer.
582  pointer
583  get() const noexcept
584  { return _M_t._M_ptr(); }
585 
586  /// Return a reference to the stored deleter.
587  deleter_type&
588  get_deleter() noexcept
589  { return _M_t._M_deleter(); }
590 
591  /// Return a reference to the stored deleter.
592  const deleter_type&
593  get_deleter() const noexcept
594  { return _M_t._M_deleter(); }
595 
596  /// Return @c true if the stored pointer is not null.
597  explicit operator bool() const noexcept
598  { return get() == pointer() ? false : true; }
599 
600  // Modifiers.
601 
602  /// Release ownership of any stored pointer.
603  pointer
604  release() noexcept
605  {
606  pointer __p = get();
607  _M_t._M_ptr() = pointer();
608  return __p;
609  }
610 
611  /** @brief Replace the stored pointer.
612  *
613  * @param __p The new pointer to store.
614  *
615  * The deleter will be invoked if a pointer is already owned.
616  */
617  template <typename _Up,
618  typename = _Require<
619  __or_<is_same<_Up, pointer>,
620  __and_<is_same<pointer, element_type*>,
622  is_convertible<
623  typename remove_pointer<_Up>::type(*)[],
624  element_type(*)[]
625  >
626  >
627  >
628  >>
629  void
630  reset(_Up __p) noexcept
631  {
632  pointer __ptr = __p;
633  using std::swap;
634  swap(_M_t._M_ptr(), __ptr);
635  if (__ptr != nullptr)
636  get_deleter()(__ptr);
637  }
638 
639  void reset(nullptr_t = nullptr) noexcept
640  {
641  reset(pointer());
642  }
643 
644  /// Exchange the pointer and deleter with another object.
645  void
646  swap(unique_ptr& __u) noexcept
647  {
648  using std::swap;
649  swap(_M_t, __u._M_t);
650  }
651 
652  // Disable copy from lvalue.
653  unique_ptr(const unique_ptr&) = delete;
654  unique_ptr& operator=(const unique_ptr&) = delete;
655  };
656 
657  template<typename _Tp, typename _Dp>
658  inline
659 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
660  // Constrained free swap overload, see p0185r1
661  typename enable_if<__is_swappable<_Dp>::value>::type
662 #else
663  void
664 #endif
665  swap(unique_ptr<_Tp, _Dp>& __x,
666  unique_ptr<_Tp, _Dp>& __y) noexcept
667  { __x.swap(__y); }
668 
669 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
670  template<typename _Tp, typename _Dp>
671  typename enable_if<!__is_swappable<_Dp>::value>::type
672  swap(unique_ptr<_Tp, _Dp>&,
673  unique_ptr<_Tp, _Dp>&) = delete;
674 #endif
675 
676  template<typename _Tp, typename _Dp,
677  typename _Up, typename _Ep>
678  inline bool
679  operator==(const unique_ptr<_Tp, _Dp>& __x,
680  const unique_ptr<_Up, _Ep>& __y)
681  { return __x.get() == __y.get(); }
682 
683  template<typename _Tp, typename _Dp>
684  inline bool
685  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
686  { return !__x; }
687 
688  template<typename _Tp, typename _Dp>
689  inline bool
690  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
691  { return !__x; }
692 
693  template<typename _Tp, typename _Dp,
694  typename _Up, typename _Ep>
695  inline bool
696  operator!=(const unique_ptr<_Tp, _Dp>& __x,
697  const unique_ptr<_Up, _Ep>& __y)
698  { return __x.get() != __y.get(); }
699 
700  template<typename _Tp, typename _Dp>
701  inline bool
702  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
703  { return (bool)__x; }
704 
705  template<typename _Tp, typename _Dp>
706  inline bool
707  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
708  { return (bool)__x; }
709 
710  template<typename _Tp, typename _Dp,
711  typename _Up, typename _Ep>
712  inline bool
713  operator<(const unique_ptr<_Tp, _Dp>& __x,
714  const unique_ptr<_Up, _Ep>& __y)
715  {
716  typedef typename
717  std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
718  typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
719  return std::less<_CT>()(__x.get(), __y.get());
720  }
721 
722  template<typename _Tp, typename _Dp>
723  inline bool
724  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
726  nullptr); }
727 
728  template<typename _Tp, typename _Dp>
729  inline bool
730  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
732  __x.get()); }
733 
734  template<typename _Tp, typename _Dp,
735  typename _Up, typename _Ep>
736  inline bool
737  operator<=(const unique_ptr<_Tp, _Dp>& __x,
738  const unique_ptr<_Up, _Ep>& __y)
739  { return !(__y < __x); }
740 
741  template<typename _Tp, typename _Dp>
742  inline bool
743  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
744  { return !(nullptr < __x); }
745 
746  template<typename _Tp, typename _Dp>
747  inline bool
748  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
749  { return !(__x < nullptr); }
750 
751  template<typename _Tp, typename _Dp,
752  typename _Up, typename _Ep>
753  inline bool
754  operator>(const unique_ptr<_Tp, _Dp>& __x,
755  const unique_ptr<_Up, _Ep>& __y)
756  { return (__y < __x); }
757 
758  template<typename _Tp, typename _Dp>
759  inline bool
760  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
762  __x.get()); }
763 
764  template<typename _Tp, typename _Dp>
765  inline bool
766  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
768  nullptr); }
769 
770  template<typename _Tp, typename _Dp,
771  typename _Up, typename _Ep>
772  inline bool
773  operator>=(const unique_ptr<_Tp, _Dp>& __x,
774  const unique_ptr<_Up, _Ep>& __y)
775  { return !(__x < __y); }
776 
777  template<typename _Tp, typename _Dp>
778  inline bool
779  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
780  { return !(__x < nullptr); }
781 
782  template<typename _Tp, typename _Dp>
783  inline bool
784  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
785  { return !(nullptr < __x); }
786 
787  /// std::hash specialization for unique_ptr.
788  template<typename _Tp, typename _Dp>
789  struct hash<unique_ptr<_Tp, _Dp>>
790  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
791  private __poison_hash<typename unique_ptr<_Tp, _Dp>::pointer>
792  {
793  size_t
794  operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
795  {
796  typedef unique_ptr<_Tp, _Dp> _UP;
797  return std::hash<typename _UP::pointer>()(__u.get());
798  }
799  };
800 
801 #if __cplusplus > 201103L
802 
803 #define __cpp_lib_make_unique 201304
804 
805  template<typename _Tp>
806  struct _MakeUniq
807  { typedef unique_ptr<_Tp> __single_object; };
808 
809  template<typename _Tp>
810  struct _MakeUniq<_Tp[]>
811  { typedef unique_ptr<_Tp[]> __array; };
812 
813  template<typename _Tp, size_t _Bound>
814  struct _MakeUniq<_Tp[_Bound]>
815  { struct __invalid_type { }; };
816 
817  /// std::make_unique for single objects
818  template<typename _Tp, typename... _Args>
819  inline typename _MakeUniq<_Tp>::__single_object
820  make_unique(_Args&&... __args)
821  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
822 
823  /// std::make_unique for arrays of unknown bound
824  template<typename _Tp>
825  inline typename _MakeUniq<_Tp>::__array
826  make_unique(size_t __num)
827  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
828 
829  /// Disable std::make_unique for arrays of known bound
830  template<typename _Tp, typename... _Args>
831  inline typename _MakeUniq<_Tp>::__invalid_type
832  make_unique(_Args&&...) = delete;
833 #endif
834 
835  // @} group pointer_abstractions
836 
837 _GLIBCXX_END_NAMESPACE_VERSION
838 } // namespace
839 
840 #endif /* _UNIQUE_PTR_H */
pointer operator->() const noexcept
Return the stored pointer.
Definition: unique_ptr.h:323
add_lvalue_reference< element_type >::type operator*() const
Dereference the stored pointer.
Definition: unique_ptr.h:315
constexpr unique_ptr(nullptr_t) noexcept
Creates a unique_ptr that owns nothing.
Definition: unique_ptr.h:228
unique_ptr(_Up __p, typename conditional< is_reference< deleter_type >::value, deleter_type, const deleter_type &>::type __d) noexcept
Definition: unique_ptr.h:478
is_void
Definition: type_traits:214
void swap(unique_ptr &__u) noexcept
Exchange the pointer and deleter with another object.
Definition: unique_ptr.h:376
enable_if< __and_< __safe_conversion_up< _Up, _Ep >, is_assignable< deleter_type &, _Ep && > >::value, unique_ptr & >::type operator=(unique_ptr< _Up, _Ep > &&__u) noexcept
Assignment from another type.
Definition: unique_ptr.h:556
void operator()(_Tp *__ptr) const
Calls delete __ptr.
Definition: unique_ptr.h:72
unique_ptr(pointer __p) noexcept
Definition: unique_ptr.h:196
default_delete(const default_delete< _Up > &) noexcept
Converting constructor.
Definition: unique_ptr.h:68
const deleter_type & get_deleter() const noexcept
Return a reference to the stored deleter.
Definition: unique_ptr.h:593
enable_if< is_convertible< _Up(*)[], _Tp(*)[]>::value >::type operator()(_Up *__ptr) const
Calls delete[] __ptr.
Definition: unique_ptr.h:108
pointer get() const noexcept
Return the stored pointer.
Definition: unique_ptr.h:331
constexpr unique_ptr() noexcept
Default constructor, creates a unique_ptr that owns nothing.
Definition: unique_ptr.h:183
Primary template of default_delete, used by unique_ptr.
Definition: unique_ptr.h:56
deleter_type & get_deleter() noexcept
Return a reference to the stored deleter.
Definition: unique_ptr.h:336
unique_ptr(pointer __p, typename conditional< is_reference< deleter_type >::value, deleter_type, const deleter_type &>::type __d) noexcept
Definition: unique_ptr.h:207
A simple smart pointer providing strict ownership semantics.
Definition: auto_ptr.h:87
enable_if< __and_< __safe_conversion_up< _Up, _Ep >, is_assignable< deleter_type &, _Ep && > >::value, unique_ptr & >::type operator=(unique_ptr< _Up, _Ep > &&__u) noexcept
Assignment from another type.
Definition: unique_ptr.h:296
void swap(unique_ptr &__u) noexcept
Exchange the pointer and deleter with another object.
Definition: unique_ptr.h:646
One of the comparison functors.
Definition: stl_function.h:340
20.7.1.2 unique_ptr for single objects.
Definition: unique_ptr.h:157
unique_ptr(_Up __p) noexcept
Definition: unique_ptr.h:463
constexpr unique_ptr() noexcept
Default constructor, creates a unique_ptr that owns nothing.
Definition: unique_ptr.h:446
unique_ptr & operator=(nullptr_t) noexcept
Reset the unique_ptr to empty, invoking the deleter if necessary.
Definition: unique_ptr.h:565
is_reference
Definition: type_traits:580
void reset(_Up __p) noexcept
Replace the stored pointer.
Definition: unique_ptr.h:630
_MakeUniq< _Tp >::__single_object make_unique(_Args &&... __args)
std::make_unique for single objects
Definition: unique_ptr.h:820
std::add_lvalue_reference< element_type >::type operator[](size_t __i) const
Access an element of owned array.
Definition: unique_ptr.h:575
is_array
Definition: type_traits:359
ISO C++ entities toplevel namespace is std.
unique_ptr & operator=(nullptr_t) noexcept
Reset the unique_ptr to empty, invoking the deleter if necessary.
Definition: unique_ptr.h:305
void reset(pointer __p=pointer()) noexcept
Replace the stored pointer.
Definition: unique_ptr.h:366
unique_ptr & operator=(unique_ptr &&__u) noexcept
Move assignment operator.
Definition: unique_ptr.h:536
is_pointer
Definition: type_traits:380
default_delete(const default_delete< _Up[]> &) noexcept
Converting constructor.
Definition: unique_ptr.h:103
const deleter_type & get_deleter() const noexcept
Return a reference to the stored deleter.
Definition: unique_ptr.h:341
_Del * get_deleter(const __shared_ptr< _Tp, _Lp > &__p) noexcept
20.7.2.2.10 shared_ptr get_deleter
unique_ptr(_Up __p, typename remove_reference< deleter_type >::type &&__d) noexcept
Definition: unique_ptr.h:494
pointer release() noexcept
Release ownership of any stored pointer.
Definition: unique_ptr.h:604
Primary class template hash.
Definition: system_error:142
constexpr unique_ptr(nullptr_t) noexcept
Creates a unique_ptr that owns nothing.
Definition: unique_ptr.h:507
unique_ptr(unique_ptr< _Up, _Ep > &&__u) noexcept
Converting constructor from another type.
Definition: unique_ptr.h:247
~unique_ptr() noexcept
Destructor, invokes the deleter if the stored pointer is not null.
Definition: unique_ptr.h:259
unique_ptr(unique_ptr &&__u) noexcept
Move constructor.
Definition: unique_ptr.h:233
pointer release() noexcept
Release ownership of any stored pointer.
Definition: unique_ptr.h:352
unique_ptr(unique_ptr &&__u) noexcept
Move constructor.
Definition: unique_ptr.h:501
~unique_ptr()
Destructor, invokes the deleter if the stored pointer is not null.
Definition: unique_ptr.h:519
constexpr default_delete() noexcept=default
Default constructor.
unique_ptr & operator=(unique_ptr &&__u) noexcept
Move assignment operator.
Definition: unique_ptr.h:276
unique_ptr(pointer __p, typename remove_reference< deleter_type >::type &&__d) noexcept
Definition: unique_ptr.h:219
deleter_type & get_deleter() noexcept
Return a reference to the stored deleter.
Definition: unique_ptr.h:588