[unique.ptr, util.smartptr.shared] Remove redundant repetitions of declarations that already appear in the synopsis (#1758)

Author: tkoeppe

source/utilities.tex

@@ -7997,61 +7997,6 @@
 memory to a function, and returning dynamically allocated memory from a
 function. \end{note}
 
-\begin{codeblock}
-namespace std {
-  template<class T> struct default_delete;
-  template<class T> struct default_delete<T[]>;
-
-  template<class T, class D = default_delete<T>> class unique_ptr;
-  template<class T, class D> class unique_ptr<T[], D>;
-
-  template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
-  template<class T> unique_ptr<T> make_unique(size_t n);
-  template<class T, class... Args> @\unspec@ make_unique(Args&&...) = delete;
-
-  template<class T, class D>
-    void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
-
-  template<class T1, class D1, class T2, class D2>
-    bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template<class T1, class D1, class T2, class D2>
-    bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-
-  template <class T, class D>
-    bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-  template <class T, class D>
-    bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
-  template <class T, class D>
-    bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-  template <class T, class D>
-    bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
-  template <class T, class D>
-    bool operator<(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator<(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator>(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator>(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
-}
-\end{codeblock}
-
 \rSec3[unique.ptr.dltr]{Default deleters}
 
 \rSec4[unique.ptr.dltr.general]{In general}
@@ -9186,94 +9131,6 @@
 
   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>;
-
-  // \ref{util.smartptr.shared.create}, \tcode{shared_ptr} creation
-  template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args);                                  // \tcode{T} is not array
-  template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args);                  // \tcode{T} is not array
-
-  template<class T>
-    shared_ptr<T> make_shared(size_t N);                                        // \tcode{T} is \tcode{U[]}
-  template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, size_t N);                        // \tcode{T} is \tcode{U[]}
-
-  template<class T>
-    shared_ptr<T> make_shared();                                                // \tcode{T} is \tcode{U[N]}
-  template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a);                                  // \tcode{T} is \tcode{U[N]}
-
-  template<class T>
-    shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u);           // \tcode{T} is \tcode{U[]}
-  template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, size_t N,
-                                  const remove_extent_t<T>& u);                 // \tcode{T} is \tcode{U[]}
-
-  template<class T> shared_ptr<T>
-    make_shared(const remove_extent_t<T>& u);                                   // \tcode{T} is \tcode{U[N]}
-  template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u);     // \tcode{T} is \tcode{U[N]}
-
-  // \ref{util.smartptr.shared.cmp}, \tcode{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;
-
-  // \ref{util.smartptr.shared.spec}, \tcode{shared_ptr} specialized algorithms
-  template<class T>
-    void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
-
-  // \ref{util.smartptr.shared.cast}, \tcode{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;
-
-  // \ref{util.smartptr.getdeleter}, \tcode{shared_ptr} \tcode{get_deleter}
-  template<class D, class T>
-    D* get_deleter(const shared_ptr<T>& p) noexcept;
-
-  // \ref{util.smartptr.shared.io}, \tcode{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);
 }
 \end{codeblock}