cppdraft_translate/cppdraft/unique/ptr/special.md

[unique.ptr.special]

20 Memory management library [mem]

20.3 Smart pointers [smartptr]

20.3.1 Unique-ownership pointers [unique.ptr]

20.3.1.6 Specialized algorithms [unique.ptr.special]

🔗

template<class T, class D> constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;

1

#

Constraints: is_swappable_v is true.

2

#

Effects: Calls x.swap(y).

🔗

template<class T1, class D1, class T2, class D2> constexpr bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

3

#

Returns: x.get() == y.get().

🔗

template<class T1, class D1, class T2, class D2> constexpr bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

4

#

Let CT denotecommon_type_t<typename unique_ptr<T1, D1>::pointer, typename unique_ptr<T2, D2>::pointer>

5

#

Mandates:

• (5.1)

unique_ptr<T1, D1>​::​pointer is implicitly convertible to CT and

• (5.2)

unique_ptr<T2, D2>​::​pointer is implicitly convertible to CT.

6

#

Preconditions: The specializationless is a function object type ([function.objects]) that induces a strict weak ordering ([alg.sorting]) on the pointer values.

7

#

Returns: less()(x.get(), y.get()).

🔗

template<class T1, class D1, class T2, class D2> constexpr bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

8

#

Returns: y < x.

🔗

template<class T1, class D1, class T2, class D2> constexpr bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

9

#

Returns: !(y < x).

🔗

template<class T1, class D1, class T2, class D2> constexpr bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

10

#

Returns: !(x < y).

🔗

template<class T1, class D1, class T2, class D2> requires [three_way_comparable_with](cmp.concept#concept:three_way_comparable_with "17.12.4 Concept three_­way_­comparable [cmp.concept]")<typename unique_ptr<T1, D1>::pointer, typename unique_ptr<T2, D2>::pointer> constexpr compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer, typename unique_ptr<T2, D2>::pointer> operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

11

#

Returns: compare_three_way()(x.get(), y.get()).

🔗

template<class T, class D> constexpr bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;

12

#

Returns: !x.

🔗

template<class T, class D> constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t); template<class T, class D> constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& x);

13

#

Preconditions: The specialization less<unique_ptr<T, D>​::​pointer> is a function object type ([function.objects]) that induces a strict weak ordering ([alg.sorting]) on the pointer values.

14

#

Returns: The first function template returnsless<unique_ptr<T, D>::pointer>()(x.get(), nullptr)

The second function template returnsless<unique_ptr<T, D>::pointer>()(nullptr, x.get())

🔗

template<class T, class D> constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t); template<class T, class D> constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& x);

15

#

Returns: The first function template returns nullptr < x.

The second function template returns x < nullptr.

🔗

template<class T, class D> constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t); template<class T, class D> constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& x);

16

#

Returns: The first function template returns !(nullptr < x).

The second function template returns !(x < nullptr).

🔗

template<class T, class D> constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t); template<class T, class D> constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& x);

17

#

Returns: The first function template returns !(x < nullptr).

The second function template returns !(nullptr < x).

🔗

template<class T, class D> requires [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<typename unique_ptr<T, D>::pointer> constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer> operator<=>(const unique_ptr<T, D>& x, nullptr_t);

18

#

Returns: compare_three_way()(x.get(), static_cast<typename unique_ptr<T, D>::pointer>(nullptr)).