unique_ptr.h source code [include/c++/7/bits/unique

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>
56	struct default_delete
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>>
157	class unique_ptr
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))
222	{ static_assert(!std::is_reference<deleter_type>::value,
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>>
247	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
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
296	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
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_<
421	is_array<_Up>,
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.
519	~unique_ptr()
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
556	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
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*>,
621	is_pointer<_Up>,
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)
725	{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
726	nullptr); }
727
728	template<typename _Tp, typename _Dp>
729	inline bool
730	operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
731	{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
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)
761	{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
762	__x.get()); }
763
764	template<typename _Tp, typename _Dp>
765	inline bool
766	operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
767	{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
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 */
841

Clang Project