[util.smartptr] - C++17 → C++20

Files changed (1) hide show

tmp/tmpet6w6kxd/{from.md → to.md} +0 -1239

tmp/tmpet6w6kxd/{from.md → to.md} RENAMED Viewed

@@ -1,1239 +0,0 @@
-### Shared-ownership pointers <a id="util.smartptr">[[util.smartptr]]</a>
-#### Class `bad_weak_ptr` <a id="util.smartptr.weak.bad">[[util.smartptr.weak.bad]]</a>
-``` cpp
-namespace std {
-  class bad_weak_ptr : public exception {
-  public:
-    bad_weak_ptr() noexcept;
-  };
-}
-```
-An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
-constructor taking a `weak_ptr`.
-``` cpp
-bad_weak_ptr() noexcept;
-```
-*Postconditions:* `what()` returns an *implementation-defined* NTBS.
-#### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
-The `shared_ptr` class template stores a pointer, usually obtained via
-`new`. `shared_ptr` implements semantics of shared ownership; the last
-remaining owner of the pointer is responsible for destroying the object,
-or otherwise releasing the resources associated with the stored pointer.
-A `shared_ptr` is said to be empty if it does not own a pointer.
-``` cpp
-namespace std {
-  template<class T> class shared_ptr {
-  public:
-    using element_type = remove_extent_t<T>;
-    using weak_type    = weak_ptr<T>;
-    // [util.smartptr.shared.const], constructors
-    constexpr shared_ptr() noexcept;
-    template<class Y> explicit shared_ptr(Y* p);
-    template<class Y, class D> shared_ptr(Y* p, D d);
-    template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
-    template <class D> shared_ptr(nullptr_t p, D d);
-    template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
-    template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
-    shared_ptr(const shared_ptr& r) noexcept;
-    template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
-    shared_ptr(shared_ptr&& r) noexcept;
-    template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
-    template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
-    template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
-    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
-    // [util.smartptr.shared.dest], destructor
-    ~shared_ptr();
-    // [util.smartptr.shared.assign], assignment
-    shared_ptr& operator=(const shared_ptr& r) noexcept;
-    template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
-    shared_ptr& operator=(shared_ptr&& r) noexcept;
-    template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
-    template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
-    // [util.smartptr.shared.mod], modifiers
-    void swap(shared_ptr& r) noexcept;
-    void reset() noexcept;
-    template<class Y> void reset(Y* p);
-    template<class Y, class D> void reset(Y* p, D d);
-    template<class Y, class D, class A> void reset(Y* p, D d, A a);
-    // [util.smartptr.shared.obs], observers
-    element_type* get() const noexcept;
-    T& operator*() const noexcept;
-    T* operator->() const noexcept;
-    element_type& operator[](ptrdiff_t i) const;
-    long use_count() const noexcept;
-    explicit operator bool() const noexcept;
-    template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
-    template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
-  };
-  template<class T> shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
-  template<class T, class D> shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
-  // [util.smartptr.shared.create], shared_ptr creation
-  template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args);
-  template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
-  // [util.smartptr.shared.cmp], shared_ptr comparisons
-  template<class T, class U>
-    bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator<=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator>=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template <class T>
-    bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator==(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator!=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator!=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator<(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator<(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator<=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator<=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator>(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator>=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator>=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  // [util.smartptr.shared.spec], shared_ptr specialized algorithms
-  template<class T>
-    void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
-  // [util.smartptr.shared.cast], shared_ptr casts
-  template<class T, class U>
-    shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
-  template<class T, class U>
-    shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
-  template<class T, class U>
-    shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
-  template<class T, class U>
-    shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
-  // [util.smartptr.getdeleter], shared_ptr get_deleter
-  template<class D, class T>
-    D* get_deleter(const shared_ptr<T>& p) noexcept;
-  // [util.smartptr.shared.io], shared_ptr I/O
-  template<class E, class T, class Y>
-    basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, const shared_ptr<Y>& p);
-}
-```
-Specializations of `shared_ptr` shall be `CopyConstructible`,
-`CopyAssignable`, and `LessThanComparable`, allowing their use in
-standard containers. Specializations of `shared_ptr` shall be
-contextually convertible to `bool`, allowing their use in boolean
-expressions and declarations in conditions. The template parameter `T`
-of `shared_ptr` may be an incomplete type.
-[*Example 1*:
-``` cpp
-if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
-  // do something with px
-}
-```
-— *end example*]
-For purposes of determining the presence of a data race, member
-functions shall access and modify only the `shared_ptr` and `weak_ptr`
-objects themselves and not objects they refer to. Changes in
-`use_count()` do not reflect modifications that can introduce data
-races.
-For the purposes of subclause [[util.smartptr]], a pointer type `Y*` is
-said to be *compatible with* a pointer type `T*` when either `Y*` is
-convertible to `T*` or `Y` is `U[N]` and `T` is cv `U[]`.
-##### `shared_ptr` constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
-In the constructor definitions below, enables `shared_from_this` with
-`p`, for a pointer `p` of type `Y*`, means that if `Y` has an
-unambiguous and accessible base class that is a specialization of
-`enable_shared_from_this` ([[util.smartptr.enab]]), then
-`remove_cv_t<Y>*` shall be implicitly convertible to `T*` and the
-constructor evaluates the statement:
-``` cpp
-if (p != nullptr && p->weak_this.expired())
-  p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
-```
-The assignment to the `weak_this` member is not atomic and conflicts
-with any potentially concurrent access to the same object (
-[[intro.multithread]]).
-``` cpp
-constexpr shared_ptr() noexcept;
-```
-*Effects:* Constructs an empty `shared_ptr` object.
-*Postconditions:* `use_count() == 0 && get() == nullptr`.
-``` cpp
-template<class Y> explicit shared_ptr(Y* p);
-```
-*Requires:* `Y` shall be a complete type. The expression `delete[] p`,
-when `T` is an array type, or `delete p`, when `T` is not an array type,
-shall have well-defined behavior, and shall not throw exceptions.
-*Effects:* When `T` is not an array type, constructs a `shared_ptr`
-object that owns the pointer `p`. Otherwise, constructs a `shared_ptr`
-that owns `p` and a deleter of an unspecified type that calls
-`delete[] p`. When `T` is not an array type, enables `shared_from_this`
-with `p`. If an exception is thrown, `delete p` is called when `T` is
-not an array type, `delete[] p` otherwise.
-*Postconditions:* `use_count() == 1 && get() == p`.
-*Throws:* `bad_alloc`, or an *implementation-defined* exception when a
-resource other than memory could not be obtained.
-*Remarks:* When `T` is an array type, this constructor shall not
-participate in overload resolution unless the expression `delete[] p` is
-well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
-`T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
-not an array type, this constructor shall not participate in overload
-resolution unless the expression `delete p` is well-formed and `Y*` is
-convertible to `T*`.
-``` cpp
-template<class Y, class D> shared_ptr(Y* p, D d);
-template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
-template <class D> shared_ptr(nullptr_t p, D d);
-template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
-```
-*Requires:* Construction of `d` and a deleter of type `D` initialized
-with `std::move(d)` shall not throw exceptions. The expression `d(p)`
-shall have well-defined behavior and shall not throw exceptions. `A`
-shall be an allocator ([[allocator.requirements]]).
-*Effects:* Constructs a `shared_ptr` object that owns the object `p` and
-the deleter `d`. When `T` is not an array type, the first and second
-constructors enable `shared_from_this` with `p`. The second and fourth
-constructors shall use a copy of `a` to allocate memory for internal
-use. If an exception is thrown, `d(p)` is called.
-*Postconditions:* `use_count() == 1 && get() == p`.
-*Throws:* `bad_alloc`, or an *implementation-defined* exception when a
-resource other than memory could not be obtained.
-*Remarks:* When `T` is an array type, this constructor shall not
-participate in overload resolution unless `is_move_constructible_v<D>`
-is `true`, the expression `d(p)` is well-formed, and either `T` is
-`U[N]` and `Y(*)[N]` is convertible to `T*`, or `T` is `U[]` and
-`Y(*)[]` is convertible to `T*`. When `T` is not an array type, this
-constructor shall not participate in overload resolution unless
-`is_move_constructible_v<D>` is `true`, the expression `d(p)` is
-well-formed, and `Y*` is convertible to `T*`.
-``` cpp
-template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
-```
-*Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
-ownership with `r`.
-*Postconditions:* `get() == p && use_count() == r.use_count()`.
-[*Note 1*: To avoid the possibility of a dangling pointer, the user of
-this constructor must ensure that `p` remains valid at least until the
-ownership group of `r` is destroyed. — *end note*]
-[*Note 2*: This constructor allows creation of an empty `shared_ptr`
-instance with a non-null stored pointer. — *end note*]
-``` cpp
-shared_ptr(const shared_ptr& r) noexcept;
-template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
-```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
-*Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
-otherwise, constructs a `shared_ptr` object that shares ownership with
-`r`.
-*Postconditions:* `get() == r.get() && use_count() == r.use_count()`.
-``` cpp
-shared_ptr(shared_ptr&& r) noexcept;
-template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
-```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
-*Effects:* Move constructs a `shared_ptr` instance from `r`.
-*Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be empty. `r.get() == nullptr`.
-``` cpp
-template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
-```
-*Effects:* Constructs a `shared_ptr` object that shares ownership with
-`r` and stores a copy of the pointer stored in `r`. If an exception is
-thrown, the constructor has no effect.
-*Postconditions:* `use_count() == r.use_count()`.
-*Throws:* `bad_weak_ptr` when `r.expired()`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `Y*` is compatible with `T*`.
-``` cpp
-template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
-```
-*Remarks:* This constructor shall not participate in overload resolution
-unless `Y*` is compatible with `T*` and `unique_ptr<Y, D>::pointer` is
-convertible to `element_type*`.
-*Effects:* If `r.get() == nullptr`, equivalent to `shared_ptr()`.
-Otherwise, if `D` is not a reference type, equivalent to
-`shared_ptr(r.release(), r.get_deleter())`. Otherwise, equivalent to
-`shared_ptr(r.release(), ref(r.get_deleter()))`. If an exception is
-thrown, the constructor has no effect.
-##### `shared_ptr` destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
-``` cpp
-~shared_ptr();
-```
-*Effects:*
-- If `*this` is empty or shares ownership with another `shared_ptr`
-  instance (`use_count() > 1`), there are no side effects.
-- Otherwise, if `*this` owns an object `p` and a deleter `d`, `d(p)` is
-  called.
-- Otherwise, `*this` owns a pointer `p`, and `delete p` is called.
-[*Note 1*: Since the destruction of `*this` decreases the number of
-instances that share ownership with `*this` by one, after `*this` has
-been destroyed all `shared_ptr` instances that shared ownership with
-`*this` will report a `use_count()` that is one less than its previous
-value. — *end note*]
-##### `shared_ptr` assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
-``` cpp
-shared_ptr& operator=(const shared_ptr& r) noexcept;
-template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
-```
-*Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
-*Returns:* `*this`.
-[*Note 3*:
-The use count updates caused by the temporary object construction and
-destruction are not observable side effects, so the implementation may
-meet the effects (and the implied guarantees) via different means,
-without creating a temporary. In particular, in the example:
-``` cpp
-shared_ptr<int> p(new int);
-shared_ptr<void> q(p);
-p = p;
-q = p;
-```
-both assignments may be no-ops.
-— *end note*]
-``` cpp
-shared_ptr& operator=(shared_ptr&& r) noexcept;
-template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
-```
-*Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
-*Returns:* `*this`.
-``` cpp
-template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
-```
-*Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
-*Returns:* `*this`.
-##### `shared_ptr` modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
-``` cpp
-void swap(shared_ptr& r) noexcept;
-```
-*Effects:* Exchanges the contents of `*this` and `r`.
-``` cpp
-void reset() noexcept;
-```
-*Effects:* Equivalent to `shared_ptr().swap(*this)`.
-``` cpp
-template<class Y> void reset(Y* p);
-```
-*Effects:* Equivalent to `shared_ptr(p).swap(*this)`.
-``` cpp
-template<class Y, class D> void reset(Y* p, D d);
-```
-*Effects:* Equivalent to `shared_ptr(p, d).swap(*this)`.
-``` cpp
-template<class Y, class D, class A> void reset(Y* p, D d, A a);
-```
-*Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
-##### `shared_ptr` observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
-``` cpp
-element_type* get() const noexcept;
-```
-*Returns:* The stored pointer.
-``` cpp
-T& operator*() const noexcept;
-```
-*Requires:* `get() != 0`.
-*Returns:* `*get()`.
-*Remarks:* When `T` is an array type or cv `void`, it is unspecified
-whether this member function is declared. If it is declared, it is
-unspecified what its return type is, except that the declaration
-(although not necessarily the definition) of the function shall be well
-formed.
-``` cpp
-T* operator->() const noexcept;
-```
-*Requires:* `get() != 0`.
-*Returns:* `get()`.
-*Remarks:* When `T` is an array type, it is unspecified whether this
-member function is declared. If it is declared, it is unspecified what
-its return type is, except that the declaration (although not
-necessarily the definition) of the function shall be well formed.
-``` cpp
-element_type& operator[](ptrdiff_t i) const;
-```
-*Requires:* `get() != 0 && i >= 0`. If `T` is `U[N]`, `i < N`.
-*Returns:* `get()[i]`.
-*Remarks:* When `T` is not an array type, it is unspecified whether this
-member function is declared. If it is declared, it is unspecified what
-its return type is, except that the declaration (although not
-necessarily the definition) of the function shall be well formed.
-*Throws:* Nothing.
-``` cpp
-long use_count() const noexcept;
-```
-*Returns:* The number of `shared_ptr` objects, `*this` included, that
-share ownership with `*this`, or `0` when `*this` is empty.
-*Synchronization:* None.
-[*Note 4*: `get() == nullptr` does not imply a specific return value of
-`use_count()`. — *end note*]
-[*Note 5*: `weak_ptr<T>::lock()` can affect the return value of
-`use_count()`. — *end note*]
-[*Note 6*: When multiple threads can affect the return value of
-`use_count()`, the result should be treated as approximate. In
-particular, `use_count() == 1` does not imply that accesses through a
-previously destroyed `shared_ptr` have in any sense
-completed. — *end note*]
-``` cpp
-explicit operator bool() const noexcept;
-```
-*Returns:* `get() != 0`.
-``` cpp
-template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
-template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
-```
-*Returns:* An unspecified value such that
-- `x.owner_before(y)` defines a strict weak ordering as defined
-  in  [[alg.sorting]];
-- under the equivalence relation defined by `owner_before`,
-  `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
-  `weak_ptr` instances are equivalent if and only if they share
-  ownership or are both empty.
-##### `shared_ptr` creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
-``` cpp
-template<class T, class... Args>
-  shared_ptr<T> make_shared(Args&&... args);
-template<class T, class A, class... Args>
-  shared_ptr<T> allocate_shared(const A& a, Args&&... args);
-```
-*Requires:* The expression `::new (pv) T(std::forward<Args>(args)...)`,
-where `pv` has type `void*` and points to storage suitable to hold an
-object of type `T`, shall be well formed. `A` shall be an
-allocator ([[allocator.requirements]]). The copy constructor and
-destructor of `A` shall not throw exceptions.
-*Effects:* Allocates memory suitable for an object of type `T` and
-constructs an object in that memory via the placement *new-expression*
-`::new (pv) T(std::forward<Args>(args)...)`. The template
-`allocate_shared` uses a copy of `a` to allocate memory. If an exception
-is thrown, the functions have no effect.
-*Returns:* A `shared_ptr` instance that stores and owns the address of
-the newly constructed object of type `T`.
-*Postconditions:* `get() != 0 && use_count() == 1`.
-*Throws:* `bad_alloc`, or an exception thrown from `A::allocate` or from
-the constructor of `T`.
-*Remarks:* The `shared_ptr` constructor called by this function enables
-`shared_from_this` with the address of the newly constructed object of
-type `T`. Implementations should perform no more than one memory
-allocation.
-[*Note 7*: This provides efficiency equivalent to an intrusive smart
-pointer. — *end note*]
-[*Note 8*: These functions will typically allocate more memory than
-`sizeof(T)` to allow for internal bookkeeping structures such as the
-reference counts. — *end note*]
-##### `shared_ptr` comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
-``` cpp
-template<class T, class U>
-  bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-```
-*Returns:* `a.get() == b.get()`.
-``` cpp
-template<class T, class U>
-  bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-```
-*Returns:* `less<>()(a.get(), b.get())`.
-[*Note 9*: Defining a comparison function allows `shared_ptr` objects
-to be used as keys in associative containers. — *end note*]
-``` cpp
-template <class T>
-  bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator==(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* `!a`.
-``` cpp
-template <class T>
-  bool operator!=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator!=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* `(bool)a`.
-``` cpp
-template <class T>
-  bool operator<(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator<(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns
-`less<shared_ptr<T>::element_type*>()(a.get(), nullptr)`. The second
-function template returns
-`less<shared_ptr<T>::element_type*>()(nullptr, a.get())`.
-``` cpp
-template <class T>
-  bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator>(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns `nullptr < a`. The second
-function template returns `a < nullptr`.
-``` cpp
-template <class T>
-  bool operator<=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator<=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns `!(nullptr < a)`. The
-second function template returns `!(a < nullptr)`.
-``` cpp
-template <class T>
-  bool operator>=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator>=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns `!(a < nullptr)`. The
-second function template returns `!(nullptr < a)`.
-##### `shared_ptr` specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
-``` cpp
-template<class T>
-  void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
-```
-*Effects:* Equivalent to `a.swap(b)`.
-##### `shared_ptr` casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
-``` cpp
-template<class T, class U>
-  shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
-```
-*Requires:* The expression `static_cast<T*>((U*)0)` shall be well
-formed.
-*Returns:*
-``` cpp
-shared_ptr<T>(r, static_cast<typename shared_ptr<T>::element_type*>(r.get()))
-```
-[*Note 10*: The seemingly equivalent expression
-`shared_ptr<T>(static_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
-``` cpp
-template<class T, class U>
-  shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
-```
-*Requires:* The expression `dynamic_cast<T*>((U*)0)` shall be well
-formed and shall have well defined behavior.
-*Returns:*
-- When `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())`
-  returns a nonzero value `p`, `shared_ptr<T>(r, p)`.
-- Otherwise, `shared_ptr<T>()`.
-[*Note 11*: The seemingly equivalent expression
-`shared_ptr<T>(dynamic_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
-``` cpp
-template<class T, class U>
-  shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
-```
-*Requires:* The expression `const_cast<T*>((U*)0)` shall be well formed.
-*Returns:*
-``` cpp
-shared_ptr<T>(r, const_cast<typename shared_ptr<T>::element_type*>(r.get()))
-```
-[*Note 12*: The seemingly equivalent expression
-`shared_ptr<T>(const_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
-``` cpp
-template<class T, class U>
-  shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
-```
-*Requires:* The expression `reinterpret_cast<T*>((U*)0)` shall be well
-formed.
-*Returns:*
-``` cpp
-shared_ptr<T>(r, reinterpret_cast<typename shared_ptr<T>::element_type*>(r.get()))
-```
-[*Note 13*: The seemingly equivalent expression
-`shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
-undefined behavior, attempting to delete the same object
-twice. — *end note*]
-##### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
-``` cpp
-template<class D, class T>
-  D* get_deleter(const shared_ptr<T>& p) noexcept;
-```
-*Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
-`addressof(d)`; otherwise returns `nullptr`. The returned pointer
-remains valid as long as there exists a `shared_ptr` instance that owns
-`d`.
-[*Note 14*: It is unspecified whether the pointer remains valid longer
-than that. This can happen if the implementation doesn’t destroy the
-deleter until all `weak_ptr` instances that share ownership with `p`
-have been destroyed. — *end note*]
-##### `shared_ptr` I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
-``` cpp
-template<class E, class T, class Y>
-  basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, const shared_ptr<Y>& p);
-```
-*Effects:* As if by: `os << p.get();`
-*Returns:* `os`.
-#### Class template `weak_ptr` <a id="util.smartptr.weak">[[util.smartptr.weak]]</a>
-The `weak_ptr` class template stores a weak reference to an object that
-is already managed by a `shared_ptr`. To access the object, a `weak_ptr`
-can be converted to a `shared_ptr` using the member function `lock`.
-``` cpp
-namespace std {
-  template<class T> class weak_ptr {
-  public:
-    using element_type = T;
-    // [util.smartptr.weak.const], constructors
-    constexpr weak_ptr() noexcept;
-    template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
-    weak_ptr(const weak_ptr& r) noexcept;
-    template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
-    weak_ptr(weak_ptr&& r) noexcept;
-    template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
-    // [util.smartptr.weak.dest], destructor
-    ~weak_ptr();
-    // [util.smartptr.weak.assign], assignment
-    weak_ptr& operator=(const weak_ptr& r) noexcept;
-    template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
-    template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
-    weak_ptr& operator=(weak_ptr&& r) noexcept;
-    template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
-    // [util.smartptr.weak.mod], modifiers
-    void swap(weak_ptr& r) noexcept;
-    void reset() noexcept;
-    // [util.smartptr.weak.obs], observers
-    long use_count() const noexcept;
-    bool expired() const noexcept;
-    shared_ptr<T> lock() const noexcept;
-    template<class U> bool owner_before(const shared_ptr<U>& b) const;
-    template<class U> bool owner_before(const weak_ptr<U>& b) const;
-  };
-  template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
-  // [util.smartptr.weak.spec], specialized algorithms
-  template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
-}
-```
-Specializations of `weak_ptr` shall be `CopyConstructible` and
-`CopyAssignable`, allowing their use in standard containers. The
-template parameter `T` of `weak_ptr` may be an incomplete type.
-##### `weak_ptr` constructors <a id="util.smartptr.weak.const">[[util.smartptr.weak.const]]</a>
-``` cpp
-constexpr weak_ptr() noexcept;
-```
-*Effects:* Constructs an empty `weak_ptr` object.
-*Postconditions:* `use_count() == 0`.
-``` cpp
-weak_ptr(const weak_ptr& r) noexcept;
-template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
-template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
-```
-*Remarks:* The second and third constructors shall not participate in
-overload resolution unless `Y*` is compatible with `T*`.
-*Effects:* If `r` is empty, constructs an empty `weak_ptr` object;
-otherwise, constructs a `weak_ptr` object that shares ownership with `r`
-and stores a copy of the pointer stored in `r`.
-*Postconditions:* `use_count() == r.use_count()`.
-``` cpp
-weak_ptr(weak_ptr&& r) noexcept;
-template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
-```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
-*Effects:* Move constructs a `weak_ptr` instance from `r`.
-*Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be empty. `r.use_count() == 0`.
-##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
-``` cpp
-~weak_ptr();
-```
-*Effects:* Destroys this `weak_ptr` object but has no effect on the
-object its stored pointer points to.
-##### `weak_ptr` assignment <a id="util.smartptr.weak.assign">[[util.smartptr.weak.assign]]</a>
-``` cpp
-weak_ptr& operator=(const weak_ptr& r) noexcept;
-template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
-template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
-```
-*Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
-*Remarks:* The implementation may meet the effects (and the implied
-guarantees) via different means, without creating a temporary.
-*Returns:* `*this`.
-``` cpp
-weak_ptr& operator=(weak_ptr&& r) noexcept;
-template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
-```
-*Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
-*Returns:* `*this`.
-##### `weak_ptr` modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
-``` cpp
-void swap(weak_ptr& r) noexcept;
-```
-*Effects:* Exchanges the contents of `*this` and `r`.
-``` cpp
-void reset() noexcept;
-```
-*Effects:* Equivalent to `weak_ptr().swap(*this)`.
-##### `weak_ptr` observers <a id="util.smartptr.weak.obs">[[util.smartptr.weak.obs]]</a>
-``` cpp
-long use_count() const noexcept;
-```
-*Returns:* `0` if `*this` is empty; otherwise, the number of
-`shared_ptr` instances that share ownership with `*this`.
-``` cpp
-bool expired() const noexcept;
-```
-*Returns:* `use_count() == 0`.
-``` cpp
-shared_ptr<T> lock() const noexcept;
-```
-*Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
-executed atomically.
-``` cpp
-template<class U> bool owner_before(const shared_ptr<U>& b) const;
-template<class U> bool owner_before(const weak_ptr<U>& b) const;
-```
-*Returns:* An unspecified value such that
-- `x.owner_before(y)` defines a strict weak ordering as defined
-  in  [[alg.sorting]];
-- under the equivalence relation defined by `owner_before`,
-  `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
-  `weak_ptr` instances are equivalent if and only if they share
-  ownership or are both empty.
-##### `weak_ptr` specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
-``` cpp
-template<class T>
-  void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
-```
-*Effects:* Equivalent to `a.swap(b)`.
-#### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
-The class template `owner_less` allows ownership-based mixed comparisons
-of shared and weak pointers.
-``` cpp
-namespace std {
-  template<class T = void> struct owner_less;
-  template<class T> struct owner_less<shared_ptr<T>> {
-    bool operator()(const shared_ptr<T>&, const shared_ptr<T>&) const noexcept;
-    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
-  };
-  template<class T> struct owner_less<weak_ptr<T>> {
-    bool operator()(const weak_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
-  };
-  template<> struct owner_less<void> {
-    template<class T, class U>
-      bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
-    template<class T, class U>
-      bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
-    template<class T, class U>
-      bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
-    template<class T, class U>
-      bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
-    using is_transparent = unspecified;
-  };
-}
-```
-`operator()(x, y)` shall return `x.owner_before(y)`.
-[*Note 1*:
-Note that
-- `operator()` defines a strict weak ordering as defined in
-  [[alg.sorting]];
-- under the equivalence relation defined by `operator()`,
-  `!operator()(a, b) && !operator()(b, a)`, two `shared_ptr` or
-  `weak_ptr` instances are equivalent if and only if they share
-  ownership or are both empty.
-— *end note*]
-#### Class template `enable_shared_from_this` <a id="util.smartptr.enab">[[util.smartptr.enab]]</a>
-A class `T` can inherit from `enable_shared_from_this<T>` to inherit the
-`shared_from_this` member functions that obtain a `shared_ptr` instance
-pointing to `*this`.
-[*Example 1*:
-``` cpp
-struct X: public enable_shared_from_this<X> { };
-int main() {
-  shared_ptr<X> p(new X);
-  shared_ptr<X> q = p->shared_from_this();
-  assert(p == q);
-  assert(!p.owner_before(q) && !q.owner_before(p)); // p and q share ownership
-}
-```
-— *end example*]
-``` cpp
-namespace std {
-  template<class T> class enable_shared_from_this {
-  protected:
-    constexpr enable_shared_from_this() noexcept;
-    enable_shared_from_this(const enable_shared_from_this&) noexcept;
-    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
-    ~enable_shared_from_this();
-  public:
-    shared_ptr<T> shared_from_this();
-    shared_ptr<T const> shared_from_this() const;
-    weak_ptr<T> weak_from_this() noexcept;
-    weak_ptr<T const> weak_from_this() const noexcept;
-  private:
-    mutable weak_ptr<T> weak_this; // exposition only
-  };
-}
-```
-The template parameter `T` of `enable_shared_from_this` may be an
-incomplete type.
-``` cpp
-constexpr enable_shared_from_this() noexcept;
-enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;
-```
-*Effects:* Value-initializes `weak_this`.
-``` cpp
-enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
-```
-*Returns:* `*this`.
-[*Note 1*: `weak_this` is not changed. — *end note*]
-``` cpp
-shared_ptr<T>       shared_from_this();
-shared_ptr<T const> shared_from_this() const;
-```
-*Returns:* `shared_ptr<T>(weak_this)`.
-``` cpp
-weak_ptr<T>       weak_from_this() noexcept;
-weak_ptr<T const> weak_from_this() const noexcept;
-```
-*Returns:* `weak_this`.
-#### `shared_ptr` atomic access <a id="util.smartptr.shared.atomic">[[util.smartptr.shared.atomic]]</a>
-Concurrent access to a `shared_ptr` object from multiple threads does
-not introduce a data race if the access is done exclusively via the
-functions in this section and the instance is passed as their first
-argument.
-The meaning of the arguments of type `memory_order` is explained in
-[[atomics.order]].
-``` cpp
-template<class T>
-  bool atomic_is_lock_free(const shared_ptr<T>* p);
-```
-*Requires:* `p` shall not be null.
-*Returns:* `true` if atomic access to `*p` is lock-free, `false`
-otherwise.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_load(const shared_ptr<T>* p);
-```
-*Requires:* `p` shall not be null.
-*Returns:* `atomic_load_explicit(p, memory_order_seq_cst)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
-```
-*Requires:* `p` shall not be null.
-*Requires:* `mo` shall not be `memory_order_release` or
-`memory_order_acq_rel`.
-*Returns:* `*p`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
-```
-*Requires:* `p` shall not be null.
-*Effects:* As if by `atomic_store_explicit(p, r, memory_order_seq_cst)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
-```
-*Requires:* `p` shall not be null.
-*Requires:* `mo` shall not be `memory_order_acquire` or
-`memory_order_acq_rel`.
-*Effects:* As if by `p->swap(r)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
-```
-*Requires:* `p` shall not be null.
-*Returns:* `atomic_exchange_explicit(p, r, memory_order_seq_cst)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
-```
-*Requires:* `p` shall not be null.
-*Effects:* As if by `p->swap(r)`.
-*Returns:* The previous value of `*p`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  bool atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
-```
-*Requires:* `p` shall not be null and `v` shall not be null.
-*Returns:*
-``` cpp
-atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
-```
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  bool atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
-```
-*Returns:*
-``` cpp
-atomic_compare_exchange_strong_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
-```
-``` cpp
-template<class T>
-  bool atomic_compare_exchange_weak_explicit(
-    shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
-    memory_order success, memory_order failure);
-template<class T>
-  bool atomic_compare_exchange_strong_explicit(
-    shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
-    memory_order success, memory_order failure);
-```
-*Requires:* `p` shall not be null and `v` shall not be null. The
-`failure` argument shall not be `memory_order_release` nor
-`memory_order_acq_rel`.
-*Effects:* If `*p` is equivalent to `*v`, assigns `w` to `*p` and has
-synchronization semantics corresponding to the value of `success`,
-otherwise assigns `*p` to `*v` and has synchronization semantics
-corresponding to the value of `failure`.
-*Returns:* `true` if `*p` was equivalent to `*v`, `false` otherwise.
-*Throws:* Nothing.
-*Remarks:* Two `shared_ptr` objects are equivalent if they store the
-same pointer value and share ownership. The weak form may fail
-spuriously. See  [[atomics.types.operations]].
-#### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
-``` cpp
-template <class T, class D> struct hash<unique_ptr<T, D>>;
-```
-Letting `UP` be `unique_ptr<T,D>`, the specialization `hash<UP>` is
-enabled ([[unord.hash]]) if and only if `hash<typename UP::pointer>` is
-enabled. When enabled, for an object `p` of type `UP`, `hash<UP>()(p)`
-shall evaluate to the same value as
-`hash<typename UP::pointer>()(p.get())`. The member functions are not
-guaranteed to be `noexcept`.
-``` cpp
-template <class T> struct hash<shared_ptr<T>>;
-```
-For an object `p` of type `shared_ptr<T>`, `hash<shared_ptr<T>>()(p)`
-shall evaluate to the same value as
-`hash<typename shared_ptr<T>::element_type*>()(p.get())`.

Diff to HTML by rtfpessoa