From 52fdab7cdb060f45003395697b973aa60f275853 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 20 Dec 2016 23:03:26 +0100 Subject: [PATCH] Harmonize spacing for template headers. Use 'template'. Also remove space between two closing template brackets in [lib]. Fixes #53. --- source/access.tex | 6 +- source/algorithms.tex | 34 +- source/atomics.tex | 70 +- source/basic.tex | 6 +- source/compatibility.tex | 8 +- source/containers.tex | 1064 ++++++++--------- source/declarations.tex | 20 +- source/declarators.tex | 8 +- source/diagnostics.tex | 42 +- source/future.tex | 88 +- source/iostreams.tex | 266 ++--- source/iterators.tex | 332 +++--- source/lib-intro.tex | 12 +- source/locales.tex | 178 +-- source/numerics.tex | 90 +- source/overloading.tex | 20 +- source/regex.tex | 354 +++--- source/strings.tex | 2 +- source/support.tex | 14 +- source/threads.tex | 238 ++-- source/utilities.tex | 2411 +++++++++++++++++++------------------- 21 files changed, 2633 insertions(+), 2630 deletions(-) diff --git a/source/access.tex b/source/access.tex index 77ccc72669..4428c7d83b 100644 --- a/source/access.tex +++ b/source/access.tex @@ -179,12 +179,12 @@ points of use of the default \grammarterm{template-argument}. \begin{example} \begin{codeblock} class B { }; -template class C { +template class C { protected: typedef T TT; }; -template +template class D : public U { }; D >* d; // access error, \tcode{C::TT} is protected @@ -703,7 +703,7 @@ friend class D; // OK: elaborated-type-specifier declares new class }; -template class R { +template class R { friend T; }; diff --git a/source/algorithms.tex b/source/algorithms.tex index 45352ab688..13b4646d34 100644 --- a/source/algorithms.tex +++ b/source/algorithms.tex @@ -31,19 +31,19 @@ namespace std { // \ref{alg.nonmodifying}, non-modifying sequence operations - template + template bool all_of(InputIterator first, InputIterator last, Predicate pred); - template + template bool all_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, Predicate pred); - template + template bool any_of(InputIterator first, InputIterator last, Predicate pred); - template + template bool any_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, Predicate pred); - template + template bool none_of(InputIterator first, InputIterator last, Predicate pred); - template + template bool none_of(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, Predicate pred); @@ -285,7 +285,7 @@ Size count, const T& value, BinaryPredicate pred); - template + template ForwardIterator search(ForwardIterator first, ForwardIterator last, const Searcher& searcher); @@ -531,9 +531,9 @@ UniformRandomBitGenerator&& g); // \ref{alg.partitions}, partitions - template + template bool is_partitioned(InputIterator first, InputIterator last, Predicate pred); - template + template bool is_partitioned(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, Predicate pred); @@ -555,13 +555,13 @@ BidirectionalIterator first, BidirectionalIterator last, Predicate pred); - template pair partition_copy(InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred); - template pair partition_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} @@ -1440,9 +1440,9 @@ \indexlibrary{\idxcode{all_of}}% \begin{itemdecl} -template +template bool all_of(InputIterator first, InputIterator last, Predicate pred); -template +template bool all_of(ExecutionPolicy&& exec, InputIterator first, InputIterator last, Predicate pred); \end{itemdecl} @@ -1461,9 +1461,9 @@ \indexlibrary{\idxcode{any_of}}% \begin{itemdecl} -template +template bool any_of(InputIterator first, InputIterator last, Predicate pred); -template +template bool any_of(ExecutionPolicy&& exec, InputIterator first, InputIterator last, Predicate pred); \end{itemdecl} @@ -1482,9 +1482,9 @@ \indexlibrary{\idxcode{none_of}}% \begin{itemdecl} -template +template bool none_of(InputIterator first, InputIterator last, Predicate pred); -template +template bool none_of(ExecutionPolicy&& exec, InputIterator first, InputIterator last, Predicate pred); \end{itemdecl} diff --git a/source/atomics.tex b/source/atomics.tex index f5ee38729c..8fe3f60c89 100644 --- a/source/atomics.tex +++ b/source/atomics.tex @@ -34,7 +34,7 @@ namespace std { // \ref{atomics.order}, order and consistency enum memory_order; - template + template T kill_dependency(T y) noexcept; // \ref{atomics.lockfree}, lock-free property @@ -57,7 +57,7 @@ // \ref{atomics.types.operations.general}, general operations on atomic types // In the following declarations, \tcode{\placeholder{atomic-type}} is either \tcode{atomic} or a named base class // for \tcode{T} from Table~\ref{tab:atomics.integral} or inferred from Table~\ref{tab:atomics.typedefs} or from \tcode{bool}. If it is \tcode{atomic}, - // then the declaration is a template declaration prefixed with \tcode{template }. + // then the declaration is a template declaration prefixed with \tcode{template}. bool atomic_is_lock_free(const volatile @\placeholder{atomic-type}@*) noexcept; bool atomic_is_lock_free(const @\placeholder{atomic-type}@*) noexcept; void atomic_init(volatile @\placeholder{atomic-type}@*@\itcorr[-1]@, T) noexcept; @@ -88,51 +88,51 @@ memory_order, memory_order) noexcept; // \ref{atomics.types.operations.templ}, templated operations on atomic types - template + template T atomic_fetch_add(volatile @atomic@*, T) noexcept; - template + template T atomic_fetch_add(@atomic@*, T) noexcept; - template + template T atomic_fetch_add_explicit(volatile atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_add_explicit(atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_sub(volatile atomic*, T) noexcept; - template + template T atomic_fetch_sub(atomic*, T) noexcept; - template + template T atomic_fetch_sub_explicit(volatile atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_sub_explicit(atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_and(volatile atomic*, T) noexcept; - template + template T atomic_fetch_and(atomic*, T) noexcept; - template + template T atomic_fetch_and_explicit(volatile atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_and_explicit(atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_or(volatile atomic*, T) noexcept; - template + template T atomic_fetch_or(atomic*, T) noexcept; - template + template T atomic_fetch_or_explicit(volatile atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_or_explicit(atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_xor(volatile atomic*, T) noexcept; - template + template T atomic_fetch_xor(atomic*, T) noexcept; - template + template T atomic_fetch_xor_explicit(volatile atomic*, T, memory_order) noexcept; - template + template T atomic_fetch_xor_explicit(atomic*, T, memory_order) noexcept; // \ref{atomics.types.operations.arith}, arithmetic operations on atomic types // In the following declarations, \tcode{\placeholder{atomic-integral}} is either \tcode{atomic} or a named base class // for \tcode{T} from Table~\ref{tab:atomics.integral} or inferred from Table~\ref{tab:atomics.typedefs}. If it is \tcode{atomic}, then the declaration - // is a template specialization declaration prefixed with \tcode{template <>}. + // is a template specialization declaration prefixed with \tcode{template<>}. @\placeholdernc{integral}@ atomic_fetch_add(volatile @\placeholder{atomic-integral}@*@\itcorr[-1]@, @\placeholdernc{integral}@) noexcept; @\placeholdernc{integral}@ atomic_fetch_add(@\placeholder{atomic-integral}@*@\itcorr[-1]@, @\placeholdernc{integral}@) noexcept; @\placeholdernc{integral}@ atomic_fetch_add_explicit(volatile @\placeholder{atomic-integral}@*@\itcorr[-1]@, @\placeholdernc{integral}@, memory_order) noexcept; @@ -155,21 +155,21 @@ @\placeholdernc{integral}@ atomic_fetch_xor_explicit(@\placeholder{atomic-integral}@*@\itcorr[-1]@, @\placeholdernc{integral}@, memory_order) noexcept; // \ref{atomics.types.operations.pointer}, non-member overloads for atomic - template + template T* atomic_fetch_add(volatile atomic*, ptrdiff_t) noexcept; - template + template T* atomic_fetch_add(atomic*, ptrdiff_t) noexcept; - template + template T* atomic_fetch_add_explicit(volatile atomic*, ptrdiff_t, memory_order) noexcept; - template + template T* atomic_fetch_add_explicit(atomic*, ptrdiff_t, memory_order) noexcept; - template + template T* atomic_fetch_sub(volatile atomic*, ptrdiff_t) noexcept; - template + template T* atomic_fetch_sub(atomic*, ptrdiff_t) noexcept; - template + template T* atomic_fetch_sub_explicit(volatile atomic*, ptrdiff_t, memory_order) noexcept; - template + template T* atomic_fetch_sub_explicit(atomic*, ptrdiff_t, memory_order) noexcept; // \ref{atomics.types.operations.req}, initialization @@ -364,7 +364,7 @@ \indexlibrary{\idxcode{kill_dependency}}% \begin{itemdecl} -template +template T kill_dependency(T y) noexcept; \end{itemdecl} @@ -437,7 +437,7 @@ \indexlibrary{\idxcode{atomic<\placeholder{integral}>}}% \begin{codeblock} namespace std { - template struct atomic { + template struct atomic { static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; @@ -467,7 +467,7 @@ T operator=(T) noexcept; }; - template <> struct atomic<@\placeholder{integral}@> { + template<> struct atomic<@\placeholder{integral}@> { static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; @@ -534,7 +534,7 @@ @\placeholdernc{integral}@ operator^=(@\placeholdernc{integral}@) noexcept; }; - template struct atomic { + template struct atomic { static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; diff --git a/source/basic.tex b/source/basic.tex index bdae264dbf..412af5f000 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -1360,7 +1360,7 @@ typedef int AT; void f1(AT); void f2(float); - template void f3(); + template void f3(); }; struct B { typedef char AT; @@ -2163,7 +2163,7 @@ namespace N { struct A { void g() { } - template operator T(); + template operator T(); }; } @@ -2374,7 +2374,7 @@ \begin{example} \begin{codeblock} -template struct B { +template struct B { void g(T) { } void h(T); friend void i(B, T) { } diff --git a/source/compatibility.tex b/source/compatibility.tex index a3a08d0fd1..1660572720 100644 --- a/source/compatibility.tex +++ b/source/compatibility.tex @@ -994,8 +994,8 @@ ``\tcode{>>}'' closes two templates. \begin{codeblock} -template struct X { }; -template struct Y { }; +template struct X { }; +template struct Y { }; X< Y< 1 >> 2 > > x; \end{codeblock} @@ -1622,8 +1622,8 @@ \effect Valid \CppXIV code may fail to compile or produce different results in this International Standard: \begin{codeblock} -template struct A; -template int foo(A *) = delete; +template struct A; +template int foo(A *) = delete; void foo(void *); void bar(A<0> *p) { foo(p); // ill-formed; previously well-formed diff --git a/source/containers.tex b/source/containers.tex index 2ef175bff5..6bd79086ed 100644 --- a/source/containers.tex +++ b/source/containers.tex @@ -982,7 +982,7 @@ \begin{itemize} \item If the constructor \begin{codeblock} -template +template X(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()); \end{codeblock} @@ -992,14 +992,14 @@ \item If the member functions of the forms: \begin{codeblock} -template +template @\placeholdernc{return-type}@ @\placeholdernc{F}@(const_iterator p, InputIterator first, InputIterator last); // such as \tcode{insert} -template +template @\placeholdernc{return-type}@ @\placeholdernc{F}@(InputIterator first, InputIterator last); // such as \tcode{append}, \tcode{assign} -template +template @\placeholdernc{return-type}@ @\placeholdernc{F}@(const_iterator i1, const_iterator i2, InputIterator first, InputIterator last); // such as \tcode{replace} \end{codeblock} @@ -1436,7 +1436,7 @@ That return type is a specialization of the type specified in this subclause. \begin{codeblock} -template +template struct @\textit{INSERT_RETURN_TYPE}@ { Iterator position; @@ -2883,35 +2883,35 @@ namespace std { // \ref{array}, class template \tcode{array} - template struct array; - template + template struct array; + template bool operator==(const array& x, const array& y); - template + template bool operator!=(const array& x, const array& y); - template + template bool operator< (const array& x, const array& y); - template + template bool operator> (const array& x, const array& y); - template + template bool operator<=(const array& x, const array& y); - template + template bool operator>=(const array& x, const array& y); - template + template void swap(array& x, array& y) noexcept(noexcept(x.swap(y))); - template class tuple_size; - template class tuple_element; - template + template class tuple_size; + template class tuple_element; + template struct tuple_size>; - template + template struct tuple_element>; - template + template constexpr T& get(array&) noexcept; - template + template constexpr T&& get(array&&) noexcept; - template + template constexpr const T& get(const array&) noexcept; - template + template constexpr const T&& get(const array&&) noexcept; } \end{codeblock} @@ -2926,25 +2926,25 @@ namespace std { // \ref{deque}, class template \tcode{deque} - template > class deque; - template + template> class deque; + template bool operator==(const deque& x, const deque& y); - template + template bool operator< (const deque& x, const deque& y); - template + template bool operator!=(const deque& x, const deque& y); - template + template bool operator> (const deque& x, const deque& y); - template + template bool operator>=(const deque& x, const deque& y); - template + template bool operator<=(const deque& x, const deque& y); - template + template void swap(deque& x, deque& y) noexcept(noexcept(x.swap(y))); namespace pmr { - template + template using deque = std::deque>; } } @@ -2960,25 +2960,25 @@ namespace std { // \ref{forwardlist}, class template \tcode{forward_list} - template > class forward_list; - template + template> class forward_list; + template bool operator==(const forward_list& x, const forward_list& y); - template + template bool operator< (const forward_list& x, const forward_list& y); - template + template bool operator!=(const forward_list& x, const forward_list& y); - template + template bool operator> (const forward_list& x, const forward_list& y); - template + template bool operator>=(const forward_list& x, const forward_list& y); - template + template bool operator<=(const forward_list& x, const forward_list& y); - template + template void swap(forward_list& x, forward_list& y) noexcept(noexcept(x.swap(y))); namespace pmr { - template + template using forward_list = std::forward_list>; } } @@ -2994,25 +2994,25 @@ namespace std { // \ref{list}, class template \tcode{list} - template > class list; - template + template> class list; + template bool operator==(const list& x, const list& y); - template + template bool operator< (const list& x, const list& y); - template + template bool operator!=(const list& x, const list& y); - template + template bool operator> (const list& x, const list& y); - template + template bool operator>=(const list& x, const list& y); - template + template bool operator<=(const list& x, const list& y); - template + template void swap(list& x, list& y) noexcept(noexcept(x.swap(y))); namespace pmr { - template + template using list = std::list>; } } @@ -3028,32 +3028,32 @@ namespace std { // \ref{vector}, class template \tcode{vector} - template > class vector; - template + template> class vector; + template bool operator==(const vector& x, const vector& y); - template + template bool operator< (const vector& x, const vector& y); - template + template bool operator!=(const vector& x, const vector& y); - template + template bool operator> (const vector& x, const vector& y); - template + template bool operator>=(const vector& x, const vector& y); - template + template bool operator<=(const vector& x, const vector& y); - template + template void swap(vector& x, vector& y) noexcept(noexcept(x.swap(y))); // \ref{vector.bool}, class \tcode{vector} - template class vector; + template class vector; // hash support - template struct hash; - template struct hash>; + template struct hash; + template struct hash>; namespace pmr { - template + template using vector = std::vector>; } } @@ -3098,7 +3098,7 @@ \indexlibrarymember{array}{max_size}% \begin{codeblock} namespace std { - template + template struct array { // types: using value_type = T; @@ -3173,7 +3173,7 @@ \indexlibrarymember{array}{swap}% \begin{itemdecl} -template +template void swap(array& x, array& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -3193,7 +3193,7 @@ \indexlibrarymember{array}{size}% \begin{itemdecl} -template constexpr size_type array::size() const noexcept; +template constexpr size_type array::size() const noexcept; \end{itemdecl} \begin{itemdescr} @@ -3266,7 +3266,7 @@ \indextext{\idxcode{array}!tuple interface to}% \indexlibrary{\idxcode{tuple_size}}% \begin{itemdecl} -template +template struct tuple_size> : integral_constant { }; \end{itemdecl} @@ -3285,13 +3285,13 @@ \indexlibrarymember{array}{get}% \begin{itemdecl} -template +template constexpr T& get(array& a) noexcept; -template +template constexpr T&& get(array&& a) noexcept; -template +template constexpr const T& get(const array& a) noexcept; -template +template constexpr const T&& get(const array&& a) noexcept; \end{itemdecl} @@ -3331,7 +3331,7 @@ \begin{codeblock} namespace std { - template > + template> class deque { public: // types: @@ -3353,7 +3353,7 @@ explicit deque(const Allocator&); explicit deque(size_type n, const Allocator& = Allocator()); deque(size_type n, const T& value, const Allocator& = Allocator()); - template + template deque(InputIterator first, InputIterator last, const Allocator& = Allocator()); deque(const deque& x); deque(deque&&); @@ -3366,7 +3366,7 @@ deque& operator=(deque&& x) noexcept(allocator_traits::is_always_equal::value); deque& operator=(initializer_list); - template + template void assign(InputIterator first, InputIterator last); void assign(size_type n, const T& t); void assign(initializer_list); @@ -3406,9 +3406,9 @@ const_reference back() const; // \ref{deque.modifiers}, modifiers - template reference emplace_front(Args&&... args); - template reference emplace_back(Args&&... args); - template iterator emplace(const_iterator position, Args&&... args); + template reference emplace_front(Args&&... args); + template reference emplace_back(Args&&... args); + template iterator emplace(const_iterator position, Args&&... args); void push_front(const T& x); void push_front(T&& x); @@ -3418,7 +3418,7 @@ iterator insert(const_iterator position, const T& x); iterator insert(const_iterator position, T&& x); iterator insert(const_iterator position, size_type n, const T& x); - template + template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list); @@ -3432,21 +3432,21 @@ void clear() noexcept; }; - template + template bool operator==(const deque& x, const deque& y); - template + template bool operator< (const deque& x, const deque& y); - template + template bool operator!=(const deque& x, const deque& y); - template + template bool operator> (const deque& x, const deque& y); - template + template bool operator>=(const deque& x, const deque& y); - template + template bool operator<=(const deque& x, const deque& y); // \ref{deque.special}, specialized algorithms - template + template void swap(deque& x, deque& y) noexcept(noexcept(x.swap(y))); } @@ -3511,7 +3511,7 @@ \indexlibrary{\idxcode{deque}!constructor}% \begin{itemdecl} -template +template deque(InputIterator first, InputIterator last, const Allocator& = Allocator()); \end{itemdecl} @@ -3596,14 +3596,14 @@ iterator insert(const_iterator position, const T& x); iterator insert(const_iterator position, T&& x); iterator insert(const_iterator position, size_type n, const T& x); -template +template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list); -template reference emplace_front(Args&&... args); -template reference emplace_back(Args&&... args); -template iterator emplace(const_iterator position, Args&&... args); +template reference emplace_front(Args&&... args); +template reference emplace_back(Args&&... args); +template iterator emplace(const_iterator position, Args&&... args); void push_front(const T& x); void push_front(T&& x); void push_back(const T& x); @@ -3677,7 +3677,7 @@ \indexlibrarymember{swap}{deque}% \begin{itemdecl} -template +template void swap(deque& x, deque& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -3721,7 +3721,7 @@ \begin{codeblock} namespace std { - template > + template> class forward_list { public: // types: @@ -3742,7 +3742,7 @@ explicit forward_list(size_type n, const Allocator& = Allocator()); forward_list(size_type n, const T& value, const Allocator& = Allocator()); - template + template forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator()); forward_list(const forward_list& x); @@ -3755,7 +3755,7 @@ forward_list& operator=(forward_list&& x) noexcept(allocator_traits::is_always_equal::value); forward_list& operator=(initializer_list); - template + template void assign(InputIterator first, InputIterator last); void assign(size_type n, const T& t); void assign(initializer_list); @@ -3782,17 +3782,17 @@ const_reference front() const; // \ref{forwardlist.modifiers}, modifiers - template reference emplace_front(Args&&... args); + template reference emplace_front(Args&&... args); void push_front(const T& x); void push_front(T&& x); void pop_front(); - template iterator emplace_after(const_iterator position, Args&&... args); + template iterator emplace_after(const_iterator position, Args&&... args); iterator insert_after(const_iterator position, const T& x); iterator insert_after(const_iterator position, T&& x); iterator insert_after(const_iterator position, size_type n, const T& x); - template + template iterator insert_after(const_iterator position, InputIterator first, InputIterator last); iterator insert_after(const_iterator position, initializer_list il); @@ -3818,37 +3818,37 @@ const_iterator first, const_iterator last); void remove(const T& value); - template void remove_if(Predicate pred); + template void remove_if(Predicate pred); void unique(); - template void unique(BinaryPredicate binary_pred); + template void unique(BinaryPredicate binary_pred); void merge(forward_list& x); void merge(forward_list&& x); - template void merge(forward_list& x, Compare comp); - template void merge(forward_list&& x, Compare comp); + template void merge(forward_list& x, Compare comp); + template void merge(forward_list&& x, Compare comp); void sort(); - template void sort(Compare comp); + template void sort(Compare comp); void reverse() noexcept; }; - template + template bool operator==(const forward_list& x, const forward_list& y); - template + template bool operator< (const forward_list& x, const forward_list& y); - template + template bool operator!=(const forward_list& x, const forward_list& y); - template + template bool operator> (const forward_list& x, const forward_list& y); - template + template bool operator>=(const forward_list& x, const forward_list& y); - template + template bool operator<=(const forward_list& x, const forward_list& y); // \ref{forwardlist.spec}, specialized algorithms - template + template void swap(forward_list& x, forward_list& y) noexcept(noexcept(x.swap(y))); } @@ -3911,7 +3911,7 @@ \indexlibrary{\idxcode{forward_list}!constructor}% \begin{itemdecl} -template +template forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator()); \end{itemdecl} @@ -3973,7 +3973,7 @@ \indexlibrarymember{emplace_front}{forward_list}% \begin{itemdecl} -template reference emplace_front(Args&&... args); +template reference emplace_front(Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4042,7 +4042,7 @@ \indexlibrarymember{insert_after}{forward_list}% \begin{itemdecl} -template +template iterator insert_after(const_iterator position, InputIterator first, InputIterator last); \end{itemdecl} @@ -4077,7 +4077,7 @@ \indexlibrarymember{emplace_after}{forward_list}% \begin{itemdecl} -template +template iterator emplace_after(const_iterator position, Args&&... args); \end{itemdecl} @@ -4264,7 +4264,7 @@ \indexlibrarymember{remove_if}{forward_list}% \begin{itemdecl} void remove(const T& value); -template void remove_if(Predicate pred); +template void remove_if(Predicate pred); \end{itemdecl} \begin{itemdescr} @@ -4289,7 +4289,7 @@ \indexlibrarymember{unique}{forward_list}% \begin{itemdecl} void unique(); -template void unique(BinaryPredicate pred); +template void unique(BinaryPredicate pred); \end{itemdecl} \begin{itemdescr} @@ -4311,8 +4311,8 @@ \begin{itemdecl} void merge(forward_list& x); void merge(forward_list&& x); -template void merge(forward_list& x, Compare comp); -template void merge(forward_list&& x, Compare comp); +template void merge(forward_list& x, Compare comp); +template void merge(forward_list&& x, Compare comp); \end{itemdecl} \begin{itemdescr} @@ -4342,7 +4342,7 @@ \indexlibrarymember{sort}{forward_list}% \begin{itemdecl} void sort(); -template void sort(Compare comp); +template void sort(Compare comp); \end{itemdecl} \begin{itemdescr} @@ -4380,7 +4380,7 @@ \indexlibrarymember{swap}{forward_list}% \begin{itemdecl} -template +template void swap(forward_list& x, forward_list& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -4427,7 +4427,7 @@ \begin{codeblock} namespace std { - template > + template> class list { public: // types: @@ -4449,7 +4449,7 @@ explicit list(const Allocator&); explicit list(size_type n, const Allocator& = Allocator()); list(size_type n, const T& value, const Allocator& = Allocator()); - template + template list(InputIterator first, InputIterator last, const Allocator& = Allocator()); list(const list& x); list(list&& x); @@ -4461,7 +4461,7 @@ list& operator=(list&& x) noexcept(allocator_traits::is_always_equal::value); list& operator=(initializer_list); - template + template void assign(InputIterator first, InputIterator last); void assign(size_type n, const T& t); void assign(initializer_list); @@ -4496,8 +4496,8 @@ const_reference back() const; // \ref{list.modifiers}, modifiers - template reference emplace_front(Args&&... args); - template reference emplace_back(Args&&... args); + template reference emplace_front(Args&&... args); + template reference emplace_back(Args&&... args); void push_front(const T& x); void push_front(T&& x); void pop_front(); @@ -4505,11 +4505,11 @@ void push_back(T&& x); void pop_back(); - template iterator emplace(const_iterator position, Args&&... args); + template iterator emplace(const_iterator position, Args&&... args); iterator insert(const_iterator position, const T& x); iterator insert(const_iterator position, T&& x); iterator insert(const_iterator position, size_type n, const T& x); - template + template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list il); @@ -4531,38 +4531,38 @@ const_iterator first, const_iterator last); void remove(const T& value); - template void remove_if(Predicate pred); + template void remove_if(Predicate pred); void unique(); - template + template void unique(BinaryPredicate binary_pred); void merge(list& x); void merge(list&& x); - template void merge(list& x, Compare comp); - template void merge(list&& x, Compare comp); + template void merge(list& x, Compare comp); + template void merge(list&& x, Compare comp); void sort(); - template void sort(Compare comp); + template void sort(Compare comp); void reverse() noexcept; }; - template + template bool operator==(const list& x, const list& y); - template + template bool operator< (const list& x, const list& y); - template + template bool operator!=(const list& x, const list& y); - template + template bool operator> (const list& x, const list& y); - template + template bool operator>=(const list& x, const list& y); - template + template bool operator<=(const list& x, const list& y); // \ref{list.special}, specialized algorithms - template + template void swap(list& x, list& y) noexcept(noexcept(x.swap(y))); } @@ -4638,7 +4638,7 @@ \indexlibrary{\idxcode{list}!constructor}% \begin{itemdecl} -template +template list(InputIterator first, InputIterator last, const Allocator& = Allocator()); \end{itemdecl} @@ -4715,14 +4715,14 @@ iterator insert(const_iterator position, const T& x); iterator insert(const_iterator position, T&& x); iterator insert(const_iterator position, size_type n, const T& x); -template +template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list); -template reference emplace_front(Args&&... args); -template reference emplace_back(Args&&... args); -template iterator emplace(const_iterator position, Args&&... args); +template reference emplace_front(Args&&... args); +template reference emplace_back(Args&&... args); +template iterator emplace(const_iterator position, Args&&... args); void push_front(const T& x); void push_front(T&& x); void push_back(const T& x); @@ -4921,7 +4921,7 @@ \indexlibrary{\idxcode{remove}!\idxcode{list}}% \begin{itemdecl} void remove(const T& value); -template void remove_if(Predicate pred); +template void remove_if(Predicate pred); \end{itemdecl} \begin{itemdescr} @@ -4951,7 +4951,7 @@ \indexlibrary{\idxcode{unique}!\idxcode{list}}% \begin{itemdecl} void unique(); -template void unique(BinaryPredicate binary_pred); +template void unique(BinaryPredicate binary_pred); \end{itemdecl} \begin{itemdescr} @@ -4985,8 +4985,8 @@ \begin{itemdecl} void merge(list& x); void merge(list&& x); -template void merge(list& x, Compare comp); -template void merge(list&& x, Compare comp); +template void merge(list& x, Compare comp); +template void merge(list&& x, Compare comp); \end{itemdecl} \begin{itemdescr} @@ -5042,7 +5042,7 @@ \indexlibrary{\idxcode{sort}!\idxcode{list}}% \begin{itemdecl} void sort(); -template void sort(Compare comp); +template void sort(Compare comp); \end{itemdecl} \begin{itemdescr} @@ -5076,7 +5076,7 @@ \indexlibrarymember{swap}{list}% \begin{itemdecl} -template +template void swap(list& x, list& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -5117,7 +5117,7 @@ \begin{codeblock} namespace std { - template > + template> class vector { public: // types: @@ -5139,7 +5139,7 @@ explicit vector(const Allocator&) noexcept; explicit vector(size_type n, const Allocator& = Allocator()); vector(size_type n, const T& value, const Allocator& = Allocator()); - template + template vector(InputIterator first, InputIterator last, const Allocator& = Allocator()); vector(const vector& x); vector(vector&&) noexcept; @@ -5152,7 +5152,7 @@ noexcept(allocator_traits::propagate_on_container_move_assignment::value || allocator_traits::is_always_equal::value); vector& operator=(initializer_list); - template + template void assign(InputIterator first, InputIterator last); void assign(size_type n, const T& u); void assign(initializer_list); @@ -5198,16 +5198,16 @@ const T* data() const noexcept; // \ref{vector.modifiers}, modifiers - template reference emplace_back(Args&&... args); + template reference emplace_back(Args&&... args); void push_back(const T& x); void push_back(T&& x); void pop_back(); - template iterator emplace(const_iterator position, Args&&... args); + template iterator emplace(const_iterator position, Args&&... args); iterator insert(const_iterator position, const T& x); iterator insert(const_iterator position, T&& x); iterator insert(const_iterator position, size_type n, const T& x); - template + template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list il); iterator erase(const_iterator position); @@ -5218,21 +5218,21 @@ void clear() noexcept; }; - template + template bool operator==(const vector& x, const vector& y); - template + template bool operator< (const vector& x, const vector& y); - template + template bool operator!=(const vector& x, const vector& y); - template + template bool operator> (const vector& x, const vector& y); - template + template bool operator>=(const vector& x, const vector& y); - template + template bool operator<=(const vector& x, const vector& y); // \ref{vector.special}, specialized algorithms - template + template void swap(vector& x, vector& y) noexcept(noexcept(x.swap(y))); } @@ -5301,7 +5301,7 @@ \indexlibrary{\idxcode{vector}!constructor} \begin{itemdecl} -template +template vector(InputIterator first, InputIterator last, const Allocator& = Allocator()); \end{itemdecl} @@ -5511,12 +5511,12 @@ iterator insert(const_iterator position, const T& x); iterator insert(const_iterator position, T&& x); iterator insert(const_iterator position, size_type n, const T& x); -template +template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list); -template reference emplace_back(Args&&... args); -template iterator emplace(const_iterator position, Args&&... args); +template reference emplace_back(Args&&... args); +template iterator emplace(const_iterator position, Args&&... args); void push_back(const T& x); void push_back(T&& x); \end{itemdecl} @@ -5576,7 +5576,7 @@ \indexlibrarymember{swap}{vector}% \begin{itemdecl} -template +template void swap(vector& x, vector& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -5597,7 +5597,7 @@ \begin{codeblock} namespace std { - template + template class vector { public: // types: @@ -5631,7 +5631,7 @@ explicit vector(size_type n, const Allocator& = Allocator()); vector(size_type n, const bool& value, const Allocator& = Allocator()); - template + template vector(InputIterator first, InputIterator last, const Allocator& = Allocator()); vector(const vector& x); @@ -5643,7 +5643,7 @@ vector& operator=(const vector& x); vector& operator=(vector&& x); vector& operator=(initializer_list); - template + template void assign(InputIterator first, InputIterator last); void assign(size_type n, const bool& t); void assign(initializer_list); @@ -5684,13 +5684,13 @@ const_reference back() const; // modifiers: - template reference emplace_back(Args&&... args); + template reference emplace_back(Args&&... args); void push_back(const bool& x); void pop_back(); - template iterator emplace(const_iterator position, Args&&... args); + template iterator emplace(const_iterator position, Args&&... args); iterator insert(const_iterator position, const bool& x); iterator insert(const_iterator position, size_type n, const bool& x); - template + template iterator insert(const_iterator position, InputIterator first, InputIterator last); iterator insert(const_iterator position, initializer_list il); @@ -5754,7 +5754,7 @@ \end{itemdescr} \begin{itemdecl} -template struct hash>; +template struct hash>; \end{itemdecl} \begin{itemdescr} @@ -5780,65 +5780,65 @@ namespace std { // \ref{map}, class template \tcode{map} - template , - class Allocator = allocator>> + template, + class Allocator = allocator>> class map; - template + template bool operator==(const map& x, const map& y); - template + template bool operator< (const map& x, const map& y); - template + template bool operator!=(const map& x, const map& y); - template + template bool operator> (const map& x, const map& y); - template + template bool operator>=(const map& x, const map& y); - template + template bool operator<=(const map& x, const map& y); - template + template void swap(map& x, map& y) noexcept(noexcept(x.swap(y))); // \ref{multimap}, class template \tcode{multimap} - template , - class Allocator = allocator>> + template, + class Allocator = allocator>> class multimap; - template + template bool operator==(const multimap& x, const multimap& y); - template + template bool operator< (const multimap& x, const multimap& y); - template + template bool operator!=(const multimap& x, const multimap& y); - template + template bool operator> (const multimap& x, const multimap& y); - template + template bool operator>=(const multimap& x, const multimap& y); - template + template bool operator<=(const multimap& x, const multimap& y); - template + template void swap(multimap& x, multimap& y) noexcept(noexcept(x.swap(y))); namespace pmr { - template > + template> using map = std::map>>; - template > + template> using multimap = std::multimap>>; } @@ -5855,65 +5855,65 @@ namespace std { // \ref{set}, class template \tcode{set} - template , - class Allocator = allocator> + template, + class Allocator = allocator> class set; - template + template bool operator==(const set& x, const set& y); - template + template bool operator< (const set& x, const set& y); - template + template bool operator!=(const set& x, const set& y); - template + template bool operator> (const set& x, const set& y); - template + template bool operator>=(const set& x, const set& y); - template + template bool operator<=(const set& x, const set& y); - template + template void swap(set& x, set& y) noexcept(noexcept(x.swap(y))); // \ref{multiset}, class template \tcode{multiset} - template , - class Allocator = allocator> + template, + class Allocator = allocator> class multiset; - template + template bool operator==(const multiset& x, const multiset& y); - template + template bool operator< (const multiset& x, const multiset& y); - template + template bool operator!=(const multiset& x, const multiset& y); - template + template bool operator> (const multiset& x, const multiset& y); - template + template bool operator>=(const multiset& x, const multiset& y); - template + template bool operator<=(const multiset& x, const multiset& y); - template + template void swap(multiset& x, multiset& y) noexcept(noexcept(x.swap(y))); namespace pmr { - template > + template> using set = std::set>; - template > + template> using multiset = std::multiset>; } @@ -5965,7 +5965,7 @@ \begin{codeblock} namespace std { - template , + template, class Allocator = allocator>> class map { public: @@ -6002,7 +6002,7 @@ // \ref{map.cons}, construct/copy/destroy map() : map(Compare()) { } explicit map(const Compare& comp, const Allocator& = Allocator()); - template + template map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); map(const map& x); @@ -6013,7 +6013,7 @@ map(initializer_list, const Compare& = Compare(), const Allocator& = Allocator()); - template + template map(InputIterator first, InputIterator last, const Allocator& a) : map(first, last, Compare(), a) { } map(initializer_list il, const Allocator& a) @@ -6054,16 +6054,16 @@ const T& at(const key_type& x) const; // \ref{map.modifiers}, modifiers - template pair emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template pair emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& x); pair insert(value_type&& x); - template pair insert(P&& x); + template pair insert(P&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); - template + template iterator insert(const_iterator position, P&&); - template + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); @@ -6072,21 +6072,21 @@ insert_return_type insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh); - template + template pair try_emplace(const key_type& k, Args&&... args); - template + template pair try_emplace(key_type&& k, Args&&... args); - template + template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); - template + template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); - template + template pair insert_or_assign(const key_type& k, M&& obj); - template + template pair insert_or_assign(key_type&& k, M&& obj); - template + template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); - template + template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); iterator erase(iterator position); @@ -6114,51 +6114,51 @@ // map operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; - template iterator find(const K& x); - template const_iterator find(const K& x) const; + template iterator find(const K& x); + template const_iterator find(const K& x) const; size_type count(const key_type& x) const; - template size_type count(const K& x) const; + template size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; - template iterator lower_bound(const K& x); - template const_iterator lower_bound(const K& x) const; + template iterator lower_bound(const K& x); + template const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; - template iterator upper_bound(const K& x); - template const_iterator upper_bound(const K& x) const; + template iterator upper_bound(const K& x); + template const_iterator upper_bound(const K& x) const; pair equal_range(const key_type& x); pair equal_range(const key_type& x) const; - template + template pair equal_range(const K& x); - template + template pair equal_range(const K& x) const; }; - template + template bool operator==(const map& x, const map& y); - template + template bool operator< (const map& x, const map& y); - template + template bool operator!=(const map& x, const map& y); - template + template bool operator> (const map& x, const map& y); - template + template bool operator>=(const map& x, const map& y); - template + template bool operator<=(const map& x, const map& y); // \ref{map.special}, specialized algorithms - template + template void swap(map& x, map& y) noexcept(noexcept(x.swap(y))); @@ -6189,7 +6189,7 @@ \indexlibrary{\idxcode{map}!constructor}% \begin{itemdecl} -template +template map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); \end{itemdecl} @@ -6260,9 +6260,9 @@ \indexlibrarymember{insert}{map}% \begin{itemdecl} -template +template pair insert(P&& x); -template +template iterator insert(const_iterator position, P&& x); \end{itemdecl} @@ -6282,9 +6282,9 @@ \indexlibrarymember{try_emplace}{map}% \begin{itemdecl} -template +template pair try_emplace(const key_type& k, Args&&... args); -template +template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); \end{itemdecl} @@ -6320,9 +6320,9 @@ \indexlibrarymember{try_emplace}{map}% \begin{itemdecl} -template +template pair try_emplace(key_type&& k, Args&&... args); -template +template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); \end{itemdecl} @@ -6358,9 +6358,9 @@ \indexlibrarymember{insert_or_assign}{map}% \begin{itemdecl} -template +template pair insert_or_assign(const key_type& k, M&& obj); -template +template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); \end{itemdecl} @@ -6395,9 +6395,9 @@ \indexlibrarymember{insert_or_assign}{map}% \begin{itemdecl} -template +template pair insert_or_assign(key_type&& k, M&& obj); -template +template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); \end{itemdecl} @@ -6434,7 +6434,7 @@ \indexlibrarymember{swap}{map}% \begin{itemdecl} -template +template void swap(map& x, map& y) noexcept(noexcept(x.swap(y))); @@ -6498,7 +6498,7 @@ \begin{codeblock} namespace std { - template , + template, class Allocator = allocator>> class multimap { public: @@ -6534,7 +6534,7 @@ // \ref{multimap.cons}, construct/copy/destroy multimap() : multimap(Compare()) { } explicit multimap(const Compare& comp, const Allocator& = Allocator()); - template + template multimap(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); @@ -6546,7 +6546,7 @@ multimap(initializer_list, const Compare& = Compare(), const Allocator& = Allocator()); - template + template multimap(InputIterator first, InputIterator last, const Allocator& a) : multimap(first, last, Compare(), a) { } multimap(initializer_list il, const Allocator& a) @@ -6581,15 +6581,15 @@ size_type max_size() const noexcept; // \ref{multimap.modifiers}, modifiers - template iterator emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template iterator emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& x); iterator insert(value_type&& x); - template iterator insert(P&& x); + template iterator insert(P&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); - template iterator insert(const_iterator position, P&& x); - template + template iterator insert(const_iterator position, P&& x); + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); @@ -6623,51 +6623,51 @@ // map operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; - template iterator find(const K& x); - template const_iterator find(const K& x) const; + template iterator find(const K& x); + template const_iterator find(const K& x) const; size_type count(const key_type& x) const; - template size_type count(const K& x) const; + template size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; - template iterator lower_bound(const K& x); - template const_iterator lower_bound(const K& x) const; + template iterator lower_bound(const K& x); + template const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; - template iterator upper_bound(const K& x); - template const_iterator upper_bound(const K& x) const; + template iterator upper_bound(const K& x); + template const_iterator upper_bound(const K& x) const; pair equal_range(const key_type& x); pair equal_range(const key_type& x) const; - template + template pair equal_range(const K& x); - template + template pair equal_range(const K& x) const; }; - template + template bool operator==(const multimap& x, const multimap& y); - template + template bool operator< (const multimap& x, const multimap& y); - template + template bool operator!=(const multimap& x, const multimap& y); - template + template bool operator> (const multimap& x, const multimap& y); - template + template bool operator>=(const multimap& x, const multimap& y); - template + template bool operator<=(const multimap& x, const multimap& y); // \ref{multimap.special}, specialized algorithms - template + template void swap(multimap& x, multimap& y) noexcept(noexcept(x.swap(y))); @@ -6697,7 +6697,7 @@ \indexlibrary{\idxcode{multimap}!constructor}% \begin{itemdecl} -template +template multimap(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); @@ -6726,8 +6726,8 @@ \indexlibrarymember{insert}{multimap}% \begin{itemdecl} -template iterator insert(P&& x); -template iterator insert(const_iterator position, P&& x); +template iterator insert(P&& x); +template iterator insert(const_iterator position, P&& x); \end{itemdecl} \begin{itemdescr} @@ -6748,7 +6748,7 @@ \indexlibrarymember{swap}{multimap}% \begin{itemdecl} -template +template void swap(multimap& x, multimap& y) noexcept(noexcept(x.swap(y))); @@ -6806,7 +6806,7 @@ \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class set { public: @@ -6832,7 +6832,7 @@ // \ref{set.cons}, construct/copy/destroy set() : set(Compare()) { } explicit set(const Compare& comp, const Allocator& = Allocator()); - template + template set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); set(const set& x); @@ -6842,7 +6842,7 @@ set(set&&, const Allocator&); set(initializer_list, const Compare& = Compare(), const Allocator& = Allocator()); - template + template set(InputIterator first, InputIterator last, const Allocator& a) : set(first, last, Compare(), a) { } set(initializer_list il, const Allocator& a) @@ -6877,13 +6877,13 @@ size_type max_size() const noexcept; // modifiers: - template pair emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template pair emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& x); pair insert(value_type&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); - template + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); @@ -6917,51 +6917,51 @@ // set operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; - template iterator find(const K& x); - template const_iterator find(const K& x) const; + template iterator find(const K& x); + template const_iterator find(const K& x) const; size_type count(const key_type& x) const; - template size_type count(const K& x) const; + template size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; - template iterator lower_bound(const K& x); - template const_iterator lower_bound(const K& x) const; + template iterator lower_bound(const K& x); + template const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; - template iterator upper_bound(const K& x); - template const_iterator upper_bound(const K& x) const; + template iterator upper_bound(const K& x); + template const_iterator upper_bound(const K& x) const; pair equal_range(const key_type& x); pair equal_range(const key_type& x) const; - template + template pair equal_range(const K& x); - template + template pair equal_range(const K& x) const; }; - template + template bool operator==(const set& x, const set& y); - template + template bool operator< (const set& x, const set& y); - template + template bool operator!=(const set& x, const set& y); - template + template bool operator> (const set& x, const set& y); - template + template bool operator>=(const set& x, const set& y); - template + template bool operator<=(const set& x, const set& y); // \ref{set.special}, specialized algorithms - template + template void swap(set& x, set& y) noexcept(noexcept(x.swap(y))); @@ -6989,7 +6989,7 @@ \indexlibrary{\idxcode{set}!constructor}% \begin{itemdecl} -template +template set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); \end{itemdecl} @@ -7017,7 +7017,7 @@ \indexlibrarymember{swap}{set}% \begin{itemdecl} -template +template void swap(set& x, set& y) noexcept(noexcept(x.swap(y))); @@ -7074,7 +7074,7 @@ \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class multiset { public: @@ -7099,7 +7099,7 @@ // \ref{multiset.cons}, construct/copy/destroy multiset() : multiset(Compare()) { } explicit multiset(const Compare& comp, const Allocator& = Allocator()); - template + template multiset(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); multiset(const multiset& x); @@ -7109,7 +7109,7 @@ multiset(multiset&&, const Allocator&); multiset(initializer_list, const Compare& = Compare(), const Allocator& = Allocator()); - template + template multiset(InputIterator first, InputIterator last, const Allocator& a) : multiset(first, last, Compare(), a) { } multiset(initializer_list il, const Allocator& a) @@ -7144,13 +7144,13 @@ size_type max_size() const noexcept; // modifiers: - template iterator emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template iterator emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& x); iterator insert(value_type&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x); - template + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); @@ -7184,51 +7184,51 @@ // set operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; - template iterator find(const K& x); - template const_iterator find(const K& x) const; + template iterator find(const K& x); + template const_iterator find(const K& x) const; size_type count(const key_type& x) const; - template size_type count(const K& x) const; + template size_type count(const K& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; - template iterator lower_bound(const K& x); - template const_iterator lower_bound(const K& x) const; + template iterator lower_bound(const K& x); + template const_iterator lower_bound(const K& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; - template iterator upper_bound(const K& x); - template const_iterator upper_bound(const K& x) const; + template iterator upper_bound(const K& x); + template const_iterator upper_bound(const K& x) const; pair equal_range(const key_type& x); pair equal_range(const key_type& x) const; - template + template pair equal_range(const K& x); - template + template pair equal_range(const K& x) const; }; - template + template bool operator==(const multiset& x, const multiset& y); - template + template bool operator< (const multiset& x, const multiset& y); - template + template bool operator!=(const multiset& x, const multiset& y); - template + template bool operator> (const multiset& x, const multiset& y); - template + template bool operator>=(const multiset& x, const multiset& y); - template + template bool operator<=(const multiset& x, const multiset& y); // \ref{multiset.special}, specialized algorithms - template + template void swap(multiset& x, multiset& y) noexcept(noexcept(x.swap(y))); @@ -7256,7 +7256,7 @@ \indexlibrary{\idxcode{multiset}!constructor}% \begin{itemdecl} -template +template multiset(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); \end{itemdecl} @@ -7284,7 +7284,7 @@ \indexlibrarymember{swap}{multiset}% \begin{itemdecl} -template +template void swap(multiset& x, multiset& y) noexcept(noexcept(x.swap(y))); @@ -7316,53 +7316,53 @@ namespace std { // \ref{unord.map}, class template \tcode{unordered_map} - template , - class Pred = equal_to, - class Alloc = allocator>> + template, + class Pred = equal_to, + class Alloc = allocator>> class unordered_map; // \ref{unord.multimap}, class template \tcode{unordered_multimap} - template , - class Pred = equal_to, - class Alloc = allocator>> + template, + class Pred = equal_to, + class Alloc = allocator>> class unordered_multimap; - template + template void swap(unordered_map& x, unordered_map& y) noexcept(noexcept(x.swap(y))); - template + template void swap(unordered_multimap& x, unordered_multimap& y) noexcept(noexcept(x.swap(y))); - template + template bool operator==(const unordered_map& a, const unordered_map& b); - template + template bool operator!=(const unordered_map& a, const unordered_map& b); - template + template bool operator==(const unordered_multimap& a, const unordered_multimap& b); - template + template bool operator!=(const unordered_multimap& a, const unordered_multimap& b); namespace pmr { - template , class Pred = equal_to> using unordered_map = std::unordered_map>>; - template , class Pred = equal_to> @@ -7384,50 +7384,50 @@ namespace std { // \ref{unord.set}, class template \tcode{unordered_set} - template , - class Pred = equal_to, - class Alloc = allocator> + template, + class Pred = equal_to, + class Alloc = allocator> class unordered_set; // \ref{unord.multiset}, class template \tcode{unordered_multiset} - template , - class Pred = equal_to, - class Alloc = allocator> + template, + class Pred = equal_to, + class Alloc = allocator> class unordered_multiset; - template + template void swap(unordered_set& x, unordered_set& y) noexcept(noexcept(x.swap(y))); - template + template void swap(unordered_multiset& x, unordered_multiset& y) noexcept(noexcept(x.swap(y))); - template + template bool operator==(const unordered_set& a, const unordered_set& b); - template + template bool operator!=(const unordered_set& a, const unordered_set& b); - template + template bool operator==(const unordered_multiset& a, const unordered_multiset& b); - template + template bool operator!=(const unordered_multiset& a, const unordered_multiset& b); namespace pmr { - template , class Pred = equal_to> using unordered_set = std::unordered_set>; - template , class Pred = equal_to> using unordered_multiset = std::unordered_multiset, class Pred = equal_to, @@ -7496,7 +7496,7 @@ const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); - template + template unordered_map(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -7516,10 +7516,10 @@ : unordered_map(n, hasher(), key_equal(), a) { } unordered_map(size_type n, const hasher& hf, const allocator_type& a) : unordered_map(n, hf, key_equal(), a) { } - template + template unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a) : unordered_map(f, l, n, hasher(), key_equal(), a) { } - template + template unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a) : unordered_map(f, l, n, hf, key_equal(), a) { } @@ -7551,15 +7551,15 @@ size_type max_size() const noexcept; // \ref{unord.map.modifiers}, modifiers - template pair emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template pair emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& obj); pair insert(value_type&& obj); - template pair insert(P&& obj); + template pair insert(P&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); - template iterator insert(const_iterator hint, P&& obj); - template void insert(InputIterator first, InputIterator last); + template iterator insert(const_iterator hint, P&& obj); + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); node_type extract(const_iterator position); @@ -7567,21 +7567,21 @@ insert_return_type insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh); - template + template pair try_emplace(const key_type& k, Args&&... args); - template + template pair try_emplace(key_type&& k, Args&&... args); - template + template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); - template + template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); - template + template pair insert_or_assign(const key_type& k, M&& obj); - template + template pair insert_or_assign(key_type&& k, M&& obj); - template + template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); - template + template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); iterator erase(iterator position); @@ -7640,15 +7640,15 @@ void reserve(size_type n); }; - template + template bool operator==(const unordered_map& a, const unordered_map& b); - template + template bool operator!=(const unordered_map& a, const unordered_map& b); // \ref{unord.map.swap}, swap - template + template void swap(unordered_map& x, unordered_map& y) noexcept(noexcept(x.swap(y))); @@ -7681,7 +7681,7 @@ \indexlibrary{\idxcode{unordered_map}!constructor}% \begin{itemdecl} -template +template unordered_map(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -7753,7 +7753,7 @@ \indexlibrarymember{unordered_map}{insert}% \begin{itemdecl} -template +template pair insert(P&& obj); \end{itemdecl} @@ -7768,7 +7768,7 @@ \indexlibrarymember{unordered_map}{insert}% \begin{itemdecl} -template +template iterator insert(const_iterator hint, P&& obj); \end{itemdecl} @@ -7784,9 +7784,9 @@ \indexlibrarymember{try_emplace}{unordered_map}% \begin{itemdecl} -template +template pair try_emplace(const key_type& k, Args&&... args); -template +template iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); \end{itemdecl} @@ -7822,9 +7822,9 @@ \indexlibrarymember{try_emplace}{unordered_map}% \begin{itemdecl} -template +template pair try_emplace(key_type&& k, Args&&... args); -template +template iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); \end{itemdecl} @@ -7860,9 +7860,9 @@ \indexlibrarymember{insert_or_assign}{unordered_map}% \begin{itemdecl} -template +template pair insert_or_assign(const key_type& k, M&& obj); -template +template iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); \end{itemdecl} @@ -7897,9 +7897,9 @@ \indexlibrarymember{insert_or_assign}{unordered_map}% \begin{itemdecl} -template +template pair insert_or_assign(key_type&& k, M&& obj); -template +template iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); \end{itemdecl} @@ -7936,7 +7936,7 @@ \indexlibrarymember{unordered_map}{swap}% \begin{itemdecl} -template +template void swap(unordered_map& x, unordered_map& y) noexcept(noexcept(x.swap(y))); @@ -7978,7 +7978,7 @@ \indexlibrary{\idxcode{unordered_multimap}}% \begin{codeblock} namespace std { - template , class Pred = equal_to, @@ -8011,7 +8011,7 @@ const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); - template + template unordered_multimap(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -8031,10 +8031,10 @@ : unordered_multimap(n, hasher(), key_equal(), a) { } unordered_multimap(size_type n, const hasher& hf, const allocator_type& a) : unordered_multimap(n, hf, key_equal(), a) { } - template + template unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a) : unordered_multimap(f, l, n, hasher(), key_equal(), a) { } - template + template unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a) : unordered_multimap(f, l, n, hf, key_equal(), a) { } @@ -8066,15 +8066,15 @@ size_type max_size() const noexcept; // \ref{unord.multimap.modifiers}, modifiers - template iterator emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template iterator emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj); iterator insert(value_type&& obj); - template iterator insert(P&& obj); + template iterator insert(P&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); - template iterator insert(const_iterator hint, P&& obj); - template void insert(InputIterator first, InputIterator last); + template iterator insert(const_iterator hint, P&& obj); + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); node_type extract(const_iterator position); @@ -8132,15 +8132,15 @@ void reserve(size_type n); }; - template + template bool operator==(const unordered_multimap& a, const unordered_multimap& b); - template + template bool operator!=(const unordered_multimap& a, const unordered_multimap& b); // \ref{unord.multimap.swap}, swap - template + template void swap(unordered_multimap& x, unordered_multimap& y) noexcept(noexcept(x.swap(y))); @@ -8174,7 +8174,7 @@ \indexlibrary{\idxcode{unordered_multimap}!constructor}% \begin{itemdecl} -template +template unordered_multimap(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -8207,7 +8207,7 @@ \indexlibrarymember{unordered_multimap}{insert}% \begin{itemdecl} -template +template iterator insert(P&& obj); \end{itemdecl} @@ -8222,7 +8222,7 @@ \indexlibrarymember{unordered_multimap}{insert}% \begin{itemdecl} -template +template iterator insert(const_iterator hint, P&& obj); \end{itemdecl} @@ -8240,7 +8240,7 @@ \indexlibrarymember{unordered_multimap}{swap}% \begin{itemdecl} -template +template void swap(unordered_multimap& x, unordered_multimap& y) noexcept(noexcept(x.swap(y))); @@ -8277,7 +8277,7 @@ \indexlibrary{\idxcode{unordered_set}}% \begin{codeblock} namespace std { - template , class Pred = equal_to, class Allocator = allocator> @@ -8309,7 +8309,7 @@ const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); - template + template unordered_set(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -8329,10 +8329,10 @@ : unordered_set(n, hasher(), key_equal(), a) { } unordered_set(size_type n, const hasher& hf, const allocator_type& a) : unordered_set(n, hf, key_equal(), a) { } - template + template unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a) : unordered_set(f, l, n, hasher(), key_equal(), a) { } - template + template unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a) : unordered_set(f, l, n, hf, key_equal(), a) { } @@ -8364,13 +8364,13 @@ size_type max_size() const noexcept; // modifiers: - template pair emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template pair emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); pair insert(const value_type& obj); pair insert(value_type&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); - template void insert(InputIterator first, InputIterator last); + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); node_type extract(const_iterator position); @@ -8428,15 +8428,15 @@ void reserve(size_type n); }; - template + template bool operator==(const unordered_set& a, const unordered_set& b); - template + template bool operator!=(const unordered_set& a, const unordered_set& b); // \ref{unord.set.swap}, swap - template + template void swap(unordered_set& x, unordered_set& y) noexcept(noexcept(x.swap(y))); @@ -8469,7 +8469,7 @@ \indexlibrary{\idxcode{unordered_set}!constructor}% \begin{itemdecl} -template +template unordered_set(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -8502,7 +8502,7 @@ \indexlibrarymember{unordered_set}{swap}% \begin{itemdecl} -template +template void swap(unordered_set& x, unordered_set& y) noexcept(noexcept(x.swap(y))); @@ -8545,7 +8545,7 @@ \indexlibrary{\idxcode{unordered_multiset}}% \begin{codeblock} namespace std { - template , class Pred = equal_to, class Allocator = allocator> @@ -8576,7 +8576,7 @@ const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); - template + template unordered_multiset(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -8596,11 +8596,13 @@ : unordered_multiset(n, hasher(), key_equal(), a) { } unordered_multiset(size_type n, const hasher& hf, const allocator_type& a) : unordered_multiset(n, hf, key_equal(), a) { } - template + template unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a) : unordered_multiset(f, l, n, hasher(), key_equal(), a) { } - template + template unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf, + template + unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a) : unordered_multiset(f, l, n, hf, key_equal(), a) { } unordered_multiset(initializer_list il, size_type n, const allocator_type& a) @@ -8631,13 +8633,13 @@ size_type max_size() const noexcept; // modifiers: - template iterator emplace(Args&&... args); - template iterator emplace_hint(const_iterator position, Args&&... args); + template iterator emplace(Args&&... args); + template iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj); iterator insert(value_type&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); - template void insert(InputIterator first, InputIterator last); + template void insert(InputIterator first, InputIterator last); void insert(initializer_list); node_type extract(const_iterator position); @@ -8695,15 +8697,15 @@ void reserve(size_type n); }; - template + template bool operator==(const unordered_multiset& a, const unordered_multiset& b); - template + template bool operator!=(const unordered_multiset& a, const unordered_multiset& b); // \ref{unord.multiset.swap}, swap - template + template void swap(unordered_multiset& x, unordered_multiset& y) noexcept(noexcept(x.swap(y))); @@ -8736,7 +8738,7 @@ \indexlibrary{\idxcode{unordered_multiset}!constructor}% \begin{itemdecl} -template +template unordered_multiset(InputIterator f, InputIterator l, size_type n = @\seebelow@, const hasher& hf = hasher(), @@ -8768,7 +8770,7 @@ \indexlibrarymember{unordered_multiset}{swap}% \begin{itemdecl} -template +template void swap(unordered_multiset& x, unordered_multiset& y) noexcept(noexcept(x.swap(y))); @@ -8808,27 +8810,27 @@ #include namespace std { - template > class queue; - template , + template> class queue; + template, class Compare = default_order_t> class priority_queue; - template + template bool operator==(const queue& x, const queue& y); - template + template bool operator< (const queue& x, const queue& y); - template + template bool operator!=(const queue& x, const queue& y); - template + template bool operator> (const queue& x, const queue& y); - template + template bool operator>=(const queue& x, const queue& y); - template + template bool operator<=(const queue& x, const queue& y); - template + template void swap(queue& x, queue& y) noexcept(noexcept(x.swap(y))); - template + template void swap(priority_queue& x, priority_queue& y) noexcept(noexcept(x.swap(y))); } @@ -8842,20 +8844,20 @@ #include namespace std { - template > class stack; - template + template> class stack; + template bool operator==(const stack& x, const stack& y); - template + template bool operator< (const stack& x, const stack& y); - template + template bool operator!=(const stack& x, const stack& y); - template + template bool operator> (const stack& x, const stack& y); - template + template bool operator>=(const stack& x, const stack& y); - template + template bool operator<=(const stack& x, const stack& y); - template + template void swap(stack& x, stack& y) noexcept(noexcept(x.swap(y))); } \end{codeblock} @@ -8882,7 +8884,7 @@ \begin{codeblock} namespace std { - template > + template> class queue { public: using value_type = typename Container::value_type; @@ -8897,11 +8899,11 @@ public: explicit queue(const Container&); explicit queue(Container&& = Container()); - template explicit queue(const Alloc&); - template queue(const Container&, const Alloc&); - template queue(Container&&, const Alloc&); - template queue(const queue&, const Alloc&); - template queue(queue&&, const Alloc&); + template explicit queue(const Alloc&); + template queue(const Container&, const Alloc&); + template queue(Container&&, const Alloc&); + template queue(const queue&, const Alloc&); + template queue(queue&&, const Alloc&); bool empty() const { return c.empty(); } size_type size() const { return c.size(); } @@ -8911,30 +8913,30 @@ const_reference back() const { return c.back(); } void push(const value_type& x) { c.push_back(x); } void push(value_type&& x) { c.push_back(std::move(x)); } - template + template reference emplace(Args&&... args) { return c.emplace_back(std::forward(args)...); } void pop() { c.pop_front(); } void swap(queue& q) noexcept(is_nothrow_swappable_v) { using std::swap; swap(c, q.c); } }; - template + template bool operator==(const queue& x, const queue& y); - template + template bool operator< (const queue& x, const queue& y); - template + template bool operator!=(const queue& x, const queue& y); - template + template bool operator> (const queue& x, const queue& y); - template + template bool operator>=(const queue& x, const queue& y); - template + template bool operator<=(const queue& x, const queue& y); - template + template void swap(queue& x, queue& y) noexcept(noexcept(x.swap(y))); - template + template struct uses_allocator, Alloc> : uses_allocator::type { }; } @@ -8967,7 +8969,7 @@ the constructors in this subclause shall not participate in overload resolution. \begin{itemdecl} -template explicit queue(const Alloc& a); +template explicit queue(const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -8976,7 +8978,7 @@ \end{itemdescr} \begin{itemdecl} -template queue(const container_type& cont, const Alloc& a); +template queue(const container_type& cont, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -8986,7 +8988,7 @@ \end{itemdescr} \begin{itemdecl} -template queue(container_type&& cont, const Alloc& a); +template queue(container_type&& cont, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -8996,7 +8998,7 @@ \end{itemdescr} \begin{itemdecl} -template queue(const queue& q, const Alloc& a); +template queue(const queue& q, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9006,7 +9008,7 @@ \end{itemdescr} \begin{itemdecl} -template queue(queue&& q, const Alloc& a); +template queue(queue&& q, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9019,7 +9021,7 @@ \indexlibrary{\idxcode{operator==}!\idxcode{queue}}% \begin{itemdecl} -template +template bool operator==(const queue& x, const queue& y); \end{itemdecl} @@ -9031,7 +9033,7 @@ \indexlibrary{\idxcode{operator"!=}!\idxcode{queue}}% \begin{itemdecl} -template +template bool operator!=(const queue& x, const queue& y); \end{itemdecl} @@ -9043,7 +9045,7 @@ \indexlibrary{\idxcode{operator<}!\idxcode{queue}}% \begin{itemdecl} -template +template bool operator< (const queue& x, const queue& y); \end{itemdecl} @@ -9055,7 +9057,7 @@ \indexlibrary{\idxcode{operator<=}!\idxcode{queue}}% \begin{itemdecl} -template +template bool operator<=(const queue& x, const queue& y); \end{itemdecl} @@ -9067,7 +9069,7 @@ \indexlibrary{\idxcode{operator>}!\idxcode{queue}}% \begin{itemdecl} -template +template bool operator> (const queue& x, const queue& y); \end{itemdecl} @@ -9079,7 +9081,7 @@ \indexlibrary{\idxcode{operator>=}!\idxcode{queue}}% \begin{itemdecl} -template +template bool operator>=(const queue& x, const queue& y); \end{itemdecl} @@ -9094,7 +9096,7 @@ \indexlibrarymember{swap}{queue}% \begin{itemdecl} -template +template void swap(queue& x, queue& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -9132,7 +9134,7 @@ \begin{codeblock} namespace std { - template , + template, class Compare = default_order_t> class priority_queue { public: @@ -9150,25 +9152,25 @@ public: priority_queue(const Compare& x, const Container&); explicit priority_queue(const Compare& x = Compare(), Container&& = Container()); - template + template priority_queue(InputIterator first, InputIterator last, const Compare& x, const Container&); - template + template priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare(), Container&& = Container()); - template explicit priority_queue(const Alloc&); - template priority_queue(const Compare&, const Alloc&); - template priority_queue(const Compare&, const Container&, const Alloc&); - template priority_queue(const Compare&, Container&&, const Alloc&); - template priority_queue(const priority_queue&, const Alloc&); - template priority_queue(priority_queue&&, const Alloc&); + template explicit priority_queue(const Alloc&); + template priority_queue(const Compare&, const Alloc&); + template priority_queue(const Compare&, const Container&, const Alloc&); + template priority_queue(const Compare&, Container&&, const Alloc&); + template priority_queue(const priority_queue&, const Alloc&); + template priority_queue(priority_queue&&, const Alloc&); bool empty() const { return c.empty(); } size_type size() const { return c.size(); } const_reference top() const { return c.front(); } void push(const value_type& x); void push(value_type&& x); - template void emplace(Args&&... args); + template void emplace(Args&&... args); void pop(); void swap(priority_queue& q) noexcept(is_nothrow_swappable_v && is_nothrow_swappable_v) @@ -9177,11 +9179,11 @@ // no equality is provided - template + template void swap(priority_queue& x, priority_queue& y) noexcept(noexcept(x.swap(y))); - template + template struct uses_allocator, Alloc> : uses_allocator::type { }; } @@ -9213,11 +9215,11 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template +template priority_queue(InputIterator first, InputIterator last, const Compare& x, const Container& y); -template +template priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare(), Container&& y = Container()); @@ -9249,7 +9251,7 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template explicit priority_queue(const Alloc& a); +template explicit priority_queue(const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9259,7 +9261,7 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template priority_queue(const Compare& compare, const Alloc& a); +template priority_queue(const Compare& compare, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9269,7 +9271,7 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template +template priority_queue(const Compare& compare, const Container& cont, const Alloc& a); \end{itemdecl} @@ -9282,7 +9284,7 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template +template priority_queue(const Compare& compare, Container&& cont, const Alloc& a); \end{itemdecl} @@ -9295,7 +9297,7 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template priority_queue(const priority_queue& q, const Alloc& a); +template priority_queue(const priority_queue& q, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9306,7 +9308,7 @@ \indexlibrary{\idxcode{priority_queue}!constructor}% \begin{itemdecl} -template priority_queue(priority_queue&& q, const Alloc& a); +template priority_queue(priority_queue&& q, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9349,7 +9351,7 @@ \indexlibrarymember{emplace}{priority_queue}% \begin{itemdecl} -template void emplace(Args&&... args) +template void emplace(Args&&... args) \end{itemdecl} \begin{itemdescr} @@ -9382,7 +9384,7 @@ \indexlibrarymember{swap}{priority_queue}% \begin{itemdecl} -template +template void swap(priority_queue& x, priority_queue& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} @@ -9420,7 +9422,7 @@ \begin{codeblock} namespace std { - template > + template> class stack { public: using value_type = typename Container::value_type; @@ -9435,11 +9437,11 @@ public: explicit stack(const Container&); explicit stack(Container&& = Container()); - template explicit stack(const Alloc&); - template stack(const Container&, const Alloc&); - template stack(Container&&, const Alloc&); - template stack(const stack&, const Alloc&); - template stack(stack&&, const Alloc&); + template explicit stack(const Alloc&); + template stack(const Container&, const Alloc&); + template stack(Container&&, const Alloc&); + template stack(const stack&, const Alloc&); + template stack(stack&&, const Alloc&); bool empty() const { return c.empty(); } size_type size() const { return c.size(); } @@ -9447,29 +9449,29 @@ const_reference top() const { return c.back(); } void push(const value_type& x) { c.push_back(x); } void push(value_type&& x) { c.push_back(std::move(x)); } - template + template reference emplace(Args&&... args) { return c.emplace_back(std::forward(args)...); } void pop() { c.pop_back(); } void swap(stack& s) noexcept(is_nothrow_swappable_v) { using std::swap; swap(c, s.c); } }; - template + template bool operator==(const stack& x, const stack& y); - template + template bool operator< (const stack& x, const stack& y); - template + template bool operator!=(const stack& x, const stack& y); - template + template bool operator> (const stack& x, const stack& y); - template + template bool operator>=(const stack& x, const stack& y); - template + template bool operator<=(const stack& x, const stack& y); - template + template void swap(stack& x, stack& y) noexcept(noexcept(x.swap(y))); - template + template struct uses_allocator, Alloc> : uses_allocator::type { }; } @@ -9505,7 +9507,7 @@ \indexlibrary{\idxcode{stack}!constructor}% \begin{itemdecl} -template explicit stack(const Alloc& a); +template explicit stack(const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9515,7 +9517,7 @@ \indexlibrary{\idxcode{stack}!constructor}% \begin{itemdecl} -template stack(const container_type& cont, const Alloc& a); +template stack(const container_type& cont, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9526,7 +9528,7 @@ \indexlibrary{\idxcode{stack}!constructor}% \begin{itemdecl} -template stack(container_type&& cont, const Alloc& a); +template stack(container_type&& cont, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9537,7 +9539,7 @@ \indexlibrary{\idxcode{stack}!constructor}% \begin{itemdecl} -template stack(const stack& s, const Alloc& a); +template stack(const stack& s, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9548,7 +9550,7 @@ \indexlibrary{\idxcode{stack}!constructor}% \begin{itemdecl} -template stack(stack&& s, const Alloc& a); +template stack(stack&& s, const Alloc& a); \end{itemdecl} \begin{itemdescr} @@ -9561,7 +9563,7 @@ \indexlibrary{\idxcode{operator==}!\idxcode{stack}}% \begin{itemdecl} -template +template bool operator==(const stack& x, const stack& y); \end{itemdecl} @@ -9573,7 +9575,7 @@ \indexlibrary{\idxcode{operator"!=}!\idxcode{stack}}% \begin{itemdecl} -template +template bool operator!=(const stack& x, const stack& y); \end{itemdecl} @@ -9585,7 +9587,7 @@ \indexlibrary{\idxcode{operator<}!\idxcode{stack}}% \begin{itemdecl} -template +template bool operator< (const stack& x, const stack& y); \end{itemdecl} @@ -9597,7 +9599,7 @@ \indexlibrary{\idxcode{operator<=}!\idxcode{stack}}% \begin{itemdecl} -template +template bool operator<=(const stack& x, const stack& y); \end{itemdecl} @@ -9609,7 +9611,7 @@ \indexlibrary{\idxcode{operator>}!\idxcode{stack}}% \begin{itemdecl} -template +template bool operator> (const stack& x, const stack& y); \end{itemdecl} @@ -9621,7 +9623,7 @@ \indexlibrary{\idxcode{operator>=}!\idxcode{stack}}% \begin{itemdecl} -template +template bool operator>=(const stack& x, const stack& y); \end{itemdecl} @@ -9635,7 +9637,7 @@ \indexlibrarymember{swap}{stack}% \begin{itemdecl} -template +template void swap(stack& x, stack& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} diff --git a/source/declarations.tex b/source/declarations.tex index c2a442c626..f5e415c2a4 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -1697,7 +1697,7 @@ program being ill-formed~(\ref{temp.deduct}). \end{note} \begin{example} \begin{codeblock} -template auto f(T t) { return t; } // return type deduced at instantiation time +template auto f(T t) { return t; } // return type deduced at instantiation time typedef decltype(f(1)) fint_t; // instantiates \tcode{f} to deduce return type template auto f(T* t) { return *t; } void g() { int (*p)(int*) = &f; } // instantiates both \tcode{f}s to determine return types, @@ -1717,18 +1717,18 @@ int f(); // error, cannot be overloaded with \tcode{auto f()} decltype(auto) f(); // error, \tcode{auto} and \tcode{decltype(auto)} don't match -template auto g(T t) { return t; } // \#1 +template auto g(T t) { return t; } // \#1 template auto g(int); // OK, return type is \tcode{int} template char g(char); // error, no matching template template<> auto g(double); // OK, forward declaration with unknown return type -template T g(T t) { return t; } // OK, not functionally equivalent to \#1 +template T g(T t) { return t; } // OK, not functionally equivalent to \#1 template char g(char); // OK, now there is a matching template template auto g(float); // still matches \#1 void h() { return g(42); } // error, ambiguous -template struct A { +template struct A { friend T frf(T); }; auto frf(int i) { return i; } // not a friend of \tcode{A} @@ -1746,7 +1746,7 @@ type. \begin{example} \begin{codeblock} -template auto f(T t) { return t; } +template auto f(T t) { return t; } extern template auto f(int); // does not instantiate \tcode{f} int (*p)(int) = f; // instantiates \tcode{f} to determine its return type, but an explicit // instantiation definition is still required somewhere in the program @@ -1837,7 +1837,7 @@ The type of \tcode{i} is the deduced type of the parameter \tcode{u} in the call \tcode{f(expr)} of the following invented function template: \begin{codeblock} -template void f(const U& u); +template void f(const U& u); \end{codeblock} \end{example} @@ -2556,7 +2556,7 @@ \begin{codeblock} // Assume \tcode{f} and \tcode{g} have not yet been declared. void h(int); -template void f2(T); +template void f2(T); namespace A { class X { friend void f(X); // \tcode{A::f(X)} is a friend @@ -2713,7 +2713,7 @@ being defined. \begin{example} \begin{codeblock} -template +template struct X : bases... { using bases::g...; }; @@ -2760,8 +2760,8 @@ \begin{codeblock} struct A { - template void f(T); - template struct X { }; + template void f(T); + template struct X { }; }; struct B : A { using A::f; // ill-formed diff --git a/source/declarators.tex b/source/declarators.tex index a52491d35d..07177b0173 100644 --- a/source/declarators.tex +++ b/source/declarators.tex @@ -304,8 +304,8 @@ \begin{example} \begin{codeblock} -template struct X {}; -template struct Y {}; +template struct X {}; +template struct Y {}; X a; // type-id X b; // expression (ill-formed) Y c; // type-id (ill-formed) @@ -1629,13 +1629,13 @@ A \grammarterm{trailing-return-type} is most useful for a type that would be more complicated to specify before the \grammarterm{declarator-id}: \begin{codeblock} -template auto add(T t, U u) -> decltype(t + u); +template auto add(T t, U u) -> decltype(t + u); \end{codeblock} rather than \begin{codeblock} -template decltype((*(T*)0) + (*(U*)0)) add(T t, U u); +template decltype((*(T*)0) + (*(U*)0)) add(T t, U u); \end{codeblock} \end{note} diff --git a/source/diagnostics.tex b/source/diagnostics.tex index 2e32f748a1..f50c35bfd8 100644 --- a/source/diagnostics.tex +++ b/source/diagnostics.tex @@ -794,10 +794,10 @@ class error_condition; class system_error; - template + template struct is_error_code_enum : public false_type {}; - template + template struct is_error_condition_enum : public false_type {}; enum class errc { @@ -881,12 +881,12 @@ wrong_protocol_type, // \tcode{EPROTOTYPE} }; - template <> struct is_error_condition_enum : true_type {}; + template<> struct is_error_condition_enum : true_type {}; // \ref{syserr.errcode.nonmembers}, non-member functions error_code make_error_code(errc e) noexcept; - template + template basic_ostream& operator<<(basic_ostream& os, const error_code& ec); @@ -906,14 +906,14 @@ bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; // \ref{syserr.hash}, hash support - template struct hash; - template <> struct hash; - template <> struct hash; + template struct hash; + template<> struct hash; + template<> struct hash; // \ref{syserr}, system error support - template constexpr bool is_error_code_enum_v + template constexpr bool is_error_code_enum_v = is_error_code_enum::value; - template constexpr bool is_error_condition_enum_v + template constexpr bool is_error_condition_enum_v = is_error_condition_enum::value; } \end{codeblock} @@ -1181,12 +1181,12 @@ // \ref{syserr.errcode.constructors}, constructors error_code() noexcept; error_code(int val, const error_category& cat) noexcept; - template + template error_code(ErrorCodeEnum e) noexcept; // \ref{syserr.errcode.modifiers}, modifiers void assign(int val, const error_category& cat) noexcept; - template + template error_code& operator=(ErrorCodeEnum e) noexcept; void clear() noexcept; @@ -1205,7 +1205,7 @@ // \ref{syserr.errcode.nonmembers}, non-member functions error_code make_error_code(errc e) noexcept; - template + template basic_ostream& operator<<(basic_ostream& os, const error_code& ec); } @@ -1241,7 +1241,7 @@ \indexlibrary{\idxcode{error_code}!constructor}% \begin{itemdecl} -template +template error_code(ErrorCodeEnum e) noexcept; \end{itemdecl} @@ -1271,7 +1271,7 @@ \indexlibrarymember{operator=}{error_code}% \begin{itemdecl} -template +template error_code& operator=(ErrorCodeEnum e) noexcept; \end{itemdecl} @@ -1364,7 +1364,7 @@ \indexlibrarymember{operator<<}{error_code}% \begin{itemdecl} -template +template basic_ostream& operator<<(basic_ostream& os, const error_code& ec); \end{itemdecl} @@ -1393,12 +1393,12 @@ // \ref{syserr.errcondition.constructors}, constructors error_condition() noexcept; error_condition(int val, const error_category& cat) noexcept; - template + template error_condition(ErrorConditionEnum e) noexcept; // \ref{syserr.errcondition.modifiers}, modifiers void assign(int val, const error_category& cat) noexcept; - template + template error_condition& operator=(ErrorConditionEnum e) noexcept; void clear() noexcept; @@ -1445,7 +1445,7 @@ \indexlibrary{\idxcode{error_condition}!constructor}% \begin{itemdecl} -template +template error_condition(ErrorConditionEnum e) noexcept; \end{itemdecl} @@ -1476,7 +1476,7 @@ \indexlibrarymember{operator=}{error_condition}% \begin{itemdecl} -template +template error_condition& operator=(ErrorConditionEnum e) noexcept; \end{itemdecl} @@ -1644,8 +1644,8 @@ \indexlibrary{\idxcode{hash}!\idxcode{error_code}}% \begin{itemdecl} -template <> struct hash; -template <> struct hash; +template<> struct hash; +template<> struct hash; \end{itemdecl} \begin{itemdescr} diff --git a/source/future.tex b/source/future.tex index 2a1274d021..793b438ef4 100644 --- a/source/future.tex +++ b/source/future.tex @@ -1324,7 +1324,7 @@ using second_argument_type = weak_ptr; }; - template class reference_wrapper { + template class reference_wrapper { public : using result_type = @\seebelow@; // not always defined using argument_type = @\seebelow@; // not always defined @@ -1332,113 +1332,113 @@ using second_argument_type = @\seebelow@; // not always defined }; - template struct plus { + template struct plus { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct minus { + template struct minus { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct multiplies { + template struct multiplies { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct divides { + template struct divides { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct modulus { + template struct modulus { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct negate { + template struct negate { using argument_type = T; using result_type = T; }; - template struct equal_to { + template struct equal_to { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct not_equal_to { + template struct not_equal_to { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct greater { + template struct greater { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct less { + template struct less { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct greater_equal { + template struct greater_equal { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct less_equal { + template struct less_equal { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct logical_and { + template struct logical_and { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct logical_or { + template struct logical_or { using first_argument_type = T; using second_argument_type = T; using result_type = bool; }; - template struct logical_not { + template struct logical_not { using argument_type = T; using result_type = bool; }; - template struct bit_and { + template struct bit_and { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct bit_or { + template struct bit_or { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct bit_xor { + template struct bit_xor { using first_argument_type = T; using second_argument_type = T; using result_type = T; }; - template struct bit_not { + template struct bit_not { using argument_type = T; using result_type = T; }; @@ -1562,7 +1562,7 @@ \indexlibrarymember{second_argument_type}{multimap::value_compare}% \begin{codeblock} namespace std { - template + template class map::value_compare { public: using result_type = bool; @@ -1570,7 +1570,7 @@ using second_argument_type = value_type; }; - template + template class multimap::value_compare { public: using result_type = bool; @@ -1594,11 +1594,11 @@ \indexlibrary{\idxcode{not2}}% \begin{codeblock} namespace std { - template class unary_negate; - template + template class unary_negate; + template constexpr unary_negate not1(const Predicate&); - template class binary_negate; - template + template class binary_negate; + template constexpr binary_negate not2(const Predicate&); } \end{codeblock} @@ -1612,7 +1612,7 @@ \indexlibrarymember{argument_type}{unary_negate}% \indexlibrarymember{result_type}{unary_negate}% \begin{codeblock} -template +template class unary_negate { public: constexpr explicit unary_negate(const Predicate& pred); @@ -1633,7 +1633,7 @@ \indexlibrary{\idxcode{not1}}% \begin{itemdecl} -template +template constexpr unary_negate not1(const Predicate& pred); \end{itemdecl} @@ -1646,7 +1646,7 @@ \indexlibrarymember{second_argument_type}{binary_negate}% \indexlibrarymember{result_type}{binary_negate}% \begin{codeblock} -template +template class binary_negate { public: constexpr explicit binary_negate(const Predicate& pred); @@ -1671,7 +1671,7 @@ \indexlibrary{\idxcode{not2}}% \begin{itemdecl} -template +template constexpr binary_negate not2(const Predicate& pred); \end{itemdecl} @@ -1689,17 +1689,17 @@ \begin{codeblock} namespace std { // specialize for \tcode{void}: - template <> class allocator { + template<> class allocator { public: using value_type = void; using pointer = void*; using const_pointer = const void*; // reference-to-\tcode{void} members are impossible. - template struct rebind { using other = allocator; }; + template struct rebind { using other = allocator; }; }; - template class allocator { + template class allocator { public: using size_type = size_t; using difference_type = ptrdiff_t; @@ -1707,7 +1707,7 @@ using const_pointer = const T*; using reference = T&; using const_reference = const T&; - template struct rebind { using other = allocator; }; + template struct rebind { using other = allocator; }; T* address(T& x) const noexcept; const T* address(const T& x) const noexcept; @@ -1716,7 +1716,7 @@ template void construct(U* p, Args&&... args); - template + template void destroy(U* p); size_t max_size() const noexcept; @@ -1760,7 +1760,7 @@ \indexlibrarymember{construct}{allocator}% \begin{itemdecl} -template +template void construct(U* p, Args&&... args); \end{itemdecl} @@ -1772,7 +1772,7 @@ \indexlibrarymember{destroy}{allocator}% \begin{itemdecl} -template +template void destroy(U* p); \end{itemdecl} @@ -1805,7 +1805,7 @@ \indexlibrary{\idxcode{raw_storage_iterator}}% \begin{codeblock} namespace std { - template + template class raw_storage_iterator { public: using iterator_category = output_iterator_tag; @@ -1939,16 +1939,16 @@ \begin{codeblock} namespace std { - template + template pair get_temporary_buffer(ptrdiff_t n) noexcept; - template + template void return_temporary_buffer(T* p); } \end{codeblock} \indexlibrary{\idxcode{get_temporary_buffer}}% \begin{itemdecl} -template +template pair get_temporary_buffer(ptrdiff_t n) noexcept; \end{itemdecl} @@ -1982,7 +1982,7 @@ \indexlibrary{\idxcode{return_temporary_buffer}}% \begin{itemdecl} -template void return_temporary_buffer(T* p); +template void return_temporary_buffer(T* p); \end{itemdecl} \begin{itemdescr} @@ -2012,9 +2012,9 @@ \indexlibrary{\idxcode{is_literal_type}}% \begin{codeblock} namespace std { - template struct is_literal_type; + template struct is_literal_type; - template constexpr bool is_literal_type_v = is_literal_type::value; + template constexpr bool is_literal_type_v = is_literal_type::value; } \end{codeblock} diff --git a/source/iostreams.tex b/source/iostreams.tex index 80e3925c30..14ea183d8c 100644 --- a/source/iostreams.tex +++ b/source/iostreams.tex @@ -166,42 +166,42 @@ template class allocator; - template > + template> class basic_ios; - template > + template> class basic_streambuf; - template > + template> class basic_istream; - template > + template> class basic_ostream; - template > + template> class basic_iostream; - template , + template, class Allocator = allocator> class basic_stringbuf; - template , + template, class Allocator = allocator> class basic_istringstream; - template , + template, class Allocator = allocator> class basic_ostringstream; - template , + template, class Allocator = allocator> class basic_stringstream; - template > + template> class basic_filebuf; - template > + template> class basic_ifstream; - template > + template> class basic_ofstream; - template > + template> class basic_fstream; - template > + template> class istreambuf_iterator; - template > + template> class ostreambuf_iterator; using ios = basic_ios; @@ -237,7 +237,7 @@ using wofstream = basic_ofstream; using wfstream = basic_fstream; - template class fpos; + template class fpos; using streampos = fpos::state_type>; using wstreampos = fpos::state_type>; } @@ -634,10 +634,10 @@ namespace std { using streamoff = @\impdef@; using streamsize = @\impdef@; - template class fpos; + template class fpos; class ios_base; - template > + template> class basic_ios; // \ref{std.ios.manip}, manipulators @@ -683,7 +683,7 @@ stream = 1 }; - template <> struct is_error_code_enum : public true_type { }; + template<> struct is_error_code_enum : public true_type { }; error_code make_error_code(io_errc e) noexcept; error_condition make_error_condition(io_errc e) noexcept; const error_category& iostream_category() noexcept; @@ -1612,7 +1612,7 @@ \indexlibrary{\idxcode{fpos}}% \begin{codeblock} namespace std { - template class fpos { + template class fpos { public: // \ref{fpos.members}, members stateT state() const; @@ -1757,7 +1757,7 @@ \indexlibrary{\idxcode{basic_ios}}% \begin{codeblock} namespace std { - template > + template> class basic_ios : public ios_base { public: using char_type = charT; @@ -2789,7 +2789,7 @@ \indexlibrary{\idxcode{basic_streambuf}}% \begin{codeblock} namespace std { - template > + template> class basic_streambuf; using streambuf = basic_streambuf; using wstreambuf = basic_streambuf; @@ -2908,7 +2908,7 @@ \indexlibrary{\idxcode{basic_streambuf}}% \begin{codeblock} namespace std { - template > + template> class basic_streambuf { public: using char_type = charT; @@ -4041,22 +4041,22 @@ \begin{codeblock} namespace std { - template > + template> class basic_istream; using istream = basic_istream; using wistream = basic_istream; - template > + template> class basic_iostream; using iostream = basic_iostream; using wiostream = basic_iostream; - template + template basic_istream& ws(basic_istream& is); - template + template basic_istream& operator>>(basic_istream&& is, T&& x); } \end{codeblock} @@ -4072,20 +4072,20 @@ \begin{codeblock} namespace std { - template > + template> class basic_ostream; using ostream = basic_ostream; using wostream = basic_ostream; - template + template basic_ostream& endl(basic_ostream& os); - template + template basic_ostream& ends(basic_ostream& os); - template + template basic_ostream& flush(basic_ostream& os); - template + template basic_ostream& operator<<(basic_ostream&& os, const T& x); } \end{codeblock} @@ -4108,19 +4108,19 @@ template @\textit{T4}@ setfill(charT c); @\textit{T5}@ setprecision(int n); @\textit{T6}@ setw(int n); - template @\textit{T7}@ get_money(moneyT& mon, bool intl = false); - template @\textit{T8}@ put_money(const moneyT& mon, bool intl = false); - template @\textit{T9}@ get_time(struct tm* tmb, const charT* fmt); - template @\textit{T10}@ put_time(const struct tm* tmb, const charT* fmt); + template @\textit{T7}@ get_money(moneyT& mon, bool intl = false); + template @\textit{T8}@ put_money(const moneyT& mon, bool intl = false); + template @\textit{T9}@ get_time(struct tm* tmb, const charT* fmt); + template @\textit{T10}@ put_time(const struct tm* tmb, const charT* fmt); - template + template @\textit{T11}@ quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\')); - template + template @\textit{T12}@ quoted(const basic_string& s, @\itcorr@ charT delim = charT('"'), charT escape = charT('\\')); - template + template @\textit{T13}@ quoted(basic_string& s, @\itcorr@ charT delim = charT('"'), charT escape = charT('\\')); } @@ -4139,7 +4139,7 @@ \indexlibrary{\idxcode{basic_istream}}% \begin{codeblock} namespace std { - template > + template> class basic_istream : virtual public basic_ios { public: // types (inherited from \tcode{basic_ios} (\ref{ios})): @@ -4370,7 +4370,7 @@ \indexlibrary{\idxcode{sentry}!\idxcode{basic_istream}}% \begin{codeblock} namespace std { - template > + template> class basic_istream::sentry { using traits_type = traits; bool ok_; // \expos @@ -5521,7 +5521,7 @@ \indexlibrary{\idxcode{ws}}% \begin{itemdecl} -template +template basic_istream& ws(basic_istream& is); \end{itemdecl} @@ -5550,7 +5550,7 @@ \indexlibrarymember{operator>>}{basic_istream}% \begin{itemdecl} -template +template basic_istream& operator>>(basic_istream&& is, T&& x); \end{itemdecl} @@ -5572,7 +5572,7 @@ \indexlibrary{\idxcode{basic_iostream}}% \begin{codeblock} namespace std { - template > + template> class basic_iostream : public basic_istream, public basic_ostream { @@ -5699,7 +5699,7 @@ \indexlibrary{\idxcode{basic_ostream}}% \begin{codeblock} namespace std { - template > + template> class basic_ostream : virtual public basic_ios { public: // types (inherited from \tcode{basic_ios} (\ref{ios})): @@ -5915,7 +5915,7 @@ \indexlibrary{\idxcode{sentry}!\idxcode{basic_ostream}}% \begin{codeblock} namespace std { - template > + template> class basic_ostream::sentry { bool ok_; // \expos public: @@ -6592,7 +6592,7 @@ \indexlibrary{\idxcode{endl}}% \begin{itemdecl} -template +template basic_ostream& endl(basic_ostream& os); \end{itemdecl} @@ -6611,7 +6611,7 @@ \indexlibrary{\idxcode{ends}}% \begin{itemdecl} -template +template basic_ostream& ends(basic_ostream& os); \end{itemdecl} @@ -6629,7 +6629,7 @@ \indexlibrary{\idxcode{flush}}% \begin{itemdecl} -template +template basic_ostream& flush(basic_ostream& os); \end{itemdecl} @@ -6648,7 +6648,7 @@ \indexlibrarymember{operator<<}{basic_ostream}% \begin{itemdecl} -template +template basic_ostream& operator<<(basic_ostream&& os, const T& x); \end{itemdecl} @@ -6937,7 +6937,7 @@ \indexlibrary{\idxcode{get_money}}% \begin{itemdecl} -template @\unspec@ get_money(moneyT& mon, bool intl = false); +template @\unspec@ get_money(moneyT& mon, bool intl = false); \end{itemdecl} \begin{itemdescr} @@ -6956,7 +6956,7 @@ \tcode{f(in, mon, intl)}, where the function \tcode{f} is defined as: \begin{codeblock} -template +template void f(basic_ios& str, moneyT& mon, bool intl) { using Iter = istreambuf_iterator; using MoneyGet = money_get; @@ -6977,7 +6977,7 @@ \indexlibrary{\idxcode{put_money}}% \begin{itemdecl} -template @\unspec@ put_money(const moneyT& mon, bool intl = false); +template @\unspec@ put_money(const moneyT& mon, bool intl = false); \end{itemdecl} \begin{itemdescr} @@ -6993,7 +6993,7 @@ \tcode{f(out, mon, intl)}, where the function \tcode{f} is defined as: \begin{codeblock} -template +template void f(basic_ios& str, const moneyT& mon, bool intl) { using Iter = ostreambuf_iterator; using MoneyPut = money_put; @@ -7013,7 +7013,7 @@ \indexlibrary{\idxcode{get_time}}% \begin{itemdecl} -template @\unspec@ get_time(struct tm* tmb, const charT* fmt); +template @\unspec@ get_time(struct tm* tmb, const charT* fmt); \end{itemdecl} \begin{itemdescr} @@ -7027,7 +7027,7 @@ defined as: \begin{codeblock} -template +template void f(basic_ios& str, struct tm* tmb, const charT* fmt) { using Iter = istreambuf_iterator; using TimeGet = time_get; @@ -7049,7 +7049,7 @@ \indexlibrary{\idxcode{put_time}}% \begin{itemdecl} -template @\unspec@ put_time(const struct tm* tmb, const charT* fmt); +template @\unspec@ put_time(const struct tm* tmb, const charT* fmt); \end{itemdecl} \begin{itemdescr} @@ -7066,7 +7066,7 @@ where the function \tcode{f} is defined as: \begin{codeblock} -template +template void f(basic_ios& str, const struct tm* tmb, const charT* fmt) { using Iter = ostreambuf_iterator; using TimePut = time_put; @@ -7091,9 +7091,9 @@ \indexlibrary{\idxcode{quoted}}% \begin{itemdecl} -template +template @\unspec@ quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\')); -template +template @\unspec@ quoted(const basic_string& s, @\itcorr@ charT delim = charT('"'), charT escape = charT('\\')); \end{itemdecl} @@ -7126,7 +7126,7 @@ \indexlibrary{\idxcode{quoted}}% \begin{itemdecl} -template +template @\unspec@ quoted(basic_string& s, @\itcorr@ charT delim = charT('"'), charT escape = charT('\\')); \end{itemdecl} @@ -7194,27 +7194,27 @@ \indexlibrary{\idxcode{basic_stringstream}}% \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class basic_stringbuf; using stringbuf = basic_stringbuf; using wstringbuf = basic_stringbuf; - template , + template, class Allocator = allocator> class basic_istringstream; using istringstream = basic_istringstream; using wistringstream = basic_istringstream; - template , + template, class Allocator = allocator> class basic_ostringstream; using ostringstream = basic_ostringstream; using wostringstream = basic_ostringstream; - template , + template, class Allocator = allocator> class basic_stringstream; using stringstream = basic_stringstream; @@ -7236,7 +7236,7 @@ \indexlibrary{\idxcode{basic_stringbuf}}% \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class basic_stringbuf : public basic_streambuf { public: @@ -7283,7 +7283,7 @@ ios_base::openmode mode; // \expos }; - template + template void swap(basic_stringbuf& x, basic_stringbuf& y); } @@ -7421,7 +7421,7 @@ \indexlibrarymember{swap}{basic_stringbuf}% \begin{itemdecl} -template +template void swap(basic_stringbuf& x, basic_stringbuf& y); \end{itemdecl} @@ -7752,7 +7752,7 @@ \indexlibrary{\idxcode{basic_istringstream}}% \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class basic_istringstream : public basic_istream { public: @@ -7786,7 +7786,7 @@ basic_stringbuf sb; // \expos }; - template + template void swap(basic_istringstream& x, basic_istringstream& y); } @@ -7888,7 +7888,7 @@ \indexlibrarymember{swap}{basic_istringstream}% \begin{itemdecl} -template +template void swap(basic_istringstream& x, basic_istringstream& y); \end{itemdecl} @@ -7939,7 +7939,7 @@ \indexlibrary{\idxcode{basic_ostringstream}}% \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class basic_ostringstream : public basic_ostream { public: @@ -7973,7 +7973,7 @@ basic_stringbuf sb; // \expos }; - template + template void swap(basic_ostringstream& x, basic_ostringstream& y); } @@ -8076,7 +8076,7 @@ \indexlibrarymember{swap}{basic_ostringstream}% \begin{itemdecl} -template +template void swap(basic_ostringstream& x, basic_ostringstream& y); \end{itemdecl} @@ -8127,7 +8127,7 @@ \indexlibrary{\idxcode{basic_stringstream}}% \begin{codeblock} namespace std { - template , + template, class Allocator = allocator> class basic_stringstream : public basic_iostream { public: @@ -8161,7 +8161,7 @@ basic_stringbuf sb; // \expos }; - template + template void swap(basic_stringstream& x, basic_stringstream& y); } @@ -8269,7 +8269,7 @@ \indexlibrarymember{swap}{basic_stringstream}% \begin{itemdecl} -template +template void swap(basic_stringstream& x, basic_stringstream& y); \end{itemdecl} @@ -8338,22 +8338,22 @@ \indexlibrary{\idxcode{basic_fstream}}% \begin{codeblock} namespace std { - template > + template> class basic_filebuf; using filebuf = basic_filebuf; using wfilebuf = basic_filebuf; - template > + template> class basic_ifstream; using ifstream = basic_ifstream; using wifstream = basic_ifstream; - template > + template> class basic_ofstream; using ofstream = basic_ofstream; using wofstream = basic_ofstream; - template > + template> class basic_fstream; using fstream = basic_fstream; using wfstream = basic_fstream; @@ -8379,7 +8379,7 @@ \indexlibrary{\idxcode{basic_filebuf}}% \begin{codeblock} namespace std { - template > + template> class basic_filebuf : public basic_streambuf { public: using char_type = charT; @@ -8427,7 +8427,7 @@ void imbue(const locale& loc) override; }; - template + template void swap(basic_filebuf& x, basic_filebuf& y); } @@ -8585,7 +8585,7 @@ \indexlibrarymember{swap}{basic_filebuf}% \begin{itemdecl} -template +template void swap(basic_filebuf& x, basic_filebuf& y); \end{itemdecl} @@ -9144,7 +9144,7 @@ \indexlibrary{\idxcode{basic_ifstream}}% \begin{codeblock} namespace std { - template > + template> class basic_ifstream : public basic_istream { public: using char_type = charT; @@ -9178,7 +9178,7 @@ basic_filebuf sb; // \expos }; - template + template void swap(basic_ifstream& x, basic_ifstream& y); } @@ -9296,7 +9296,7 @@ \indexlibrarymember{swap}{basic_ifstream}% \begin{itemdecl} -template +template void swap(basic_ifstream& x, basic_ifstream& y); \end{itemdecl} @@ -9381,7 +9381,7 @@ \indexlibrary{\idxcode{basic_ofstream}}% \begin{codeblock} namespace std { - template > + template class basic_ofstream : public basic_ostream { public: using char_type = charT; @@ -9415,7 +9415,7 @@ basic_filebuf sb; // \expos }; - template + template void swap(basic_ofstream& x, basic_ofstream& y); } @@ -9532,7 +9532,7 @@ \indexlibrarymember{swap}{basic_ofstream}% \begin{itemdecl} -template +template void swap(basic_ofstream& x, basic_ofstream& y); \end{itemdecl} @@ -9615,7 +9615,7 @@ \indexlibrary{\idxcode{basic_fstream}}% \begin{codeblock} namespace std { - template > + template> class basic_fstream : public basic_iostream { public: using char_type = charT; @@ -9655,7 +9655,7 @@ basic_filebuf sb; // \expos }; - template + template void swap(basic_fstream& x, basic_fstream& y); } @@ -9776,7 +9776,7 @@ \indexlibrarymember{swap}{basic_fstream}% \begin{itemdecl} -template +template void swap(basic_fstream& x, basic_fstream& y); \end{itemdecl} @@ -10126,17 +10126,17 @@ path operator/ (const path& lhs, const path& rhs); // \ref{path.io}, \tcode{path} inserter and extractor - template + template basic_ostream& operator<<(basic_ostream& os, const path& p); - template + template basic_istream& operator>>(basic_istream& is, path& p); // \ref{path.factory}, \tcode{path} factory functions - template + template path u8path(const Source& source); - template + template path u8path(InputIterator first, InputIterator last); // \ref{class.filesystem_error}, filesystem errors @@ -10414,13 +10414,13 @@ path(const path& p); path(path&& p) noexcept; path(string_type&& source); - template + template path(const Source& source); - template + template path(InputIterator first, InputIterator last); - template + template path(const Source& source, const locale& loc); - template + template path(InputIterator first, InputIterator last, const locale& loc); ~path(); @@ -10429,20 +10429,20 @@ path& operator=(path&& p) noexcept; path& operator=(string_type&& source); path& assign(string_type&& source); - template + template path& operator=(const Source& source); - template + template path& assign(const Source& source) - template + template path& assign(InputIterator first, InputIterator last); // \ref{path.append}, appends path& operator/=(const path& p); - template + template path& operator/=(const Source& source); - template + template path& append(const Source& source); - template + template path& append(InputIterator first, InputIterator last); // \ref{path.concat}, concatenation @@ -10451,13 +10451,13 @@ path& operator+=(basic_string_view x); path& operator+=(const value_type* x); path& operator+=(value_type x); - template + template path& operator+=(const Source& x); - template + template path& operator+=(EcharT x); - template + template path& concat(const Source& x); - template + template path& concat(InputIterator first, InputIterator last); // \ref{path.modifiers}, modifiers @@ -10473,7 +10473,7 @@ const value_type* c_str() const noexcept; operator string_type() const; - template , + template, class Allocator = allocator> basic_string string(const Allocator& a = Allocator()) const; @@ -10484,7 +10484,7 @@ std::u32string u32string() const; // \ref{path.generic.obs}, generic format observers - template , + template, class Allocator = allocator> basic_string generic_string(const Allocator& a = Allocator()) const; @@ -10831,9 +10831,9 @@ \indexlibrary{\idxcode{path}!constructor}% \begin{itemdecl} -template +template path(const Source& source); -template +template path(InputIterator first, InputIterator last); \end{itemdecl} @@ -10846,9 +10846,9 @@ \indexlibrary{\idxcode{path}!constructor}% \begin{itemdecl} -template +template path(const Source& source, const locale& loc); -template +template path(InputIterator first, InputIterator last, const locale& loc); \end{itemdecl} @@ -10956,11 +10956,11 @@ \indexlibrarymember{operator=}{path}% \indexlibrarymember{assign}{path}% \begin{itemdecl} -template +template path& operator=(const Source& source); -template +template path& assign(const Source& source); -template +template path& assign(InputIterator first, InputIterator last); \end{itemdecl} @@ -11008,9 +11008,9 @@ \indexlibrarymember{operator/=}{path}% \indexlibrarymember{append}{path}% \begin{itemdecl} -template +template path& operator/=(const Source& source); -template +template path& append(const Source& source); \end{itemdecl} @@ -11022,7 +11022,7 @@ \indexlibrarymember{operator/=}{path}% \indexlibrarymember{append}{path}% \begin{itemdecl} -template +template path& append(InputIterator first, InputIterator last); \end{itemdecl} @@ -11041,13 +11041,13 @@ path& operator+=(basic_string_view x); path& operator+=(const value_type* x); path& operator+=(value_type x); -template +template path& operator+=(const Source& x); -template +template path& operator+=(EcharT x); -template +template path& concat(const Source& x); -template +template path& concat(InputIterator first, InputIterator last); \end{itemdecl} @@ -11243,7 +11243,7 @@ \indexlibrarymember{string}{path}% \begin{itemdecl} -template , +template, class Allocator = allocator> basic_string string(const Allocator& a = Allocator()) const; @@ -11298,7 +11298,7 @@ \indexlibrarymember{generic_string}{path}% \begin{itemdecl} -template , +template, class Allocator = allocator> basic_string generic_string(const Allocator& a = Allocator()) const; @@ -11914,7 +11914,7 @@ \indexlibrarymember{operator<<}{path}% \begin{itemdecl} -template +template basic_ostream& operator<<(basic_ostream& os, const path& p); \end{itemdecl} @@ -11930,7 +11930,7 @@ \indexlibrarymember{operator>>}{path}% \begin{itemdecl} -template +template basic_istream& operator>>(basic_istream& is, path& p); \end{itemdecl} @@ -11953,9 +11953,9 @@ \indexlibrary{\idxcode{u8path}}% \begin{itemdecl} -template +template path u8path(const Source& source); -template +template path u8path(InputIterator first, InputIterator last); \end{itemdecl} diff --git a/source/iterators.tex b/source/iterators.tex index 4dfcf90c63..eb28c564b2 100644 --- a/source/iterators.tex +++ b/source/iterators.tex @@ -702,159 +702,159 @@ struct random_access_iterator_tag: public bidirectional_iterator_tag { }; // \ref{iterator.operations}, iterator operations - template + template constexpr void advance(InputIterator& i, Distance n); - template + template constexpr typename iterator_traits::difference_type distance(InputIterator first, InputIterator last); - template + template constexpr InputIterator next(InputIterator x, typename iterator_traits::difference_type n = 1); - template + template constexpr BidirectionalIterator prev(BidirectionalIterator x, typename iterator_traits::difference_type n = 1); // \ref{predef.iterators}, predefined iterators - template class reverse_iterator; + template class reverse_iterator; - template + template constexpr bool operator==( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator<( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator!=( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator>( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator>=( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator<=( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr auto operator-( const reverse_iterator& x, const reverse_iterator& y) ->decltype(y.base() - x.base()); - template + template constexpr reverse_iterator operator+( typename reverse_iterator::difference_type n, const reverse_iterator& x); - template + template constexpr reverse_iterator make_reverse_iterator(Iterator i); - template class back_insert_iterator; - template + template class back_insert_iterator; + template back_insert_iterator back_inserter(Container& x); - template class front_insert_iterator; - template + template class front_insert_iterator; + template front_insert_iterator front_inserter(Container& x); - template class insert_iterator; - template + template class insert_iterator; + template insert_iterator inserter(Container& x, typename Container::iterator i); - template class move_iterator; - template + template class move_iterator; + template constexpr bool operator==( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator!=( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator<( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator<=( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator>( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator>=( const move_iterator& x, const move_iterator& y); - template + template constexpr auto operator-( const move_iterator& x, const move_iterator& y) -> decltype(x.base() - y.base()); - template + template constexpr move_iterator operator+( typename move_iterator::difference_type n, const move_iterator& x); - template + template constexpr move_iterator make_move_iterator(Iterator i); // \ref{stream.iterators}, stream iterators - template , + template, class Distance = ptrdiff_t> class istream_iterator; - template + template bool operator==(const istream_iterator& x, const istream_iterator& y); - template + template bool operator!=(const istream_iterator& x, const istream_iterator& y); - template > + template> class ostream_iterator; template> class istreambuf_iterator; - template + template bool operator==(const istreambuf_iterator& a, const istreambuf_iterator& b); - template + template bool operator!=(const istreambuf_iterator& a, const istreambuf_iterator& b); - template > + template> class ostreambuf_iterator; // \ref{iterator.range}, range access - template constexpr auto begin(C& c) -> decltype(c.begin()); - template constexpr auto begin(const C& c) -> decltype(c.begin()); - template constexpr auto end(C& c) -> decltype(c.end()); - template constexpr auto end(const C& c) -> decltype(c.end()); - template constexpr T* begin(T (&array)[N]) noexcept; - template constexpr T* end(T (&array)[N]) noexcept; - template constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c))) + template constexpr auto begin(C& c) -> decltype(c.begin()); + template constexpr auto begin(const C& c) -> decltype(c.begin()); + template constexpr auto end(C& c) -> decltype(c.end()); + template constexpr auto end(const C& c) -> decltype(c.end()); + template constexpr T* begin(T (&array)[N]) noexcept; + template constexpr T* end(T (&array)[N]) noexcept; + template constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c))) -> decltype(std::begin(c)); - template constexpr auto cend(const C& c) noexcept(noexcept(std::end(c))) + template constexpr auto cend(const C& c) noexcept(noexcept(std::end(c))) -> decltype(std::end(c)); - template constexpr auto rbegin(C& c) -> decltype(c.rbegin()); - template constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); - template constexpr auto rend(C& c) -> decltype(c.rend()); - template constexpr auto rend(const C& c) -> decltype(c.rend()); - template constexpr reverse_iterator rbegin(T (&array)[N]); - template constexpr reverse_iterator rend(T (&array)[N]); - template constexpr reverse_iterator rbegin(initializer_list il); - template constexpr reverse_iterator rend(initializer_list il); - template constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); - template constexpr auto crend(const C& c) -> decltype(std::rend(c)); + template constexpr auto rbegin(C& c) -> decltype(c.rbegin()); + template constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); + template constexpr auto rend(C& c) -> decltype(c.rend()); + template constexpr auto rend(const C& c) -> decltype(c.rend()); + template constexpr reverse_iterator rbegin(T (&array)[N]); + template constexpr reverse_iterator rend(T (&array)[N]); + template constexpr reverse_iterator rbegin(initializer_list il); + template constexpr reverse_iterator rend(initializer_list il); + template constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); + template constexpr auto crend(const C& c) -> decltype(std::rend(c)); // \ref{iterator.container}, container access - template constexpr auto size(const C& c) -> decltype(c.size()); - template constexpr size_t size(const T (&array)[N]) noexcept; - template constexpr auto empty(const C& c) -> decltype(c.empty()); - template constexpr bool empty(const T (&array)[N]) noexcept; - template constexpr bool empty(initializer_list il) noexcept; - template constexpr auto data(C& c) -> decltype(c.data()); - template constexpr auto data(const C& c) -> decltype(c.data()); - template constexpr T* data(T (&array)[N]) noexcept; - template constexpr const E* data(initializer_list il) noexcept; + template constexpr auto size(const C& c) -> decltype(c.size()); + template constexpr size_t size(const T (&array)[N]) noexcept; + template constexpr auto empty(const C& c) -> decltype(c.empty()); + template constexpr bool empty(const T (&array)[N]) noexcept; + template constexpr bool empty(initializer_list il) noexcept; + template constexpr auto data(C& c) -> decltype(c.data()); + template constexpr auto data(const C& c) -> decltype(c.data()); + template constexpr T* data(T (&array)[N]) noexcept; + template constexpr const E* data(initializer_list il) noexcept; } \end{codeblock} @@ -955,7 +955,7 @@ function, a \Cpp program can do the following: \begin{codeblock} -template +template void reverse(BidirectionalIterator first, BidirectionalIterator last) { typename iterator_traits::difference_type n = distance(first, last); @@ -1044,20 +1044,20 @@ efficiently for random access iterators, then the implementation is as follows: \begin{codeblock} -template +template inline void evolve(BidirectionalIterator first, BidirectionalIterator last) { evolve(first, last, typename iterator_traits::iterator_category()); } -template +template void evolve(BidirectionalIterator first, BidirectionalIterator last, bidirectional_iterator_tag) { // more generic, but less efficient algorithm } -template +template void evolve(RandomAccessIterator first, RandomAccessIterator last, random_access_iterator_tag) { // more efficient, but less generic algorithm @@ -1091,7 +1091,7 @@ \indexlibrary{\idxcode{advance}}% \begin{itemdecl} -template +template constexpr void advance(InputIterator& i, Distance n); \end{itemdecl} @@ -1113,7 +1113,7 @@ \indexlibrary{\idxcode{distance}}% \begin{itemdecl} -template +template constexpr typename iterator_traits::difference_type distance(InputIterator first, InputIterator last); \end{itemdecl} @@ -1140,7 +1140,7 @@ \indexlibrary{\idxcode{next}}% \begin{itemdecl} -template +template constexpr InputIterator next(InputIterator x, typename iterator_traits::difference_type n = 1); \end{itemdecl} @@ -1152,7 +1152,7 @@ \indexlibrary{\idxcode{prev}}% \begin{itemdecl} -template +template constexpr BidirectionalIterator prev(BidirectionalIterator x, typename iterator_traits::difference_type n = 1); \end{itemdecl} @@ -1178,7 +1178,7 @@ \indexlibrary{\idxcode{reverse_iterator}}% \begin{codeblock} namespace std { - template + template class reverse_iterator { public: using iterator_type = Iterator; @@ -1190,8 +1190,8 @@ constexpr reverse_iterator(); constexpr explicit reverse_iterator(Iterator x); - template constexpr reverse_iterator(const reverse_iterator& u); - template constexpr reverse_iterator& operator=(const reverse_iterator& u); + template constexpr reverse_iterator(const reverse_iterator& u); + template constexpr reverse_iterator& operator=(const reverse_iterator& u); constexpr Iterator base() const; // explicit constexpr reference operator*() const; @@ -1211,40 +1211,40 @@ Iterator current; }; - template + template constexpr bool operator==( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator<( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator!=( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator>( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator>=( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr bool operator<=( const reverse_iterator& x, const reverse_iterator& y); - template + template constexpr auto operator-( const reverse_iterator& x, const reverse_iterator& y) -> decltype(y.base() - x.base()); - template + template constexpr reverse_iterator operator+( typename reverse_iterator::difference_type n, const reverse_iterator& x); - template + template constexpr reverse_iterator make_reverse_iterator(Iterator i); } \end{codeblock} @@ -1310,7 +1310,7 @@ \indexlibrary{\idxcode{reverse_iterator}!constructor}% \begin{itemdecl} -template constexpr reverse_iterator(const reverse_iterator& u); +template constexpr reverse_iterator(const reverse_iterator& u); \end{itemdecl} \begin{itemdescr} @@ -1326,7 +1326,7 @@ \indexlibrarymember{operator=}{reverse_iterator}% \begin{itemdecl} -template +template constexpr reverse_iterator& operator=(const reverse_iterator& u); \end{itemdecl} @@ -1527,7 +1527,7 @@ \indexlibrarymember{operator==}{reverse_iterator}% \begin{itemdecl} -template +template constexpr bool operator==( const reverse_iterator& x, const reverse_iterator& y); @@ -1543,7 +1543,7 @@ \indexlibrarymember{operator<}{reverse_iterator}% \begin{itemdecl} -template +template constexpr bool operator<( const reverse_iterator& x, const reverse_iterator& y); @@ -1559,7 +1559,7 @@ \indexlibrarymember{operator"!=}{reverse_iterator}% \begin{itemdecl} -template +template constexpr bool operator!=( const reverse_iterator& x, const reverse_iterator& y); @@ -1575,7 +1575,7 @@ \indexlibrarymember{operator>}{reverse_iterator}% \begin{itemdecl} -template +template constexpr bool operator>( const reverse_iterator& x, const reverse_iterator& y); @@ -1591,7 +1591,7 @@ \indexlibrarymember{operator>=}{reverse_iterator}% \begin{itemdecl} -template +template constexpr bool operator>=( const reverse_iterator& x, const reverse_iterator& y); @@ -1607,7 +1607,7 @@ \indexlibrarymember{operator<=}{reverse_iterator}% \begin{itemdecl} -template +template constexpr bool operator<=( const reverse_iterator& x, const reverse_iterator& y); @@ -1623,7 +1623,7 @@ \indexlibrarymember{operator-}{reverse_iterator}% \begin{itemdecl} -template +template constexpr auto operator-( const reverse_iterator& x, const reverse_iterator& y) -> decltype(y.base() - x.base()); @@ -1639,7 +1639,7 @@ \indexlibrarymember{operator+}{reverse_iterator}% \begin{itemdecl} -template +template constexpr reverse_iterator operator+( typename reverse_iterator::difference_type n, const reverse_iterator& x); @@ -1656,7 +1656,7 @@ \indexlibrary{\idxcode{reverse_iterator}!\idxcode{make_reverse_iterator} non-member function}% \indexlibrary{\idxcode{make_reverse_iterator}}% \begin{itemdecl} -template +template constexpr reverse_iterator make_reverse_iterator(Iterator i); \end{itemdecl} @@ -1720,7 +1720,7 @@ \indexlibrary{\idxcode{back_insert_iterator}}% \begin{codeblock} namespace std { - template + template class back_insert_iterator { protected: Container* container; @@ -1742,7 +1742,7 @@ back_insert_iterator operator++(int); }; - template + template back_insert_iterator back_inserter(Container& x); } \end{codeblock} @@ -1827,7 +1827,7 @@ \indexlibrary{\idxcode{back_inserter}}% \begin{itemdecl} -template +template back_insert_iterator back_inserter(Container& x); \end{itemdecl} @@ -1842,7 +1842,7 @@ \indexlibrary{\idxcode{front_insert_iterator}}% \begin{codeblock} namespace std { - template + template class front_insert_iterator { protected: Container* container; @@ -1864,7 +1864,7 @@ front_insert_iterator operator++(int); }; - template + template front_insert_iterator front_inserter(Container& x); } \end{codeblock} @@ -1949,7 +1949,7 @@ \indexlibrary{\idxcode{front_inserter}}% \begin{itemdecl} -template +template front_insert_iterator front_inserter(Container& x); \end{itemdecl} @@ -1964,7 +1964,7 @@ \indexlibrary{\idxcode{insert_iterator}}% \begin{codeblock} namespace std { - template + template class insert_iterator { protected: Container* container; @@ -1987,7 +1987,7 @@ insert_iterator& operator++(int); }; - template + template insert_iterator inserter(Container& x, typename Container::iterator i); } \end{codeblock} @@ -2082,7 +2082,7 @@ \indexlibrary{\idxcode{inserter}}% \begin{itemdecl} -template +template insert_iterator inserter(Container& x, typename Container::iterator i); \end{itemdecl} @@ -2120,7 +2120,7 @@ \indexlibrary{\idxcode{move_iterator}}% \begin{codeblock} namespace std { - template + template class move_iterator { public: using iterator_type = Iterator; @@ -2132,8 +2132,8 @@ constexpr move_iterator(); constexpr explicit move_iterator(Iterator i); - template constexpr move_iterator(const move_iterator& u); - template constexpr move_iterator& operator=(const move_iterator& u); + template constexpr move_iterator(const move_iterator& u); + template constexpr move_iterator& operator=(const move_iterator& u); constexpr iterator_type base() const; constexpr reference operator*() const; @@ -2154,33 +2154,33 @@ Iterator current; // \expos }; - template + template constexpr bool operator==( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator!=( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator<( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator<=( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator>( const move_iterator& x, const move_iterator& y); - template + template constexpr bool operator>=( const move_iterator& x, const move_iterator& y); - template + template constexpr auto operator-( const move_iterator& x, const move_iterator& y) -> decltype(x.base() - y.base()); - template + template constexpr move_iterator operator+( typename move_iterator::difference_type n, const move_iterator& x); - template + template constexpr move_iterator make_move_iterator(Iterator i); } \end{codeblock} @@ -2235,7 +2235,7 @@ \indexlibrary{\idxcode{move_iterator}!constructor}% \begin{itemdecl} -template constexpr move_iterator(const move_iterator& u); +template constexpr move_iterator(const move_iterator& u); \end{itemdecl} \begin{itemdescr} @@ -2252,7 +2252,7 @@ \indexlibrarymember{operator=}{move_iterator}% \begin{itemdecl} -template constexpr move_iterator& operator=(const move_iterator& u); +template constexpr move_iterator& operator=(const move_iterator& u); \end{itemdecl} \begin{itemdescr} @@ -2433,7 +2433,7 @@ \indexlibrarymember{operator==}{move_iterator}% \begin{itemdecl} -template +template constexpr bool operator==(const move_iterator& x, const move_iterator& y); \end{itemdecl} @@ -2444,7 +2444,7 @@ \indexlibrarymember{operator"!=}{move_iterator}% \begin{itemdecl} -template +template constexpr bool operator!=(const move_iterator& x, const move_iterator& y); \end{itemdecl} @@ -2455,7 +2455,7 @@ \indexlibrarymember{operator<}{move_iterator}% \begin{itemdecl} -template +template constexpr bool operator<(const move_iterator& x, const move_iterator& y); \end{itemdecl} @@ -2466,7 +2466,7 @@ \indexlibrarymember{operator<=}{move_iterator}% \begin{itemdecl} -template +template constexpr bool operator<=(const move_iterator& x, const move_iterator& y); \end{itemdecl} @@ -2477,7 +2477,7 @@ \indexlibrarymember{operator>}{move_iterator}% \begin{itemdecl} -template +template constexpr bool operator>(const move_iterator& x, const move_iterator& y); \end{itemdecl} @@ -2488,7 +2488,7 @@ \indexlibrarymember{operator>=}{move_iterator}% \begin{itemdecl} -template +template constexpr bool operator>=(const move_iterator& x, const move_iterator& y); \end{itemdecl} @@ -2501,7 +2501,7 @@ \indexlibrarymember{operator-}{move_iterator}% \begin{itemdecl} -template +template constexpr auto operator-( const move_iterator& x, const move_iterator& y) -> decltype(x.base() - y.base()); @@ -2514,7 +2514,7 @@ \indexlibrarymember{operator+}{move_iterator}% \begin{itemdecl} -template +template constexpr move_iterator operator+( typename move_iterator::difference_type n, const move_iterator& x); \end{itemdecl} @@ -2526,7 +2526,7 @@ \indexlibrary{\idxcode{make_move_iterator}}% \begin{itemdecl} -template +template constexpr move_iterator make_move_iterator(Iterator i); \end{itemdecl} @@ -2606,7 +2606,7 @@ \begin{codeblock} namespace std { - template , + template, class Distance = ptrdiff_t> class istream_iterator { public: @@ -2633,10 +2633,10 @@ T value; // \expos }; - template + template bool operator==(const istream_iterator& x, const istream_iterator& y); - template + template bool operator!=(const istream_iterator& x, const istream_iterator& y); } @@ -2771,7 +2771,7 @@ \indexlibrarymember{operator==}{istream_iterator}% \begin{itemdecl} -template +template bool operator==(const istream_iterator& x, const istream_iterator& y); \end{itemdecl} @@ -2784,7 +2784,7 @@ \indexlibrarymember{operator"!=}{istream_iterator}% \begin{itemdecl} -template +template bool operator!=(const istream_iterator& x, const istream_iterator& y); \end{itemdecl} @@ -2824,7 +2824,7 @@ \begin{codeblock} namespace std { - template > + template> class ostream_iterator { public: using iterator_category = output_iterator_tag; @@ -3019,10 +3019,10 @@ streambuf_type* sbuf_; // \expos }; - template + template bool operator==(const istreambuf_iterator& a, const istreambuf_iterator& b); - template + template bool operator!=(const istreambuf_iterator& a, const istreambuf_iterator& b); } @@ -3033,7 +3033,7 @@ \indexlibrary{\idxcode{proxy}!\idxcode{istreambuf_iterator}}% \begin{codeblock} namespace std { - template > + template> class istreambuf_iterator::proxy { // \expos charT keep_; basic_streambuf* sbuf_; @@ -3179,7 +3179,7 @@ \indexlibrarymember{operator==}{istreambuf_iterator}% \begin{itemdecl} -template +template bool operator==(const istreambuf_iterator& a, const istreambuf_iterator& b); \end{itemdecl} @@ -3194,7 +3194,7 @@ \indexlibrarymember{operator"!=}{istreambuf_iterator}% \begin{itemdecl} -template +template bool operator!=(const istreambuf_iterator& a, const istreambuf_iterator& b); \end{itemdecl} @@ -3210,7 +3210,7 @@ \indexlibrary{\idxcode{ostreambuf_iterator}}% \begin{codeblock} namespace std { - template > + template> class ostreambuf_iterator { public: using iterator_category = output_iterator_tag; @@ -3360,8 +3360,8 @@ \indexlibrary{\idxcode{begin(C\&)}}% \begin{itemdecl} -template constexpr auto begin(C& c) -> decltype(c.begin()); -template constexpr auto begin(const C& c) -> decltype(c.begin()); +template constexpr auto begin(C& c) -> decltype(c.begin()); +template constexpr auto begin(const C& c) -> decltype(c.begin()); \end{itemdecl} \begin{itemdescr} @@ -3371,8 +3371,8 @@ \indexlibrary{\idxcode{end(C\&)}}% \begin{itemdecl} -template constexpr auto end(C& c) -> decltype(c.end()); -template constexpr auto end(const C& c) -> decltype(c.end()); +template constexpr auto end(C& c) -> decltype(c.end()); +template constexpr auto end(const C& c) -> decltype(c.end()); \end{itemdecl} \begin{itemdescr} @@ -3382,7 +3382,7 @@ \indexlibrary{\idxcode{begin(T (\&)[N])}}% \begin{itemdecl} -template constexpr T* begin(T (&array)[N]) noexcept; +template constexpr T* begin(T (&array)[N]) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3392,7 +3392,7 @@ \indexlibrary{\idxcode{end(T (\&)[N])}}% \begin{itemdecl} -template constexpr T* end(T (&array)[N]) noexcept; +template constexpr T* end(T (&array)[N]) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3402,7 +3402,7 @@ \indexlibrary{\idxcode{cbegin(const C\&)}}% \begin{itemdecl} -template constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c))) +template constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c))) -> decltype(std::begin(c)); \end{itemdecl} \begin{itemdescr} @@ -3411,7 +3411,7 @@ \indexlibrary{\idxcode{cend(const C\&)}}% \begin{itemdecl} -template constexpr auto cend(const C& c) noexcept(noexcept(std::end(c))) +template constexpr auto cend(const C& c) noexcept(noexcept(std::end(c))) -> decltype(std::end(c)); \end{itemdecl} \begin{itemdescr} @@ -3420,8 +3420,8 @@ \indexlibrary{\idxcode{rbegin(C\&)}}% \begin{itemdecl} -template constexpr auto rbegin(C& c) -> decltype(c.rbegin()); -template constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); +template constexpr auto rbegin(C& c) -> decltype(c.rbegin()); +template constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{c.rbegin()}. @@ -3429,8 +3429,8 @@ \indexlibrary{\idxcode{rend(C\&)}}% \begin{itemdecl} -template constexpr auto rend(C& c) -> decltype(c.rend()); -template constexpr auto rend(const C& c) -> decltype(c.rend()); +template constexpr auto rend(C& c) -> decltype(c.rend()); +template constexpr auto rend(const C& c) -> decltype(c.rend()); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{c.rend()}. @@ -3438,7 +3438,7 @@ \indexlibrary{\idxcode{rbegin(T (\&array)[N])}}% \begin{itemdecl} -template constexpr reverse_iterator rbegin(T (&array)[N]); +template constexpr reverse_iterator rbegin(T (&array)[N]); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{reverse_iterator(array + N)}. @@ -3446,7 +3446,7 @@ \indexlibrary{\idxcode{rend(T (\&array)[N])}}% \begin{itemdecl} -template constexpr reverse_iterator rend(T (&array)[N]); +template constexpr reverse_iterator rend(T (&array)[N]); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{reverse_iterator(array)}. @@ -3454,7 +3454,7 @@ \indexlibrary{\idxcode{rbegin(initializer_list)}}% \begin{itemdecl} -template constexpr reverse_iterator rbegin(initializer_list il); +template constexpr reverse_iterator rbegin(initializer_list il); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{reverse_iterator(il.end())}. @@ -3462,7 +3462,7 @@ \indexlibrary{\idxcode{rend(initializer_list)}}% \begin{itemdecl} -template constexpr reverse_iterator rend(initializer_list il); +template constexpr reverse_iterator rend(initializer_list il); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{reverse_iterator(il.begin())}. @@ -3470,7 +3470,7 @@ \indexlibrary{\idxcode{crbegin(const C\& c)}}% \begin{itemdecl} -template constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); +template constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{std::rbegin(c)}. @@ -3478,7 +3478,7 @@ \indexlibrary{\idxcode{crend(const C\& c)}}% \begin{itemdecl} -template constexpr auto crend(const C& c) -> decltype(std::rend(c)); +template constexpr auto crend(const C& c) -> decltype(std::rend(c)); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{std::rend(c)}. @@ -3496,7 +3496,7 @@ \indexlibrary{\idxcode{size(C\& c)}}% \begin{itemdecl} -template constexpr auto size(const C& c) -> decltype(c.size()); +template constexpr auto size(const C& c) -> decltype(c.size()); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{c.size()}. @@ -3504,7 +3504,7 @@ \indexlibrary{\idxcode{size(T (\&array)[N])}}% \begin{itemdecl} -template constexpr size_t size(const T (&array)[N]) noexcept; +template constexpr size_t size(const T (&array)[N]) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{N}. @@ -3512,7 +3512,7 @@ \indexlibrary{\idxcode{empty(C\& c)}}% \begin{itemdecl} -template constexpr auto empty(const C& c) -> decltype(c.empty()); +template constexpr auto empty(const C& c) -> decltype(c.empty()); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{c.empty()}. @@ -3520,7 +3520,7 @@ \indexlibrary{\idxcode{empty(T (\&array)[N])}}% \begin{itemdecl} -template constexpr bool empty(const T (&array)[N]) noexcept; +template constexpr bool empty(const T (&array)[N]) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{false}. @@ -3528,7 +3528,7 @@ \indexlibrary{\idxcode{empty(initializer_list)}}% \begin{itemdecl} -template constexpr bool empty(initializer_list il) noexcept; +template constexpr bool empty(initializer_list il) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{il.size() == 0}. @@ -3536,8 +3536,8 @@ \indexlibrary{\idxcode{data(C\& c)}}% \begin{itemdecl} -template constexpr auto data(C& c) -> decltype(c.data()); -template constexpr auto data(const C& c) -> decltype(c.data()); +template constexpr auto data(C& c) -> decltype(c.data()); +template constexpr auto data(const C& c) -> decltype(c.data()); \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{c.data()}. @@ -3545,7 +3545,7 @@ \indexlibrary{\idxcode{data(T (\&array)[N])}}% \begin{itemdecl} -template constexpr T* data(T (&array)[N]) noexcept; +template constexpr T* data(T (&array)[N]) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{array}. @@ -3553,7 +3553,7 @@ \indexlibrary{\idxcode{data(initializer_list)}}% \begin{itemdecl} -template constexpr const E* data(initializer_list il) noexcept; +template constexpr const E* data(initializer_list il) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns \tcode{il.begin()}. diff --git a/source/lib-intro.tex b/source/lib-intro.tex index 04f80c7364..45eafc90de 100644 --- a/source/lib-intro.tex +++ b/source/lib-intro.tex @@ -1594,7 +1594,7 @@ #include // Requires: \tcode{std::forward(t)} shall be swappable with \tcode{std::forward(u)}. -template +template void value_swap(T&& t, U&& u) { using std::swap; swap(std::forward(t), std::forward(u)); // OK: uses ``swappable with'' conditions @@ -1602,7 +1602,7 @@ } // Requires: lvalues of \tcode{T} shall be swappable. -template +template void lv_swap(T& t1, T& t2) { using std::swap; swap(t1, t2); // OK: uses swappable conditions for @@ -2095,20 +2095,20 @@ Table~\ref{tab:utilities.allocator.requirements}: \begin{codeblock} -template +template struct SimpleAllocator { typedef Tp value_type; SimpleAllocator(@\textit{ctor args}@); - template SimpleAllocator(const SimpleAllocator& other); + template SimpleAllocator(const SimpleAllocator& other); Tp* allocate(std::size_t n); void deallocate(Tp* p, std::size_t n); }; -template +template bool operator==(const SimpleAllocator&, const SimpleAllocator&); -template +template bool operator!=(const SimpleAllocator&, const SimpleAllocator&); \end{codeblock} \end{example} diff --git a/source/locales.tex b/source/locales.tex index ccccd4bc69..5769508586 100644 --- a/source/locales.tex +++ b/source/locales.tex @@ -31,81 +31,81 @@ namespace std { // \ref{locale}, locale class locale; - template const Facet& use_facet(const locale&); - template bool has_facet(const locale&) noexcept; + template const Facet& use_facet(const locale&); + template bool has_facet(const locale&) noexcept; // \ref{locale.convenience}, convenience interfaces - template bool isspace (charT c, const locale& loc); - template bool isprint (charT c, const locale& loc); - template bool iscntrl (charT c, const locale& loc); - template bool isupper (charT c, const locale& loc); - template bool islower (charT c, const locale& loc); - template bool isalpha (charT c, const locale& loc); - template bool isdigit (charT c, const locale& loc); - template bool ispunct (charT c, const locale& loc); - template bool isxdigit(charT c, const locale& loc); - template bool isalnum (charT c, const locale& loc); - template bool isgraph (charT c, const locale& loc); - template bool isblank (charT c, const locale& loc); - template charT toupper(charT c, const locale& loc); - template charT tolower(charT c, const locale& loc); - template bool isspace (charT c, const locale& loc); + template bool isprint (charT c, const locale& loc); + template bool iscntrl (charT c, const locale& loc); + template bool isupper (charT c, const locale& loc); + template bool islower (charT c, const locale& loc); + template bool isalpha (charT c, const locale& loc); + template bool isdigit (charT c, const locale& loc); + template bool ispunct (charT c, const locale& loc); + template bool isxdigit(charT c, const locale& loc); + template bool isalnum (charT c, const locale& loc); + template bool isgraph (charT c, const locale& loc); + template bool isblank (charT c, const locale& loc); + template charT toupper(charT c, const locale& loc); + template charT tolower(charT c, const locale& loc); + template, class Byte_alloc = allocator> class wstring_convert; - template > class wbuffer_convert; // \ref{category.ctype}, ctype class ctype_base; - template class ctype; - template <> class ctype; // specialization - template class ctype_byname; + template class ctype; + template<> class ctype; // specialization + template class ctype_byname; class codecvt_base; - template class codecvt; - template class codecvt_byname; + template class codecvt; + template class codecvt_byname; // \ref{category.numeric}, numeric - template > + template> class num_get; - template > + template> class num_put; - template + template class numpunct; - template + template class numpunct_byname; // \ref{category.collate}, collation - template class collate; - template class collate_byname; + template class collate; + template class collate_byname; // \ref{category.time}, date and time class time_base; - template > + template> class time_get; - template > + template> class time_get_byname; - template > + template> class time_put; - template > + template> class time_put_byname; // \ref{category.monetary}, money class money_base; - template > + template> class money_get; - template > + template> class money_put; - template + template class moneypunct; - template + template class moneypunct_byname; // \ref{category.messages}, message retrieval class messages_base; - template class messages; - template class messages_byname; + template class messages; + template class messages_byname; } \end{codeblock} @@ -150,11 +150,11 @@ explicit locale(const string& std_name); locale(const locale& other, const char* std_name, category); locale(const locale& other, const string& std_name, category); - template locale(const locale& other, Facet* f); + template locale(const locale& other, Facet* f); locale(const locale& other, const locale& one, category); ~locale(); // not virtual const locale& operator=(const locale& other) noexcept; - template locale combine(const locale& other) const; + template locale combine(const locale& other) const; // locale operations: basic_string name() const; @@ -162,7 +162,7 @@ bool operator==(const locale& other) const; bool operator!=(const locale& other) const; - template + template bool operator()(const basic_string& s1, const basic_string& s2) const; @@ -200,14 +200,14 @@ \tcode{ostreambuf_iterator}.} \begin{codeblock} -template +template basic_ostream& operator<< (basic_ostream& s, Date d) { typename basic_ostream::sentry cerberos(s); if (cerberos) { ios_base::iostate err = ios_base::iostate::goodbit; tm tmbuf; d.extract(tmbuf); - use_facet> >( + use_facet>>( s.getloc()).put(s, s, s.fill(), err, &tmbuf, 'x'); s.setstate(err); // might throw } @@ -694,7 +694,7 @@ \indexlibrary{\idxcode{locale}!constructor}% \begin{itemdecl} -template locale(const locale& other, Facet* f); +template locale(const locale& other, Facet* f); \end{itemdecl} \begin{itemdescr} @@ -760,7 +760,7 @@ \indexlibrarymember{locale}{combine}% \begin{itemdecl} -template locale combine(const locale& other) const; +template locale combine(const locale& other) const; \end{itemdecl} \begin{itemdescr} @@ -832,7 +832,7 @@ \indexlibrarymember{locale}{operator()}% \begin{itemdecl} -template +template bool operator()(const basic_string& s1, const basic_string& s2) const; \end{itemdecl} @@ -933,7 +933,7 @@ \indexlibrarymember{locale}{use_facet}% \begin{itemdecl} -template const Facet& use_facet(const locale& loc); +template const Facet& use_facet(const locale& loc); \end{itemdecl} \begin{itemdescr} @@ -964,7 +964,7 @@ \indexlibrarymember{locale}{has_facet}% \begin{itemdecl} -template bool has_facet(const locale& loc) noexcept; +template bool has_facet(const locale& loc) noexcept; \end{itemdecl} \begin{itemdescr} @@ -990,18 +990,18 @@ \indexlibrary{\idxcode{isgraph}}% \indexlibrary{\idxcode{isblank}}% \begin{itemdecl} -template bool isspace (charT c, const locale& loc); -template bool isprint (charT c, const locale& loc); -template bool iscntrl (charT c, const locale& loc); -template bool isupper (charT c, const locale& loc); -template bool islower (charT c, const locale& loc); -template bool isalpha (charT c, const locale& loc); -template bool isdigit (charT c, const locale& loc); -template bool ispunct (charT c, const locale& loc); -template bool isxdigit(charT c, const locale& loc); -template bool isalnum (charT c, const locale& loc); -template bool isgraph (charT c, const locale& loc); -template bool isblank (charT c, const locale& loc); +template bool isspace (charT c, const locale& loc); +template bool isprint (charT c, const locale& loc); +template bool iscntrl (charT c, const locale& loc); +template bool isupper (charT c, const locale& loc); +template bool islower (charT c, const locale& loc); +template bool isalpha (charT c, const locale& loc); +template bool isdigit (charT c, const locale& loc); +template bool ispunct (charT c, const locale& loc); +template bool isxdigit(charT c, const locale& loc); +template bool isalnum (charT c, const locale& loc); +template bool isgraph (charT c, const locale& loc); +template bool isblank (charT c, const locale& loc); \end{itemdecl} \pnum @@ -1027,7 +1027,7 @@ \indexlibrary{\idxcode{toupper}}% \begin{itemdecl} -template charT toupper(charT c, const locale& loc); +template charT toupper(charT c, const locale& loc); \end{itemdecl} \begin{itemdescr} @@ -1038,7 +1038,7 @@ \indexlibrary{\idxcode{tolower}}% \begin{itemdecl} -template charT tolower(charT c, const locale& loc); +template charT tolower(charT c, const locale& loc); \end{itemdecl} \begin{itemdescr} @@ -1068,7 +1068,7 @@ \indexlibrary{\idxcode{wstring_convert}}% \begin{codeblock} namespace std { -template , class Byte_alloc = allocator> class wstring_convert { @@ -1322,7 +1322,7 @@ \indexlibrary{\idxcode{wbuffer_convert}}% \begin{codeblock} namespace std { -template > +template> class wbuffer_convert : public basic_streambuf { public: @@ -1524,7 +1524,7 @@ \indexlibrary{\idxcode{ctype}}% \begin{codeblock} namespace std { - template + template class ctype : public locale::facet, public ctype_base { public: using char_type = charT; @@ -1924,7 +1924,7 @@ \indexlibrary{\idxcode{ctype_byname}}% \begin{codeblock} namespace std { - template + template class ctype_byname : public ctype { public: using mask = typename ctype::mask; @@ -1941,7 +1941,7 @@ \indexlibrary{\idxcode{ctype}}% \begin{codeblock} namespace std { - template <> + template<> class ctype : public locale::facet, public ctype_base { public: using char_type = char; @@ -2254,7 +2254,7 @@ enum result { ok, partial, error, noconv }; }; - template + template class codecvt : public locale::facet, public codecvt_base { public: using intern_type = internT; @@ -2708,7 +2708,7 @@ \indexlibrary{\idxcode{codecvt_byname}}% \begin{codeblock} namespace std { - template + template class codecvt_byname : public codecvt { public: explicit codecvt_byname(const char*, size_t refs = 0); @@ -2773,7 +2773,7 @@ \indexlibrary{\idxcode{num_get}}% \begin{codeblock} namespace std { - template > + template> class num_get : public locale::facet { public: using char_type = charT; @@ -3187,7 +3187,7 @@ \indexlibrary{\idxcode{num_put}}% \begin{codeblock} namespace std { - template > + template> class num_put : public locale::facet { public: using char_type = charT; @@ -3519,7 +3519,7 @@ \indexlibrary{\idxcode{numpunct}}% \begin{codeblock} namespace std { - template + template class numpunct : public locale::facet { public: using char_type = charT; @@ -3734,7 +3734,7 @@ \indexlibrary{\idxcode{numpunct_byname}}% \begin{codeblock} namespace std { - template + template class numpunct_byname : public numpunct { // this class is specialized for \tcode{char} and \tcode{wchar_t}. public: @@ -3756,7 +3756,7 @@ \indexlibrary{\idxcode{collate}}% \begin{codeblock} namespace std { - template + template class collate : public locale::facet { public: using char_type = charT; @@ -3904,7 +3904,7 @@ \indexlibrary{\idxcode{collate_byname}}% \begin{codeblock} namespace std { - template + template class collate_byname : public collate { public: using string_type = basic_string; @@ -3951,7 +3951,7 @@ enum dateorder { no_order, dmy, mdy, ymd, ydm }; }; - template > + template> class time_get : public locale::facet, public time_base { public: using char_type = charT; @@ -4358,7 +4358,7 @@ \indexlibrary{\idxcode{time_get_byname}}% \begin{codeblock} namespace std { - template > + template> class time_get_byname : public time_get { public: using dateorder = time_base::dateorder; @@ -4377,7 +4377,7 @@ \indexlibrary{\idxcode{time_put}}% \begin{codeblock} namespace std { - template > + template> class time_put : public locale::facet { public: using char_type = charT; @@ -4510,7 +4510,7 @@ \indexlibrary{\idxcode{time_put_byname}}% \begin{codeblock} namespace std { - template > + template> class time_put_byname : public time_put { public: @@ -4556,7 +4556,7 @@ \indexlibrary{\idxcode{money_get}}% \begin{codeblock} namespace std { - template > + template> class money_get : public locale::facet { public: using char_type = charT; @@ -4785,7 +4785,7 @@ \indexlibrary{\idxcode{money_put}}% \begin{codeblock} namespace std { - template > + template> class money_put : public locale::facet { public: using char_type = charT; @@ -4941,7 +4941,7 @@ struct pattern { char field[4]; }; }; - template + template class moneypunct : public locale::facet, public money_base { public: using char_type = charT; @@ -5269,7 +5269,7 @@ \indexlibrary{\idxcode{moneypunct_byname}}% \begin{codeblock} namespace std { - template + template class moneypunct_byname : public moneypunct { public: using pattern = money_base::pattern; @@ -5300,7 +5300,7 @@ using catalog = @\textit{unspecified signed integer type}@; }; - template + template class messages : public locale::facet, public messages_base { public: using char_type = charT; @@ -5444,7 +5444,7 @@ \indexlibrary{\idxcode{messages_byname}}% \begin{codeblock} namespace std { - template + template class messages_byname : public messages { public: using catalog = messages_base::catalog; @@ -5683,21 +5683,21 @@ little_endian = 1 }; - template + template class codecvt_utf8 : public codecvt { public: explicit codecvt_utf8(size_t refs = 0); ~codecvt_utf8(); }; - template + template class codecvt_utf16 : public codecvt { public: explicit codecvt_utf16(size_t refs = 0); ~codecvt_utf16(); }; - template + template class codecvt_utf8_utf16 : public codecvt { public: explicit codecvt_utf8_utf16(size_t refs = 0); diff --git a/source/numerics.tex b/source/numerics.tex index d33139ed41..32a89ea712 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -2726,7 +2726,7 @@ \item if the constructor \begin{codeblock} -template explicit X(Sseq& q); +template explicit X(Sseq& q); \end{codeblock} is called with a type \tcode{Sseq} that does not qualify as a seed sequence, then this constructor shall not participate in overload resolution; @@ -2734,7 +2734,7 @@ \item if the member function \begin{codeblock} -template void seed(Sseq& q); +template void seed(Sseq& q); \end{codeblock} is called with a type \tcode{Sseq} that does not qualify as a seed sequence, then this function shall not participate in overload resolution. @@ -6560,10 +6560,10 @@ template valarray tan (const valarray&); template valarray tanh (const valarray&); - template @\unspec{1}@ begin(valarray& v); - template @\unspec{2}@ begin(const valarray& v); - template @\unspec{1}@ end(valarray& v); - template @\unspec{2}@ end(const valarray& v); + template @\unspec{1}@ begin(valarray& v); + template @\unspec{2}@ begin(const valarray& v); + template @\unspec{1}@ end(valarray& v); + template @\unspec{2}@ end(const valarray& v); } \end{codeblock} @@ -7748,7 +7748,7 @@ \indexlibrarymember{swap}{valarray}% \begin{itemdecl} -template void swap(valarray& x, valarray& y) noexcept; +template void swap(valarray& x, valarray& y) noexcept; \end{itemdecl} \begin{itemdescr} @@ -7840,7 +7840,7 @@ \indexlibrary{\idxcode{slice_array}}% \begin{codeblock} namespace std { - template class slice_array { + template class slice_array { public: using value_type = T; @@ -8125,7 +8125,7 @@ \indexlibrary{\idxcode{gslice_array}}% \begin{codeblock} namespace std { - template class gslice_array { + template class gslice_array { public: using value_type = T; @@ -8256,7 +8256,7 @@ \indexlibrary{\idxcode{mask_array}}% \begin{codeblock} namespace std { - template class mask_array { + template class mask_array { public: using value_type = T; @@ -8381,7 +8381,7 @@ \indexlibrary{\idxcode{indirect_array}}% \begin{codeblock} namespace std { - template class indirect_array { + template class indirect_array { public: using value_type = T; @@ -8550,8 +8550,8 @@ \indexlibrary{\idxcode{begin}!\idxcode{valarray}}% \begin{itemdecl} -template @\unspec{1}@ begin(valarray& v); -template @\unspec{2}@ begin(const valarray& v); +template @\unspec{1}@ begin(valarray& v); +template @\unspec{2}@ begin(const valarray& v); \end{itemdecl} \begin{itemdescr} @@ -8561,8 +8561,8 @@ \indexlibrary{\idxcode{end}!\idxcode{valarray}}% \begin{itemdecl} -template @\unspec{1}@ end(valarray& v); -template @\unspec{2}@ end(const valarray& v); +template @\unspec{1}@ end(valarray& v); +template @\unspec{2}@ end(const valarray& v); \end{itemdecl} \begin{itemdescr} @@ -8579,9 +8579,9 @@ \indexlibrary{\idxhdr{numeric}}% \begin{codeblock} namespace std { - template + template T accumulate(InputIterator first, InputIterator last, T init); - template + template T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); @@ -8614,21 +8614,21 @@ InputIterator first, InputIterator last, UnaryOperation unary_op, T init, BinaryOperation binary_op); - template + template T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); - template T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); - template T inner_product(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); - template T inner_product(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator1 first1, InputIterator1 last1, @@ -8636,11 +8636,11 @@ BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); - template + template OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result); - template + template OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result, @@ -8739,21 +8739,21 @@ UnaryOperation unary_op, BinaryOperation binary_op, T init); - template + template OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result); - template + template OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); - template + template OutputIterator adjacent_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, OutputIterator result); - template OutputIterator adjacent_difference(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, @@ -8761,15 +8761,15 @@ OutputIterator result, BinaryOperation binary_op); - template + template void iota(ForwardIterator first, ForwardIterator last, T value); // \ref{numeric.ops.gcd}, greatest common divisor - template + template constexpr common_type_t gcd(M m, N n); // \ref{numeric.ops.lcm}, least common multiple - template + template constexpr common_type_t lcm(M m, N n); } \end{codeblock} @@ -8783,9 +8783,9 @@ \indexlibrary{\idxcode{accumulate}}% \begin{itemdecl} -template +template T accumulate(InputIterator first, InputIterator last, T init); -template +template T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); \end{itemdecl} @@ -8958,21 +8958,21 @@ \indexlibrary{\idxcode{inner_product}}% \begin{itemdecl} -template +template T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); -template +template T inner_product(ExecutionPolicy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); -template T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); -template T inner_product(ExecutionPolicy&& exec, InputIterator1 first1, InputIterator1 last1, @@ -9019,11 +9019,11 @@ \indexlibrary{\idxcode{partial_sum}}% \begin{itemdecl} -template +template OutputIterator partial_sum( InputIterator first, InputIterator last, OutputIterator result); -template +template OutputIterator partial_sum( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); @@ -9405,22 +9405,22 @@ \indexlibrary{\idxcode{adjacent_difference}}% \begin{itemdecl} -template +template OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result); -template +template OutputIterator adjacent_difference(ExecutionPolicy&& exec, InputIterator first, InputIterator last, OutputIterator result); -template +template OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); -template +template OutputIterator adjacent_difference(ExecutionPolicy&& exec, InputIterator first, InputIterator last, @@ -9474,7 +9474,7 @@ \indexlibrary{\idxcode{iota}}% \begin{itemdecl} -template +template void iota(ForwardIterator first, ForwardIterator last, T value); \end{itemdecl} @@ -9497,7 +9497,7 @@ \indexlibrary{\idxcode{gcd}}% \begin{itemdecl} -template +template constexpr common_type_t gcd(M m, N n); \end{itemdecl} @@ -9528,7 +9528,7 @@ \indexlibrary{\idxcode{lcm}}% \begin{itemdecl} -template +template constexpr common_type_t lcm(M m, N n); \end{itemdecl} diff --git a/source/overloading.tex b/source/overloading.tex index cd60a9b7ad..fed6a46aea 100644 --- a/source/overloading.tex +++ b/source/overloading.tex @@ -1444,7 +1444,7 @@ \pnum \begin{example} \begin{codeblock} -template struct A { +template struct A { explicit A(const T&, ...) noexcept; // \#1 A(T&&, ...); // \#2 }; @@ -1457,17 +1457,17 @@ A a3{0, i}; // OK, \#2 deduces to \tcode{A} and also initializes A a4 = {0, i}; // OK, \#2 deduces to \tcode{A} and also initializes -template A(const T&, const T&) -> A; // \#3 -template explicit A(T&&, T&&) -> A; // \#4 +template A(const T&, const T&) -> A; // \#3 +template explicit A(T&&, T&&) -> A; // \#4 A a5 = {0, 1}; // error: explicit deduction guide \#4 selected in copy-list-initialization during deduction A a6{0,1}; // OK, \#4 deduces to \tcode{A} and \#2 initializes A a7 = {0, i}; // error: \#3 deduces to \tcode{A}, \#1 and \#2 declare same constructor A a8{0,i}; // error: \#3 deduces to \tcode{A}, \#1 and \#2 declare same constructor -template struct B { - template using TA = T; - template B(U, TA); +template struct B { + template using TA = T; + template B(U, TA); }; B b{(int*)0, (char*)0}; // OK, deduces \tcode{B} @@ -1628,7 +1628,7 @@ as the reference being initialized, and the return type of \tcode{F2} is not \begin{example} \begin{codeblock} -template struct A { +template struct A { operator T&(); // \#1 operator T&&(); // \#2 }; @@ -1646,13 +1646,13 @@ and \tcode{F2} is not \begin{example} \begin{codeblock} -template struct A { +template struct A { A(T, int*); // \#1 A(A&, int*); // \#2 enum { value }; }; -template A(T&&, int*) -> A; // \#3 +template A(T&&, int*) -> A; // \#3 A a{1, 0}; // uses \#1 to deduce \tcode{A} and initializes with \#1 A b{a, 0}; // uses \#3 (not \#2) to deduce \tcode{A\&>} and initializes with \#1 @@ -3373,7 +3373,7 @@ float operator " " B(const char*); // error: non-empty \grammarterm{string-literal} string operator "" 5X(const char*, std::size_t); // error: invalid literal suffix identifier double operator "" _miles(double); // error: invalid \grammarterm{parameter-declaration-clause} -template int operator "" _j(const char*); // error: invalid \grammarterm{parameter-declaration-clause} +template int operator "" _j(const char*); // error: invalid \grammarterm{parameter-declaration-clause} extern "C" void operator "" _m(long double); // error: C language linkage \end{codeblock} \end{example}% diff --git a/source/regex.tex b/source/regex.tex index 494d450f63..553929e529 100644 --- a/source/regex.tex +++ b/source/regex.tex @@ -272,20 +272,20 @@ class regex_error; // \ref{re.traits}, class template \tcode{regex_traits} - template struct regex_traits; + template struct regex_traits; // \ref{re.regex}, class template \tcode{basic_regex} - template > class basic_regex; + template> class basic_regex; using regex = basic_regex; using wregex = basic_regex; // \ref{re.regex.swap}, \tcode{basic_regex} swap - template + template void swap(basic_regex& e1, basic_regex& e2); // \ref{re.submatch}, class template \tcode{sub_match} - template + template class sub_match; using csub_match = sub_match; @@ -294,152 +294,152 @@ using wssub_match = sub_match; // \ref{re.submatch.op}, \tcode{sub_match} non-member operators - template + template bool operator==(const sub_match& lhs, const sub_match& rhs); - template + template bool operator!=(const sub_match& lhs, const sub_match& rhs); - template + template bool operator<(const sub_match& lhs, const sub_match& rhs); - template + template bool operator<=(const sub_match& lhs, const sub_match& rhs); - template + template bool operator>=(const sub_match& lhs, const sub_match& rhs); - template + template bool operator>(const sub_match& lhs, const sub_match& rhs); - template + template bool operator==( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); - template + template bool operator!=( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); - template + template bool operator<( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); - template + template bool operator>( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); - template + template bool operator>=( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); - template + template bool operator<=( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); - template + template bool operator==( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); - template + template bool operator!=( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); - template + template bool operator<( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); - template + template bool operator>( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); - template + template bool operator>=( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); - template + template bool operator<=( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); - template + template bool operator==(const typename iterator_traits::value_type* lhs, const sub_match& rhs); - template + template bool operator!=(const typename iterator_traits::value_type* lhs, const sub_match& rhs); - template + template bool operator<(const typename iterator_traits::value_type* lhs, const sub_match& rhs); - template + template bool operator>(const typename iterator_traits::value_type* lhs, const sub_match& rhs); - template + template bool operator>=(const typename iterator_traits::value_type* lhs, const sub_match& rhs); - template + template bool operator<=(const typename iterator_traits::value_type* lhs, const sub_match& rhs); - template + template bool operator==(const sub_match& lhs, const typename iterator_traits::value_type* rhs); - template + template bool operator!=(const sub_match& lhs, const typename iterator_traits::value_type* rhs); - template + template bool operator<(const sub_match& lhs, const typename iterator_traits::value_type* rhs); - template + template bool operator>(const sub_match& lhs, const typename iterator_traits::value_type* rhs); - template + template bool operator>=(const sub_match& lhs, const typename iterator_traits::value_type* rhs); - template + template bool operator<=(const sub_match& lhs, const typename iterator_traits::value_type* rhs); - template + template bool operator==(const typename iterator_traits::value_type& lhs, const sub_match& rhs); - template + template bool operator!=(const typename iterator_traits::value_type& lhs, const sub_match& rhs); - template + template bool operator<(const typename iterator_traits::value_type& lhs, const sub_match& rhs); - template + template bool operator>(const typename iterator_traits::value_type& lhs, const sub_match& rhs); - template + template bool operator>=(const typename iterator_traits::value_type& lhs, const sub_match& rhs); - template + template bool operator<=(const typename iterator_traits::value_type& lhs, const sub_match& rhs); - template + template bool operator==(const sub_match& lhs, const typename iterator_traits::value_type& rhs); - template + template bool operator!=(const sub_match& lhs, const typename iterator_traits::value_type& rhs); - template + template bool operator<(const sub_match& lhs, const typename iterator_traits::value_type& rhs); - template + template bool operator>(const sub_match& lhs, const typename iterator_traits::value_type& rhs); - template + template bool operator>=(const sub_match& lhs, const typename iterator_traits::value_type& rhs); - template + template bool operator<=(const sub_match& lhs, const typename iterator_traits::value_type& rhs); - template + template basic_ostream& operator<<(basic_ostream& os, const sub_match& m); // \ref{re.results}, class template \tcode{match_results} - template >> + template>> class match_results; using cmatch = match_results; @@ -448,83 +448,83 @@ using wsmatch = match_results; // \tcode{match_results} comparisons - template + template bool operator==(const match_results& m1, const match_results& m2); - template + template bool operator!=(const match_results& m1, const match_results& m2); // \ref{re.results.swap}, \tcode{match_results} swap - template + template void swap(match_results& m1, match_results& m2); // \ref{re.alg.match}, function template \tcode{regex_match} - template + template bool regex_match(BidirectionalIterator first, BidirectionalIterator last, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_match(BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_match(const charT* str, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_match(const basic_string& s, match_results::const_iterator, Allocator>& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_match(const basic_string&&, match_results::const_iterator, Allocator>&, const basic_regex&, regex_constants::match_flag_type = regex_constants::match_default) = delete; - template + template bool regex_match(const charT* str, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_match(const basic_string& s, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); // \ref{re.alg.search}, function template \tcode{regex_search} - template + template bool regex_search(BidirectionalIterator first, BidirectionalIterator last, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_search(BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_search(const charT* str, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_search(const charT* str, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_search(const basic_string& s, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_search(const basic_string& s, match_results::const_iterator, Allocator>& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template bool regex_search(const basic_string&&, match_results::const_iterator, Allocator>&, @@ -533,8 +533,8 @@ = regex_constants::match_default) = delete; // \ref{re.alg.replace}, function template \tcode{regex_replace} - template + template OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, @@ -548,25 +548,25 @@ const basic_regex& e, const charT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template basic_string regex_replace(const basic_string& s, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template basic_string regex_replace(const basic_string& s, const basic_regex& e, const charT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template basic_string regex_replace(const charT* s, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); - template + template basic_string regex_replace(const charT* s, const basic_regex& e, @@ -574,9 +574,9 @@ regex_constants::match_flag_type flags = regex_constants::match_default); // \ref{re.regiter}, class template \tcode{regex_iterator} - template ::value_type, - class traits = regex_traits> + template::value_type, + class traits = regex_traits> class regex_iterator; using cregex_iterator = regex_iterator; @@ -585,9 +585,9 @@ using wsregex_iterator = regex_iterator; // \ref{re.tokiter}, class template \tcode{regex_token_iterator} - template ::value_type, - class traits = regex_traits> + template::value_type, + class traits = regex_traits> class regex_token_iterator; using cregex_token_iterator = regex_token_iterator; @@ -596,7 +596,7 @@ using wsregex_token_iterator = regex_token_iterator; namespace pmr { - template + template using match_results = std::match_results>>; @@ -1015,7 +1015,7 @@ \indexlibrary{\idxcode{regex_traits}}% \begin{codeblock} namespace std { - template + template struct regex_traits { using char_type = charT; using string_type = basic_string; @@ -1026,15 +1026,15 @@ static size_t length(const char_type* p); charT translate(charT c) const; charT translate_nocase(charT c) const; - template + template string_type transform(ForwardIterator first, ForwardIterator last) const; - template + template string_type transform_primary( ForwardIterator first, ForwardIterator last) const; - template + template string_type lookup_collatename( ForwardIterator first, ForwardIterator last) const; - template + template char_class_type lookup_classname( ForwardIterator first, ForwardIterator last, bool icase = false) const; bool isctype(charT c, char_class_type f) const; @@ -1094,7 +1094,7 @@ \indexlibrarymember{regex_traits}{transform}% \begin{itemdecl} -template +template string_type transform(ForwardIterator first, ForwardIterator last) const; \end{itemdecl} @@ -1110,7 +1110,7 @@ \indexlibrarymember{regex_traits}{transform_primary}% \begin{itemdecl} -template +template string_type transform_primary(ForwardIterator first, ForwardIterator last) const; \end{itemdecl} @@ -1129,7 +1129,7 @@ \indexlibrarymember{regex_traits}{lookup_collatename}% \begin{itemdecl} -template +template string_type lookup_collatename(ForwardIterator first, ForwardIterator last) const; \end{itemdecl} @@ -1143,7 +1143,7 @@ \indexlibrarymember{regex_traits}{lookup_classname}% \begin{itemdecl} -template +template char_class_type lookup_classname( ForwardIterator first, ForwardIterator last, bool icase = false) const; \end{itemdecl} @@ -1325,7 +1325,7 @@ \indexlibrary{\idxcode{basic_regex}}% \begin{codeblock} namespace std { - template > + template> class basic_regex { public: // types: @@ -1365,10 +1365,10 @@ basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); basic_regex(const basic_regex&); basic_regex(basic_regex&&) noexcept; - template + template explicit basic_regex(const basic_string& p, flag_type f = regex_constants::ECMAScript); - template + template basic_regex(ForwardIterator first, ForwardIterator last, flag_type f = regex_constants::ECMAScript); basic_regex(initializer_list, flag_type = regex_constants::ECMAScript); @@ -1379,7 +1379,7 @@ basic_regex& operator=(basic_regex&&) noexcept; basic_regex& operator=(const charT* ptr); basic_regex& operator=(initializer_list il); - template + template basic_regex& operator=(const basic_string& p); // \ref{re.regex.assign}, assign @@ -1387,10 +1387,10 @@ basic_regex& assign(basic_regex&& that) noexcept; basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript); basic_regex& assign(const charT* p, size_t len, flag_type f); - template + template basic_regex& assign(const basic_string& s, flag_type f = regex_constants::ECMAScript); - template + template basic_regex& assign(InputIterator first, InputIterator last, flag_type f = regex_constants::ECMAScript); basic_regex& assign(initializer_list, @@ -1526,7 +1526,7 @@ \indexlibrary{\idxcode{basic_regex}!constructor}% \begin{itemdecl} -template +template explicit basic_regex(const basic_string& s, flag_type f = regex_constants::ECMAScript); \end{itemdecl} @@ -1549,7 +1549,7 @@ \indexlibrary{\idxcode{basic_regex}!constructor}% \begin{itemdecl} -template +template basic_regex(ForwardIterator first, ForwardIterator last, flag_type f = regex_constants::ECMAScript); \end{itemdecl} @@ -1637,7 +1637,7 @@ \indexlibrarymember{basic_regex}{operator=}% \begin{itemdecl} -template +template basic_regex& operator=(const basic_string& p); \end{itemdecl} @@ -1694,7 +1694,7 @@ \indexlibrarymember{basic_regex}{assign}% \begin{itemdecl} -template +template basic_regex& assign(const basic_string& s, flag_type f = regex_constants::ECMAScript); \end{itemdecl} @@ -1720,7 +1720,7 @@ \indexlibrarymember{basic_regex}{assign}% \begin{itemdecl} -template +template basic_regex& assign(InputIterator first, InputIterator last, flag_type f = regex_constants::ECMAScript); \end{itemdecl} @@ -1824,7 +1824,7 @@ \rSec3[re.regex.nmswap]{\tcode{basic_regex} non-member swap} \indexlibrarymember{basic_regex}{swap}% \begin{itemdecl} -template +template void swap(basic_regex& lhs, basic_regex& rhs); \end{itemdecl} @@ -1840,7 +1840,7 @@ \begin{codeblock} namespace std { - template + template class sub_match : public pair { public: using value_type = @@ -1937,7 +1937,7 @@ \indexlibrarymember{sub_match}{operator==}% \begin{itemdecl} -template +template bool operator==(const sub_match& lhs, const sub_match& rhs); \end{itemdecl} @@ -1947,7 +1947,7 @@ \indexlibrarymember{sub_match}{operator"!=}% \begin{itemdecl} -template +template bool operator!=(const sub_match& lhs, const sub_match& rhs); \end{itemdecl} @@ -1957,7 +1957,7 @@ \indexlibrarymember{sub_match}{operator<}% \begin{itemdecl} -template +template bool operator<(const sub_match& lhs, const sub_match& rhs); \end{itemdecl} @@ -1967,7 +1967,7 @@ \indexlibrarymember{sub_match}{operator<=}% \begin{itemdecl} -template +template bool operator<=(const sub_match& lhs, const sub_match& rhs); \end{itemdecl} @@ -1977,7 +1977,7 @@ \indexlibrarymember{sub_match}{operator>=}% \begin{itemdecl} -template +template bool operator>=(const sub_match& lhs, const sub_match& rhs); \end{itemdecl} @@ -1987,7 +1987,7 @@ \indexlibrarymember{sub_match}{operator>}% \begin{itemdecl} -template +template bool operator>(const sub_match& lhs, const sub_match& rhs); \end{itemdecl} @@ -1997,7 +1997,7 @@ \indexlibrarymember{sub_match}{operator==}% \begin{itemdecl} -template +template bool operator==( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); @@ -2013,7 +2013,7 @@ \indexlibrarymember{sub_match}{operator"!=}% \begin{itemdecl} -template +template bool operator!=( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); @@ -2025,7 +2025,7 @@ \indexlibrarymember{sub_match}{operator<}% \begin{itemdecl} -template +template bool operator<( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); @@ -2041,7 +2041,7 @@ \indexlibrarymember{sub_match}{operator>}% \begin{itemdecl} -template +template bool operator>( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); @@ -2053,7 +2053,7 @@ \indexlibrarymember{sub_match}{operator>=}% \begin{itemdecl} -template +template bool operator>=( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); @@ -2065,7 +2065,7 @@ \indexlibrarymember{sub_match}{operator<=}% \begin{itemdecl} -template +template bool operator<=( const basic_string::value_type, ST, SA>& lhs, const sub_match& rhs); @@ -2077,7 +2077,7 @@ \indexlibrarymember{operator==}{sub_match}% \begin{itemdecl} -template +template bool operator==( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); @@ -2094,7 +2094,7 @@ \indexlibrary{\idxcode{operator"!=}!\idxcode{sub_match}}% \indexlibrary{\idxcode{sub_match}!\idxcode{operator"!=}}% \begin{itemdecl} -template +template bool operator!=( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); @@ -2107,7 +2107,7 @@ \indexlibrary{\idxcode{operator>}!\idxcode{sub_match}}% \indexlibrary{\idxcode{sub_match}!\idxcode{operator<}}% \begin{itemdecl} -template +template bool operator<( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); @@ -2123,7 +2123,7 @@ \indexlibrarymember{operator>}{sub_match}% \begin{itemdecl} -template +template bool operator>( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); @@ -2135,7 +2135,7 @@ \indexlibrarymember{operator>=}{sub_match}% \begin{itemdecl} -template +template bool operator>=( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); @@ -2147,7 +2147,7 @@ \indexlibrarymember{operator<=}{sub_match}% \begin{itemdecl} -template +template bool operator<=( const sub_match& lhs, const basic_string::value_type, ST, SA>& rhs); @@ -2159,7 +2159,7 @@ \indexlibrarymember{sub_match}{operator==}% \begin{itemdecl} -template +template bool operator==(const typename iterator_traits::value_type* lhs, const sub_match& rhs); \end{itemdecl} @@ -2170,7 +2170,7 @@ \indexlibrarymember{sub_match}{operator"!=}% \begin{itemdecl} -template +template bool operator!=(const typename iterator_traits::value_type* lhs, const sub_match& rhs); \end{itemdecl} @@ -2181,7 +2181,7 @@ \indexlibrarymember{sub_match}{operator<}% \begin{itemdecl} -template +template bool operator<(const typename iterator_traits::value_type* lhs, const sub_match& rhs); \end{itemdecl} @@ -2192,7 +2192,7 @@ \indexlibrarymember{sub_match}{operator>}% \begin{itemdecl} -template +template bool operator>(const typename iterator_traits::value_type* lhs, const sub_match& rhs); \end{itemdecl} @@ -2203,7 +2203,7 @@ \indexlibrarymember{sub_match}{operator>=}% \begin{itemdecl} -template +template bool operator>=(const typename iterator_traits::value_type* lhs, const sub_match& rhs); \end{itemdecl} @@ -2214,7 +2214,7 @@ \indexlibrarymember{sub_match}{operator<=}% \begin{itemdecl} -template +template bool operator<=(const typename iterator_traits::value_type* lhs, const sub_match& rhs); \end{itemdecl} @@ -2225,7 +2225,7 @@ \indexlibrarymember{sub_match}{operator==}% \begin{itemdecl} -template +template bool operator==(const sub_match& lhs, const typename iterator_traits::value_type* rhs); \end{itemdecl} @@ -2236,7 +2236,7 @@ \indexlibrarymember{sub_match}{operator"!=}% \begin{itemdecl} -template +template bool operator!=(const sub_match& lhs, const typename iterator_traits::value_type* rhs); \end{itemdecl} @@ -2247,7 +2247,7 @@ \indexlibrarymember{sub_match}{operator<}% \begin{itemdecl} -template +template bool operator<(const sub_match& lhs, const typename iterator_traits::value_type* rhs); \end{itemdecl} @@ -2258,7 +2258,7 @@ \indexlibrarymember{sub_match}{operator>}% \begin{itemdecl} -template +template bool operator>(const sub_match& lhs, const typename iterator_traits::value_type* rhs); \end{itemdecl} @@ -2269,7 +2269,7 @@ \indexlibrarymember{sub_match}{operator>=}% \begin{itemdecl} -template +template bool operator>=(const sub_match& lhs, const typename iterator_traits::value_type* rhs); \end{itemdecl} @@ -2280,7 +2280,7 @@ \indexlibrarymember{sub_match}{operator<=}% \begin{itemdecl} -template +template bool operator<=(const sub_match& lhs, const typename iterator_traits::value_type* rhs); \end{itemdecl} @@ -2292,7 +2292,7 @@ \indexlibrarymember{sub_match}{operator==}% \begin{itemdecl} -template +template bool operator==(const typename iterator_traits::value_type& lhs, const sub_match& rhs); \end{itemdecl} @@ -2304,7 +2304,7 @@ \indexlibrarymember{sub_match}{operator"!=}% \begin{itemdecl} -template +template bool operator!=(const typename iterator_traits::value_type& lhs, const sub_match& rhs); \end{itemdecl} @@ -2316,7 +2316,7 @@ \indexlibrarymember{sub_match}{operator<}% \begin{itemdecl} -template +template bool operator<(const typename iterator_traits::value_type& lhs, const sub_match& rhs); \end{itemdecl} @@ -2328,7 +2328,7 @@ \indexlibrarymember{sub_match}{operator>}% \begin{itemdecl} -template +template bool operator>(const typename iterator_traits::value_type& lhs, const sub_match& rhs); \end{itemdecl} @@ -2340,7 +2340,7 @@ \indexlibrarymember{sub_match}{operator>=}% \begin{itemdecl} -template +template bool operator>=(const typename iterator_traits::value_type& lhs, const sub_match& rhs); \end{itemdecl} @@ -2352,7 +2352,7 @@ \indexlibrarymember{sub_match}{operator<=}% \begin{itemdecl} -template +template bool operator<=(const typename iterator_traits::value_type& lhs, const sub_match& rhs); \end{itemdecl} @@ -2364,7 +2364,7 @@ \indexlibrarymember{sub_match}{operator==}% \begin{itemdecl} -template +template bool operator==(const sub_match& lhs, const typename iterator_traits::value_type& rhs); \end{itemdecl} @@ -2376,7 +2376,7 @@ \indexlibrarymember{sub_match}{operator"!=}% \begin{itemdecl} -template +template bool operator!=(const sub_match& lhs, const typename iterator_traits::value_type& rhs); \end{itemdecl} @@ -2388,7 +2388,7 @@ \indexlibrarymember{sub_match}{operator<}% \begin{itemdecl} -template +template bool operator<(const sub_match& lhs, const typename iterator_traits::value_type& rhs); \end{itemdecl} @@ -2400,7 +2400,7 @@ \indexlibrarymember{sub_match}{operator>}% \begin{itemdecl} -template +template bool operator>(const sub_match& lhs, const typename iterator_traits::value_type& rhs); \end{itemdecl} @@ -2412,7 +2412,7 @@ \indexlibrarymember{sub_match}{operator>=}% \begin{itemdecl} -template +template bool operator>=(const sub_match& lhs, const typename iterator_traits::value_type& rhs); \end{itemdecl} @@ -2424,7 +2424,7 @@ \indexlibrarymember{sub_match}{operator<=}% \begin{itemdecl} -template +template bool operator<=(const sub_match& lhs, const typename iterator_traits::value_type& rhs); \end{itemdecl} @@ -2437,7 +2437,7 @@ \indexlibrary{\idxcode{basic_ostream}}% \indexlibrarymember{sub_match}{operator<<}% \begin{itemdecl} -template +template basic_ostream& operator<<(basic_ostream& os, const sub_match& m); \end{itemdecl} @@ -2491,7 +2491,7 @@ \begin{codeblock} namespace std { - template >> class match_results { public: @@ -2538,12 +2538,12 @@ const_iterator cend() const; // \ref{re.results.form}, format - template + template OutputIter format(OutputIter out, const char_type* fmt_first, const char_type* fmt_last, regex_constants::match_flag_type flags = regex_constants::format_default) const; - template + template OutputIter format(OutputIter out, const basic_string& fmt, @@ -2814,7 +2814,7 @@ \indexlibrarymember{match_results}{format}% \begin{itemdecl} -template +template OutputIter format( OutputIter out, const char_type* fmt_first, const char_type* fmt_last, @@ -2840,7 +2840,7 @@ \indexlibrarymember{match_results}{format}% \begin{itemdecl} -template +template OutputIter format( OutputIter out, const basic_string& fmt, @@ -2857,7 +2857,7 @@ \indexlibrarymember{match_results}{format}% \begin{itemdecl} -template +template basic_string format( const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const; @@ -2934,7 +2934,7 @@ \indexlibrarymember{match_results}{swap}% \begin{itemdecl} -template +template void swap(match_results& m1, match_results& m2); \end{itemdecl} @@ -2945,7 +2945,7 @@ \indexlibrarymember{operator==}{match_results}% \begin{itemdecl} -template +template bool operator==(const match_results& m1, const match_results& m2); \end{itemdecl} @@ -2980,7 +2980,7 @@ \indexlibrary{\idxcode{operator"!=}!\idxcode{match_results}}% \indexlibrary{\idxcode{match_results}!\idxcode{operator"!=}}% \begin{itemdecl} -template +template bool operator!=(const match_results& m1, const match_results& m2); \end{itemdecl} @@ -3002,7 +3002,7 @@ \rSec2[re.alg.match]{\tcode{regex_match}} \indexlibrary{\idxcode{regex_match}}% \begin{itemdecl} -template +template bool regex_match(BidirectionalIterator first, BidirectionalIterator last, match_results& m, const basic_regex& e, @@ -3112,7 +3112,7 @@ \indexlibrary{\idxcode{regex_match}}% \begin{itemdecl} -template +template bool regex_match(BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3128,7 +3128,7 @@ \indexlibrary{\idxcode{regex_match}}% \begin{itemdecl} -template +template bool regex_match(const charT* str, match_results& m, const basic_regex& e, @@ -3142,7 +3142,7 @@ \indexlibrary{\idxcode{regex_match}}% \begin{itemdecl} -template +template bool regex_match(const basic_string& s, match_results::const_iterator, Allocator>& m, @@ -3157,7 +3157,7 @@ \indexlibrary{\idxcode{regex_match}}% \begin{itemdecl} -template +template bool regex_match(const charT* str, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3170,7 +3170,7 @@ \indexlibrary{\idxcode{regex_match}}% \begin{itemdecl} -template +template bool regex_match(const basic_string& s, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3185,7 +3185,7 @@ \indexlibrary{\idxcode{regex_search}}% \begin{itemdecl} -template +template bool regex_search(BidirectionalIterator first, BidirectionalIterator last, match_results& m, const basic_regex& e, @@ -3280,7 +3280,7 @@ \indexlibrary{\idxcode{regex_search}}% \begin{itemdecl} -template +template bool regex_search(const charT* str, match_results& m, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3293,7 +3293,7 @@ \indexlibrary{\idxcode{regex_search}}% \begin{itemdecl} -template +template bool regex_search(const basic_string& s, match_results::const_iterator, Allocator>& m, @@ -3308,7 +3308,7 @@ \indexlibrary{\idxcode{regex_search}}% \begin{itemdecl} -template +template bool regex_search(BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3323,7 +3323,7 @@ \indexlibrary{\idxcode{regex_search}}% \begin{itemdecl} -template +template bool regex_search(const charT* str, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3336,7 +3336,7 @@ \indexlibrary{\idxcode{regex_search}}% \begin{itemdecl} -template +template bool regex_search(const basic_string& s, const basic_regex& e, regex_constants::match_flag_type flags = regex_constants::match_default); @@ -3350,15 +3350,15 @@ \indexlibrary{\idxcode{regex_replace}}% \begin{itemdecl} -template +template OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); -template +template OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, @@ -3419,13 +3419,13 @@ \indexlibrary{\idxcode{regex_replace}}% \begin{itemdecl} -template +template basic_string regex_replace(const basic_string& s, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); -template +template basic_string regex_replace(const basic_string& s, const basic_regex& e, @@ -3446,13 +3446,13 @@ \indexlibrary{\idxcode{regex_replace}}% \begin{itemdecl} -template +template basic_string regex_replace(const charT* s, const basic_regex& e, const basic_string& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); -template +template basic_string regex_replace(const charT* s, const basic_regex& e, @@ -3503,7 +3503,7 @@ \begin{codeblock} namespace std { - template ::value_type, class traits = regex_traits> class regex_iterator { @@ -3764,7 +3764,7 @@ \begin{codeblock} namespace std { - template ::value_type, class traits = regex_traits> class regex_token_iterator { @@ -3792,7 +3792,7 @@ initializer_list submatches, regex_constants::match_flag_type m = regex_constants::match_default); - template + template regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, const int (&submatches)[N], @@ -3813,7 +3813,7 @@ initializer_list submatches, regex_constants::match_flag_type m = regex_constants::match_default) = delete; - template + template regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type&& re, const int (&submatches)[N], @@ -3889,7 +3889,7 @@ initializer_list submatches, regex_constants::match_flag_type m = regex_constants::match_default); -template +template regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, const int (&submatches)[N], diff --git a/source/strings.tex b/source/strings.tex index 01dce96b5f..d604e8e08c 100644 --- a/source/strings.tex +++ b/source/strings.tex @@ -796,7 +796,7 @@ template<> struct hash; namespace pmr { - template > + template> using basic_string = std::basic_string>; diff --git a/source/support.tex b/source/support.tex index 97d28746f4..6fd252196f 100644 --- a/source/support.tex +++ b/source/support.tex @@ -1642,7 +1642,7 @@ new_handler set_new_handler(new_handler new_p) noexcept; // \ref{ptr.launder}, pointer optimization barrier - template constexpr T* launder(T* p) noexcept; + template constexpr T* launder(T* p) noexcept; // \ref{hardware.interference}, hardware interference size static constexpr size_t hardware_destructive_interference_size = @\impdef{}@; @@ -2504,7 +2504,7 @@ \indexlibrary{\idxcode{launder}}% \begin{itemdecl} -template constexpr T* launder(T* p) noexcept; +template constexpr T* launder(T* p) noexcept; \end{itemdecl} \begin{itemdescr} @@ -2912,8 +2912,8 @@ [[noreturn]] void rethrow_exception(exception_ptr p); template exception_ptr make_exception_ptr(E e) noexcept; - template [[noreturn]] void throw_with_nested(T&& t); - template void rethrow_if_nested(const E& e); + template [[noreturn]] void throw_with_nested(T&& t); + template void rethrow_if_nested(const E& e); } \end{codeblock} @@ -3309,7 +3309,7 @@ }; template [[noreturn]] void throw_with_nested(T&& t); - template void rethrow_if_nested(const E& e); + template void rethrow_if_nested(const E& e); } \end{codeblock} @@ -3356,7 +3356,7 @@ \indexlibrarymember{throw_with_nested}{nested_exception}% \begin{itemdecl} -template [[noreturn]] void throw_with_nested(T&& t); +template [[noreturn]] void throw_with_nested(T&& t); \end{itemdecl} \begin{itemdescr} @@ -3378,7 +3378,7 @@ \indexlibrarymember{rethrow_if_nested}{nested_exception}% \begin{itemdecl} -template void rethrow_if_nested(const E& e); +template void rethrow_if_nested(const E& e); \end{itemdecl} \begin{itemdescr} diff --git a/source/threads.tex b/source/threads.tex index 601af31fbb..f72dc4cd38 100644 --- a/source/threads.tex +++ b/source/threads.tex @@ -277,7 +277,7 @@ result, where \tcode{decay_copy} is defined as follows: \begin{codeblock} -template decay_t decay_copy(T&& v) +template decay_t decay_copy(T&& v) { return std::forward(v); } \end{codeblock} @@ -302,9 +302,9 @@ thread::id get_id() noexcept; void yield() noexcept; - template + template void sleep_until(const chrono::time_point& abs_time); - template + template void sleep_for(const chrono::duration& rel_time); } } @@ -335,7 +335,7 @@ // construct/copy/destroy: thread() noexcept; - template explicit thread(F&& f, Args&&... args); + template explicit thread(F&& f, Args&&... args); ~thread(); thread(const thread&) = delete; thread(thread&&) noexcept; @@ -379,8 +379,8 @@ operator<< (basic_ostream& out, thread::id id); // Hash support - template struct hash; - template <> struct hash; + template struct hash; + template<> struct hash; } \end{codeblock} @@ -489,7 +489,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{thread::id}}% \begin{itemdecl} -template <> struct hash; +template<> struct hash; \end{itemdecl} \begin{itemdescr} @@ -511,7 +511,7 @@ \indexlibrary{\idxcode{thread}!constructor}% \begin{itemdecl} -template explicit thread(F&& f, Args&&... args); +template explicit thread(F&& f, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -732,9 +732,9 @@ thread::id get_id() noexcept; void yield() noexcept; - template + template void sleep_until(const chrono::time_point& abs_time); - template + template void sleep_for(const chrono::duration& rel_time); } \end{codeblock} @@ -767,7 +767,7 @@ \indexlibrarymember{sleep_until}{this_thread}% \begin{itemdecl} -template +template void sleep_until(const chrono::time_point& abs_time); \end{itemdecl} @@ -785,7 +785,7 @@ \indexlibrarymember{sleep_for}{this_thread}% \begin{itemdecl} -template +template void sleep_for(const chrono::duration& rel_time); \end{itemdecl} @@ -827,14 +827,14 @@ constexpr try_to_lock_t try_to_lock { }; constexpr adopt_lock_t adopt_lock { }; - template class lock_guard; - template class unique_lock; + template class lock_guard; + template class unique_lock; - template + template void swap(unique_lock& x, unique_lock& y) noexcept; - template int try_lock(L1&, L2&, L3&...); - template void lock(L1&, L2&, L3&...); + template int try_lock(L1&, L2&, L3&...); + template void lock(L1&, L2&, L3&...); struct once_flag; @@ -851,8 +851,8 @@ namespace std { class shared_mutex; class shared_timed_mutex; - template class shared_lock; - template + template class shared_lock; + template void swap(shared_lock& x, shared_lock& y) noexcept; } \end{codeblock} @@ -1210,9 +1210,9 @@ void lock(); // blocking bool try_lock(); - template + template bool try_lock_for(const chrono::duration& rel_time); - template + template bool try_lock_until(const chrono::time_point& abs_time); void unlock(); @@ -1261,9 +1261,9 @@ void lock(); // blocking bool try_lock() noexcept; - template + template bool try_lock_for(const chrono::duration& rel_time); - template + template bool try_lock_until(const chrono::time_point& abs_time); void unlock(); @@ -1566,19 +1566,19 @@ // Exclusive ownership void lock(); // blocking bool try_lock(); - template + template bool try_lock_for(const chrono::duration& rel_time); - template + template bool try_lock_until(const chrono::time_point& abs_time); void unlock(); // Shared ownership void lock_shared(); // blocking bool try_lock_shared(); - template + template bool try_lock_shared_for(const chrono::duration& rel_time); - template + template bool try_lock_shared_until(const chrono::time_point& abs_time); void unlock_shared(); @@ -1643,7 +1643,7 @@ \indexlibrary{\idxcode{lock_guard}}% \begin{codeblock} namespace std { - template + template class lock_guard { public: using mutex_type = Mutex; // If \tcode{MutexTypes...} consists of the single type \tcode{Mutex} @@ -1723,7 +1723,7 @@ \indexlibrary{\idxcode{unique_lock}}% \begin{codeblock} namespace std { - template + template class unique_lock { public: using mutex_type = Mutex; @@ -1734,9 +1734,9 @@ unique_lock(mutex_type& m, defer_lock_t) noexcept; unique_lock(mutex_type& m, try_to_lock_t); unique_lock(mutex_type& m, adopt_lock_t); - template + template unique_lock(mutex_type& m, const chrono::time_point& abs_time); - template + template unique_lock(mutex_type& m, const chrono::duration& rel_time); ~unique_lock(); @@ -1750,9 +1750,9 @@ void lock(); bool try_lock(); - template + template bool try_lock_for(const chrono::duration& rel_time); - template + template bool try_lock_until(const chrono::time_point& abs_time); void unlock(); @@ -1771,7 +1771,7 @@ bool owns; // \expos }; - template + template void swap(unique_lock& x, unique_lock& y) noexcept; } \end{codeblock} @@ -1881,7 +1881,7 @@ \indexlibrary{\idxcode{unique_lock}!constructor}% \begin{itemdecl} -template +template unique_lock(mutex_type& m, const chrono::time_point& abs_time); \end{itemdecl} @@ -1902,7 +1902,7 @@ \indexlibrary{\idxcode{unique_lock}!constructor}% \begin{itemdecl} -template +template unique_lock(mutex_type& m, const chrono::duration& rel_time); \end{itemdecl} @@ -2017,7 +2017,7 @@ \indexlibrarymember{try_lock_until}{unique_lock}% \begin{itemdecl} -template +template bool try_lock_until(const chrono::time_point& abs_time); \end{itemdecl} @@ -2051,7 +2051,7 @@ \indexlibrarymember{try_lock_for}{unique_lock}% \begin{itemdecl} -template +template bool try_lock_for(const chrono::duration& rel_time); \end{itemdecl} @@ -2124,7 +2124,7 @@ \indexlibrarymember{swap}{unique_lock}% \begin{itemdecl} -template +template void swap(unique_lock& x, unique_lock& y) noexcept; \end{itemdecl} @@ -2166,7 +2166,7 @@ \indexlibrary{\idxcode{shared_lock}}% \begin{codeblock} namespace std { - template + template class shared_lock { public: using mutex_type = Mutex; @@ -2177,10 +2177,10 @@ shared_lock(mutex_type& m, defer_lock_t) noexcept; shared_lock(mutex_type& m, try_to_lock_t); shared_lock(mutex_type& m, adopt_lock_t); - template + template shared_lock(mutex_type& m, const chrono::time_point& abs_time); - template + template shared_lock(mutex_type& m, const chrono::duration& rel_time); ~shared_lock(); @@ -2194,9 +2194,9 @@ // \ref{thread.lock.shared.locking}, locking void lock(); // blocking bool try_lock(); - template + template bool try_lock_for(const chrono::duration& rel_time); - template + template bool try_lock_until(const chrono::time_point& abs_time); void unlock(); @@ -2214,7 +2214,7 @@ bool owns; // \expos }; - template + template void swap(shared_lock& x, shared_lock& y) noexcept; } \end{codeblock} @@ -2315,7 +2315,7 @@ \indexlibrary{\idxcode{shared_lock}!constructor}% \begin{itemdecl} -template +template shared_lock(mutex_type& m, const chrono::time_point& abs_time); \end{itemdecl} @@ -2336,7 +2336,7 @@ \indexlibrary{\idxcode{shared_lock}!constructor}% \begin{itemdecl} -template +template shared_lock(mutex_type& m, const chrono::duration& rel_time); \end{itemdecl} @@ -2450,7 +2450,7 @@ \indexlibrarymember{try_lock_until}{shared_lock}% \begin{itemdecl} -template +template bool try_lock_until(const chrono::time_point& abs_time); \end{itemdecl} @@ -2482,7 +2482,7 @@ \indexlibrarymember{try_lock_for}{shared_lock}% \begin{itemdecl} -template +template bool try_lock_for(const chrono::duration& rel_time); \end{itemdecl} @@ -2558,7 +2558,7 @@ \indexlibrarymember{swap}{shared_lock}% \begin{itemdecl} -template +template void swap(shared_lock& x, shared_lock& y) noexcept; \end{itemdecl} @@ -2603,7 +2603,7 @@ \indexlibrary{\idxcode{try_lock}}% \begin{itemdecl} -template int try_lock(L1&, L2&, L3&...); +template int try_lock(L1&, L2&, L3&...); \end{itemdecl} \begin{itemdescr} @@ -2627,7 +2627,7 @@ \indexlibrary{\idxcode{lock}}% \begin{itemdecl} -template void lock(L1&, L2&, L3&...); +template void lock(L1&, L2&, L3&...); \end{itemdecl} \begin{itemdescr} @@ -2873,20 +2873,20 @@ void notify_one() noexcept; void notify_all() noexcept; void wait(unique_lock& lock); - template + template void wait(unique_lock& lock, Predicate pred); - template + template cv_status wait_until(unique_lock& lock, const chrono::time_point& abs_time); - template + template bool wait_until(unique_lock& lock, const chrono::time_point& abs_time, Predicate pred); - template + template cv_status wait_for(unique_lock& lock, const chrono::duration& rel_time); - template + template bool wait_for(unique_lock& lock, const chrono::duration& rel_time, Predicate pred); @@ -2998,7 +2998,7 @@ \indexlibrarymember{wait}{condition_variable}% \begin{itemdecl} -template +template void wait(unique_lock& lock, Predicate pred); \end{itemdecl} @@ -3038,7 +3038,7 @@ \indexlibrarymember{wait_until}{condition_variable}% \begin{itemdecl} -template +template cv_status wait_until(unique_lock& lock, const chrono::time_point& abs_time); \end{itemdecl} @@ -3094,7 +3094,7 @@ \indexlibrarymember{wait_for}{condition_variable}% \begin{itemdecl} -template +template cv_status wait_for(unique_lock& lock, const chrono::duration& rel_time); \end{itemdecl} @@ -3139,7 +3139,7 @@ \indexlibrarymember{wait_until}{condition_variable}% \begin{itemdecl} -template +template bool wait_until(unique_lock& lock, const chrono::time_point& abs_time, Predicate pred); @@ -3188,7 +3188,7 @@ \indexlibrarymember{wait_for}{condition_variable}% \begin{itemdecl} -template +template bool wait_for(unique_lock& lock, const chrono::duration& rel_time, Predicate pred); @@ -3262,19 +3262,19 @@ void notify_one() noexcept; void notify_all() noexcept; - template + template void wait(Lock& lock); - template + template void wait(Lock& lock, Predicate pred); - template + template cv_status wait_until(Lock& lock, const chrono::time_point& abs_time); - template + template bool wait_until(Lock& lock, const chrono::time_point& abs_time, Predicate pred); - template + template cv_status wait_for(Lock& lock, const chrono::duration& rel_time); - template + template bool wait_for(Lock& lock, const chrono::duration& rel_time, Predicate pred); }; @@ -3345,7 +3345,7 @@ \indexlibrarymember{wait}{condition_variable_any}% \begin{itemdecl} -template +template void wait(Lock& lock); \end{itemdecl} @@ -3380,7 +3380,7 @@ \indexlibrarymember{wait}{condition_variable_any}% \begin{itemdecl} -template +template void wait(Lock& lock, Predicate pred); \end{itemdecl} @@ -3395,7 +3395,7 @@ \indexlibrarymember{wait_until}{condition_variable_any}% \begin{itemdecl} -template +template cv_status wait_until(Lock& lock, const chrono::time_point& abs_time); \end{itemdecl} @@ -3440,7 +3440,7 @@ \indexlibrarymember{wait_for}{condition_variable_any}% \begin{itemdecl} -template +template cv_status wait_for(Lock& lock, const chrono::duration& rel_time); \end{itemdecl} @@ -3473,7 +3473,7 @@ \indexlibrarymember{wait_until}{condition_variable_any}% \begin{itemdecl} -template +template bool wait_until(Lock& lock, const chrono::time_point& abs_time, Predicate pred); \end{itemdecl} @@ -3498,7 +3498,7 @@ \indexlibrarymember{wait_for}{condition_variable_any}% \begin{itemdecl} -template +template bool wait_for(Lock& lock, const chrono::duration& rel_time, Predicate pred); \end{itemdecl} @@ -3546,7 +3546,7 @@ deferred }; - template <> struct is_error_code_enum : public true_type { }; + template<> struct is_error_code_enum : public true_type { }; error_code make_error_code(future_errc e) noexcept; error_condition make_error_condition(future_errc e) noexcept; @@ -3554,38 +3554,38 @@ class future_error; - template class promise; - template class promise; - template <> class promise; + template class promise; + template class promise; + template<> class promise; - template + template void swap(promise& x, promise& y) noexcept; - template + template struct uses_allocator, Alloc>; - template class future; - template class future; - template <> class future; + template class future; + template class future; + template<> class future; - template class shared_future; - template class shared_future; - template <> class shared_future; + template class shared_future; + template class shared_future; + template<> class shared_future; - template class packaged_task; // not defined - template + template class packaged_task; // not defined + template class packaged_task; - template + template void swap(packaged_task&, packaged_task&) noexcept; - template + template struct uses_allocator, Alloc>; - template + template future(decay_t...)>> async(F&& f, Args&&... args); - template + template future(decay_t...)>> async(launch policy, F&& f, Args&&... args); } @@ -3805,11 +3805,11 @@ \indexlibrary{\idxcode{promise}}% \begin{codeblock} namespace std { - template + template class promise { public: promise(); - template + template promise(allocator_arg_t, const Allocator& a); promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; @@ -3831,9 +3831,9 @@ void set_value_at_thread_exit(@\seebelow@); void set_exception_at_thread_exit(exception_ptr p); }; - template + template void swap(promise& x, promise& y) noexcept; - template + template struct uses_allocator, Alloc>; } \end{codeblock} @@ -3852,7 +3852,7 @@ \indexlibrary{\idxcode{uses_allocator}!\idxcode{promise}}% \begin{itemdecl} -template +template struct uses_allocator, Alloc> : true_type { }; \end{itemdecl} @@ -3866,7 +3866,7 @@ \indexlibrary{\idxcode{promise}!constructor}% \begin{itemdecl} promise(); -template +template promise(allocator_arg_t, const Allocator& a); \end{itemdecl} @@ -4080,7 +4080,7 @@ \indexlibrarymember{swap}{promise}% \begin{itemdecl} -template +template void swap(promise& x, promise& y) noexcept; \end{itemdecl} @@ -4123,7 +4123,7 @@ \indexlibrary{\idxcode{future}}% \begin{codeblock} namespace std { - template + template class future { public: future() noexcept; @@ -4141,9 +4141,9 @@ bool valid() const noexcept; void wait() const; - template + template future_status wait_for(const chrono::duration& rel_time) const; - template + template future_status wait_until(const chrono::time_point& abs_time) const; }; } @@ -4311,7 +4311,7 @@ \indexlibrarymember{wait_for}{future}% \begin{itemdecl} -template +template future_status wait_for(const chrono::duration& rel_time) const; \end{itemdecl} @@ -4344,7 +4344,7 @@ \indexlibrarymember{wait_until}{future}% \begin{itemdecl} -template +template future_status wait_until(const chrono::time_point& abs_time) const; \end{itemdecl} @@ -4408,7 +4408,7 @@ \indexlibrary{\idxcode{shared_future}}% \begin{codeblock} namespace std { - template + template class shared_future { public: shared_future() noexcept; @@ -4426,9 +4426,9 @@ bool valid() const noexcept; void wait() const; - template + template future_status wait_for(const chrono::duration& rel_time) const; - template + template future_status wait_until(const chrono::time_point& abs_time) const; }; } @@ -4624,7 +4624,7 @@ \indexlibrarymember{wait_for}{shared_future}% \begin{itemdecl} -template +template future_status wait_for(const chrono::duration& rel_time) const; \end{itemdecl} @@ -4658,7 +4658,7 @@ \indexlibrarymember{wait_until}{shared_future}% \begin{itemdecl} -template +template future_status wait_until(const chrono::time_point& abs_time) const; \end{itemdecl} @@ -4699,9 +4699,9 @@ \indexlibrary{\idxcode{async}}% \begin{itemdecl} -template +template future(decay_t...)>> async(F&& f, Args&&... args); -template +template future(decay_t...)>> async(launch policy, F&& f, Args&&... args); \end{itemdecl} @@ -4884,9 +4884,9 @@ public: // construction and destruction packaged_task() noexcept; - template + template explicit packaged_task(F&& f); - template + template packaged_task(allocator_arg_t, const Allocator& a, F&& f); ~packaged_task(); @@ -4910,9 +4910,9 @@ void reset(); }; - template + template void swap(packaged_task& x, packaged_task& y) noexcept; - template + template struct uses_allocator, Alloc>; } \end{codeblock} @@ -4931,9 +4931,9 @@ \indexlibrary{\idxcode{packaged_task}!constructor}% \begin{itemdecl} -template +template packaged_task(F&& f); -template +template packaged_task(allocator_arg_t, const Allocator& a, F&& f); \end{itemdecl} @@ -5143,7 +5143,7 @@ \indexlibrarymember{swap}{packaged_task}% \begin{itemdecl} -template +template void swap(packaged_task& x, packaged_task& y) noexcept; \end{itemdecl} @@ -5154,7 +5154,7 @@ \indexlibrary{\idxcode{uses_allocator}!\idxcode{packaged_task}}% \begin{itemdecl} -template +template struct uses_allocator, Alloc> : true_type { }; \end{itemdecl} diff --git a/source/utilities.tex b/source/utilities.tex index 54c3ad47fd..974188aa02 100644 --- a/source/utilities.tex +++ b/source/utilities.tex @@ -55,35 +55,35 @@ } // \ref{utility.swap}, swap - template + template void swap(T& a, T& b) noexcept(@\seebelow@); - template + template void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v); // \ref{utility.exchange}, exchange - template + template T exchange(T& obj, U&& new_val); // \ref{forward}, forward/move - template + template constexpr T&& forward(remove_reference_t& t) noexcept; - template + template constexpr T&& forward(remove_reference_t&& t) noexcept; - template + template constexpr remove_reference_t&& move(T&&) noexcept; - template + template constexpr conditional_t< !is_nothrow_move_constructible_v && is_copy_constructible_v, const T&, T&&> move_if_noexcept(T& x) noexcept; // \ref{utility.as_const}, \tcode{as_const} - template + template constexpr add_const_t& as_const(T& t) noexcept; - template + template void as_const(const T&&) = delete; // \ref{declval}, declval - template + template add_rvalue_reference_t declval() noexcept; // as unevaluated operand @% \indexlibrary{\idxcode{index_sequence}}% @@ -105,36 +105,36 @@ using index_sequence_for = make_index_sequence; // \ref{pairs}, class template \tcode{pair} - template + template struct pair; // \ref{pairs.spec}, pair specialized algorithms - template + template constexpr bool operator==(const pair&, const pair&); - template + template constexpr bool operator< (const pair&, const pair&); - template + template constexpr bool operator!=(const pair&, const pair&); - template + template constexpr bool operator> (const pair&, const pair&); - template + template constexpr bool operator>=(const pair&, const pair&); - template + template constexpr bool operator<=(const pair&, const pair&); - template + template void swap(pair& x, pair& y) noexcept(noexcept(x.swap(y))); - template + template constexpr @\seebelow@ make_pair(T1&&, T2&&); // \ref{pair.astuple}, tuple-like access to pair - template class tuple_size; - template class tuple_element; + template class tuple_size; + template class tuple_element; - template struct tuple_size>; - template struct tuple_element<0, pair>; - template struct tuple_element<1, pair>; + template struct tuple_size>; + template struct tuple_element<0, pair>; + template struct tuple_element<1, pair>; template constexpr tuple_element_t>& get(pair&) noexcept; @@ -144,21 +144,21 @@ constexpr const tuple_element_t>& get(const pair&) noexcept; template constexpr const tuple_element_t>&& get(const pair&&) noexcept; - template + template constexpr T1& get(pair& p) noexcept; - template + template constexpr const T1& get(const pair& p) noexcept; - template + template constexpr T1&& get(pair&& p) noexcept; - template + template constexpr const T1&& get(const pair&& p) noexcept; - template + template constexpr T2& get(pair& p) noexcept; - template + template constexpr const T2& get(const pair& p) noexcept; - template + template constexpr T2&& get(pair&& p) noexcept; - template + template constexpr const T2&& get(const pair&& p) noexcept; // \ref{pair.piecewise}, pair piecewise construction @@ -166,23 +166,23 @@ explicit piecewise_construct_t() = default; }; constexpr piecewise_construct_t piecewise_construct{}; - template class tuple; // defined in \tcode{} (\ref{tuple.syn}) + template class tuple; // defined in \tcode{} (\ref{tuple.syn}) // in-place construction struct in_place_t { explicit in_place_t() = default; }; inline constexpr in_place_t in_place{}; - template + template struct in_place_type_t { explicit in_place_type_t() = default; }; - template inline constexpr in_place_type_t in_place_type{}; - template + template inline constexpr in_place_type_t in_place_type{}; + template struct in_place_index_t { explicit in_place_index_t() = default; }; - template inline constexpr in_place_index_t in_place_index{}; + template inline constexpr in_place_index_t in_place_index{}; @ \indexlibrary{\idxcode{chars_format}}% \indexlibrarymember{scientific}{chars_format}% @@ -272,7 +272,7 @@ \indexlibrary{\idxcode{operator"!=}}% \begin{itemdecl} -template bool operator!=(const T& x, const T& y); +template bool operator!=(const T& x, const T& y); \end{itemdecl} \begin{itemdescr} @@ -287,7 +287,7 @@ \indexlibrary{\idxcode{operator>}}% \begin{itemdecl} -template bool operator>(const T& x, const T& y); +template bool operator>(const T& x, const T& y); \end{itemdecl} \begin{itemdescr} @@ -302,7 +302,7 @@ \indexlibrary{\idxcode{operator<=}}% \begin{itemdecl} -template bool operator<=(const T& x, const T& y); +template bool operator<=(const T& x, const T& y); \end{itemdecl} \begin{itemdescr} @@ -317,7 +317,7 @@ \indexlibrary{\idxcode{operator>=}}% \begin{itemdecl} -template bool operator>=(const T& x, const T& y); +template bool operator>=(const T& x, const T& y); \end{itemdecl} \begin{itemdescr} @@ -340,7 +340,7 @@ \indexlibrary{\idxcode{swap}}% \begin{itemdecl} -template +template void swap(T& a, T& b) noexcept(@\seebelow@); \end{itemdecl} @@ -371,7 +371,7 @@ \indexlibrary{\idxcode{swap}}% \begin{itemdecl} -template +template void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v); \end{itemdecl} @@ -394,7 +394,7 @@ \indexlibrary{\idxcode{exchange}}% \begin{itemdecl} -template T exchange(T& obj, U&& new_val); +template T exchange(T& obj, U&& new_val); \end{itemdecl} \begin{itemdescr} @@ -418,8 +418,8 @@ \indexlibrary{\idxcode{forward}}% \begin{itemdecl} -template constexpr T&& forward(remove_reference_t& t) noexcept; -template constexpr T&& forward(remove_reference_t&& t) noexcept; +template constexpr T&& forward(remove_reference_t& t) noexcept; +template constexpr T&& forward(remove_reference_t&& t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -432,7 +432,7 @@ \pnum \begin{example} \begin{codeblock} -template +template shared_ptr factory(A1&& a1, A2&& a2) { return shared_ptr(new T(std::forward(a1), std::forward(a2))); } @@ -460,7 +460,7 @@ \indexlibrary{\idxcode{move}!function}% \begin{itemdecl} -template constexpr remove_reference_t&& move(T&& t) noexcept; +template constexpr remove_reference_t&& move(T&& t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -471,7 +471,7 @@ \pnum \begin{example} \begin{codeblock} -template +template shared_ptr factory(A1&& a1) { return shared_ptr(new T(std::forward(a1))); } @@ -502,7 +502,7 @@ \indexlibrary{\idxcode{move_if_noexcept}}% \begin{itemdecl} -template constexpr conditional_t< +template constexpr conditional_t< !is_nothrow_move_constructible_v && is_copy_constructible_v, const T&, T&&> move_if_noexcept(T& x) noexcept; \end{itemdecl} @@ -516,7 +516,7 @@ \indexlibrary{\idxcode{as_const}}% \begin{itemdecl} -template constexpr add_const_t& as_const(T& t) noexcept; +template constexpr add_const_t& as_const(T& t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -532,7 +532,7 @@ \indexlibrary{\idxcode{declval}}% \begin{itemdecl} -template add_rvalue_reference_t declval() noexcept; // as unevaluated operand +template add_rvalue_reference_t declval() noexcept; // as unevaluated operand \end{itemdecl} \begin{itemdescr} @@ -546,7 +546,7 @@ \pnum \begin{example} \begin{codeblock} -template decltype(static_cast(declval())) convert(From&&); +template decltype(static_cast(declval())) convert(From&&); \end{codeblock} declares a function template \tcode{convert} which only participates in overloading if the type \tcode{From} can be explicitly converted to type \tcode{To}. For another example see class @@ -880,7 +880,7 @@ \indexlibrary{\idxcode{pair}}% \begin{codeblock} namespace std { - template + template struct pair { using first_type = T1; using second_type = T2; @@ -895,7 +895,7 @@ template @\EXPLICIT@ constexpr pair(U1&& x, U2&& y); template @\EXPLICIT@ constexpr pair(const pair& p); template @\EXPLICIT@ constexpr pair(pair&& p); - template + template pair(piecewise_construct_t, tuple first_args, tuple second_args); pair& operator=(const pair& p); @@ -1156,7 +1156,7 @@ \indexlibrarymember{operator==}{pair}% \begin{itemdecl} -template +template constexpr bool operator==(const pair& x, const pair& y); \end{itemdecl} @@ -1168,7 +1168,7 @@ \indexlibrarymember{operator<}{pair}% \begin{itemdecl} -template +template constexpr bool operator<(const pair& x, const pair& y); \end{itemdecl} @@ -1180,7 +1180,7 @@ \indexlibrarymember{operator"!=}{pair}% \begin{itemdecl} -template +template constexpr bool operator!=(const pair& x, const pair& y); \end{itemdecl} @@ -1191,7 +1191,7 @@ \indexlibrarymember{operator>}{pair}% \begin{itemdecl} -template +template constexpr bool operator>(const pair& x, const pair& y); \end{itemdecl} @@ -1202,7 +1202,7 @@ \indexlibrarymember{operator>=}{pair}% \begin{itemdecl} -template +template constexpr bool operator>=(const pair& x, const pair& y); \end{itemdecl} @@ -1213,7 +1213,7 @@ \indexlibrarymember{operator<=}{pair}% \begin{itemdecl} -template +template constexpr bool operator<=(const pair& x, const pair& y); \end{itemdecl} @@ -1242,7 +1242,7 @@ \indexlibrary{\idxcode{make_pair}}% \begin{itemdecl} -template +template constexpr pair make_pair(T1&& x, T2&& y); \end{itemdecl} @@ -1271,7 +1271,7 @@ \indexlibrary{\idxcode{tuple_size}}% \begin{itemdecl} -template +template struct tuple_size> : integral_constant { }; \end{itemdecl} @@ -1312,13 +1312,13 @@ \indexlibrarymember{get}{pair}% \begin{itemdecl} -template +template constexpr T1& get(pair& p) noexcept; -template +template constexpr const T1& get(const pair& p) noexcept; -template +template constexpr T1&& get(pair&& p) noexcept; -template +template constexpr const T1&& get(const pair&& p) noexcept; \end{itemdecl} \begin{itemdescr} @@ -1331,13 +1331,13 @@ \indexlibrarymember{get}{pair}% \begin{itemdecl} -template +template constexpr T2& get(pair& p) noexcept; -template +template constexpr const T2& get(const pair& p) noexcept; -template +template constexpr T2&& get(pair&& p) noexcept; -template +template constexpr const T2&& get(const pair&& p) noexcept; \end{itemdecl} \begin{itemdescr} @@ -1388,66 +1388,66 @@ \begin{codeblock} namespace std { // \ref{tuple.tuple}, class template \tcode{tuple} - template + template class tuple; // \ref{tuple.creation}, tuple creation functions constexpr @\unspec@ ignore; - template + template constexpr tuple make_tuple(TTypes&&...); - template + template constexpr tuple forward_as_tuple(TTypes&&...) noexcept; template constexpr tuple tie(TTypes&...) noexcept; - template + template constexpr tuple tuple_cat(Tuples&&...); // \ref{tuple.apply}, calling a function with a tuple of arguments - template + template constexpr decltype(auto) apply(F&& f, Tuple&& t); - template + template constexpr T make_from_tuple(Tuple&& t); // \ref{tuple.helper}, tuple helper classes - template class tuple_size; // not defined - template class tuple_size; - template class tuple_size; - template class tuple_size; + template class tuple_size; // not defined + template class tuple_size; + template class tuple_size; + template class tuple_size; - template class tuple_size>; + template class tuple_size>; - template class tuple_element; // not defined - template class tuple_element; - template class tuple_element; - template class tuple_element; + template class tuple_element; // not defined + template class tuple_element; + template class tuple_element; + template class tuple_element; - template + template class tuple_element>; - template + template using tuple_element_t = typename tuple_element::type; // \ref{tuple.elem}, element access - template + template constexpr tuple_element_t>& get(tuple&) noexcept; - template + template constexpr tuple_element_t>&& get(tuple&&) noexcept; - template + template constexpr const tuple_element_t>& get(const tuple&) noexcept; - template + template constexpr const tuple_element_t>&& get(const tuple&&) noexcept; - template + template constexpr T& get(tuple& t) noexcept; - template + template constexpr T&& get(tuple&& t) noexcept; - template + template constexpr const T& get(const tuple& t) noexcept; - template + template constexpr const T&& get(const tuple&& t) noexcept; // \ref{tuple.rel}, relational operators @@ -1465,15 +1465,15 @@ constexpr bool operator>=(const tuple&, const tuple&); // \ref{tuple.traits}, allocator-related traits - template + template struct uses_allocator, Alloc>; // \ref{tuple.special}, specialized algorithms - template + template void swap(tuple& x, tuple& y) noexcept(@\seebelow@); // \ref{tuple.helper}, tuple helper classes - template + template constexpr size_t tuple_size_v = tuple_size::value; } \end{codeblock} @@ -1483,60 +1483,60 @@ \begin{codeblock} namespace std { - template + template class tuple { public: // \ref{tuple.cnstr}, \tcode{tuple} construction @\EXPLICIT@ constexpr tuple(); @\EXPLICIT@ constexpr tuple(const Types&...); // only if \tcode{sizeof...(Types) >= 1} - template + template @\EXPLICIT@ constexpr tuple(UTypes&&...); // only if \tcode{sizeof...(Types) >= 1} tuple(const tuple&) = default; tuple(tuple&&) = default; - template + template @\EXPLICIT@ constexpr tuple(const tuple&); - template + template @\EXPLICIT@ constexpr tuple(tuple&&); - template + template @\EXPLICIT@ constexpr tuple(const pair&); // only if \tcode{sizeof...(Types) == 2} - template + template @\EXPLICIT@ constexpr tuple(pair&&); // only if \tcode{sizeof...(Types) == 2} // allocator-extended constructors - template + template tuple(allocator_arg_t, const Alloc& a); - template + template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, const Types&...); - template + template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, UTypes&&...); - template + template tuple(allocator_arg_t, const Alloc& a, const tuple&); - template + template tuple(allocator_arg_t, const Alloc& a, tuple&&); - template + template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, const tuple&); - template + template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, tuple&&); - template + template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, const pair&); - template + template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, pair&&); // \ref{tuple.assign}, \tcode{tuple} assignment tuple& operator=(const tuple&); tuple& operator=(tuple&&) noexcept(@\seebelow@); - template + template tuple& operator=(const tuple&); - template + template tuple& operator=(tuple&&); - template + template tuple& operator=(const pair&); // only if \tcode{sizeof...(Types) == 2} - template + template tuple& operator=(pair&&); // only if \tcode{sizeof...(Types) == 2} // \ref{tuple.swap}, \tcode{tuple} swap @@ -1607,7 +1607,7 @@ \indexlibrary{\idxcode{tuple}!constructor}% \begin{itemdecl} -template @\EXPLICIT@ constexpr tuple(UTypes&&... u); +template @\EXPLICIT@ constexpr tuple(UTypes&&... u); \end{itemdecl} \begin{itemdescr} @@ -1654,7 +1654,7 @@ \indexlibrary{\idxcode{tuple}!constructor}% \begin{itemdecl} -template @\EXPLICIT@ constexpr tuple(const tuple& u); +template @\EXPLICIT@ constexpr tuple(const tuple& u); \end{itemdecl} \begin{itemdescr} @@ -1682,7 +1682,7 @@ \indexlibrary{\idxcode{tuple}!constructor}% \begin{itemdecl} -template @\EXPLICIT@ constexpr tuple(tuple&& u); +template @\EXPLICIT@ constexpr tuple(tuple&& u); \end{itemdecl} \begin{itemdescr} @@ -1713,7 +1713,7 @@ \indexlibrary{\idxcode{tuple}!constructor}% \indexlibrary{\idxcode{pair}}% \begin{itemdecl} -template @\EXPLICIT@ constexpr tuple(const pair& u); +template @\EXPLICIT@ constexpr tuple(const pair& u); \end{itemdecl} \begin{itemdescr} @@ -1736,7 +1736,7 @@ \indexlibrary{\idxcode{tuple}!constructor}% \indexlibrary{\idxcode{pair}}% \begin{itemdecl} -template @\EXPLICIT@ constexpr tuple(pair&& u); +template @\EXPLICIT@ constexpr tuple(pair&& u); \end{itemdecl} \begin{itemdescr} @@ -1759,23 +1759,23 @@ \indexlibrary{\idxcode{tuple}!constructor}% \begin{itemdecl} -template +template tuple(allocator_arg_t, const Alloc& a); -template +template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, const Types&...); -template +template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, UTypes&&...); -template +template tuple(allocator_arg_t, const Alloc& a, const tuple&); -template +template tuple(allocator_arg_t, const Alloc& a, tuple&&); -template +template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, const tuple&); -template +template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, tuple&&); -template +template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, const pair&); -template +template @\EXPLICIT@ tuple(allocator_arg_t, const Alloc& a, pair&&); \end{itemdecl} @@ -1846,7 +1846,7 @@ \indexlibrarymember{operator=}{tuple}% \begin{itemdecl} -template tuple& operator=(const tuple& u); +template tuple& operator=(const tuple& u); \end{itemdecl} \begin{itemdescr} @@ -1865,7 +1865,7 @@ \indexlibrarymember{operator=}{tuple}% \begin{itemdecl} -template tuple& operator=(tuple&& u); +template tuple& operator=(tuple&& u); \end{itemdecl} \begin{itemdescr} @@ -1885,7 +1885,7 @@ \indexlibrarymember{operator=}{tuple}% \indexlibrary{\idxcode{pair}}% \begin{itemdecl} -template tuple& operator=(const pair& u); +template tuple& operator=(const pair& u); \end{itemdecl} \begin{itemdescr} @@ -1907,7 +1907,7 @@ \indexlibrarymember{operator=}{tuple}% \indexlibrary{\idxcode{pair}}% \begin{itemdecl} -template tuple& operator=(pair&& u); +template tuple& operator=(pair&& u); \end{itemdecl} \begin{itemdescr} @@ -2040,7 +2040,7 @@ \indexlibrary{\idxcode{tuple_cat}} \begin{itemdecl} -template +template constexpr tuple tuple_cat(Tuples&&... tpls); \end{itemdecl} @@ -2092,7 +2092,7 @@ \indexlibrary{\idxcode{apply}}% \begin{itemdecl} -template +template constexpr decltype(auto) apply(F&& f, Tuple&& t); \end{itemdecl} @@ -2101,7 +2101,7 @@ \effects Given the exposition-only function: \begin{codeblock} -template +template constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, index_sequence) { // exposition only return @\textit{INVOKE}@(std::forward(f), std::get(std::forward(t))...); @@ -2116,7 +2116,7 @@ \indexlibrary{\idxcode{make_from_tuple}}% \begin{itemdecl} -template +template constexpr T make_from_tuple(Tuple&& t); \end{itemdecl} @@ -2125,7 +2125,7 @@ \effects Given the exposition-only function: \begin{codeblock} -template +template constexpr T make_from_tuple_impl(Tuple&& t, index_sequence) { // exposition only return T(get(std::forward(t))...); } @@ -2144,7 +2144,7 @@ \indexlibrary{\idxcode{tuple_size}!in general}% \begin{itemdecl} -template struct tuple_size; +template struct tuple_size; \end{itemdecl} \begin{itemdescr} @@ -2157,13 +2157,13 @@ \indexlibrary{\idxcode{tuple_size}}% \begin{itemdecl} -template +template class tuple_size> : public integral_constant { }; \end{itemdecl} \indexlibrary{\idxcode{tuple_element}}% \begin{itemdecl} -template +template class tuple_element> { public: using type = TI; @@ -2183,9 +2183,9 @@ \indexlibrary{\idxcode{tuple_size}}% \begin{itemdecl} -template class tuple_size; -template class tuple_size; -template class tuple_size; +template class tuple_size; +template class tuple_size; +template class tuple_size; \end{itemdecl} \begin{itemdescr} @@ -2220,9 +2220,9 @@ \indexlibrary{\idxcode{tuple_element}}% \begin{itemdecl} -template class tuple_element; -template class tuple_element; -template class tuple_element; +template class tuple_element; +template class tuple_element; +template class tuple_element; \end{itemdecl} \begin{itemdescr} @@ -2251,16 +2251,16 @@ \indexlibrarymember{get}{tuple}% \begin{itemdecl} -template +template constexpr tuple_element_t>& get(tuple& t) noexcept; -template +template constexpr tuple_element_t>&& get(tuple&& t) noexcept; // Note A -template +template constexpr const tuple_element_t>& get(const tuple& t) noexcept; // Note B -template +template constexpr const tuple_element_t>&& get(const tuple&& t) noexcept; \end{itemdecl} @@ -2295,13 +2295,13 @@ \indexlibrarymember{get}{tuple}% \begin{itemdecl} -template +template constexpr T& get(tuple& t) noexcept; -template +template constexpr T&& get(tuple&& t) noexcept; -template +template constexpr const T& get(const tuple& t) noexcept; -template +template constexpr const T&& get(const tuple&& t) noexcept; \end{itemdecl} @@ -2437,7 +2437,7 @@ \indexlibrary{\idxcode{uses_allocator}}% \begin{itemdecl} -template +template struct uses_allocator, Alloc> : true_type { }; \end{itemdecl} @@ -2455,7 +2455,7 @@ \indexlibrary{\idxcode{swap}}% \begin{itemdecl} -template +template void swap(tuple& x, tuple& y) noexcept(@\seebelow@); \end{itemdecl} @@ -2495,7 +2495,7 @@ \begin{codeblock} namespace std { // \ref{optional.optional}, class template \tcode{optional} - template + template class optional; // \ref{optional.nullopt}, no-value state indicator @@ -2506,61 +2506,61 @@ class bad_optional_access; // \ref{optional.relops}, relational operators - template + template constexpr bool operator==(const optional&, const optional&); - template + template constexpr bool operator!=(const optional&, const optional&); - template + template constexpr bool operator<(const optional&, const optional&); - template + template constexpr bool operator>(const optional&, const optional&); - template + template constexpr bool operator<=(const optional&, const optional&); - template + template constexpr bool operator>=(const optional&, const optional&); // \ref{optional.nullops}, comparison with \tcode{nullopt} - template constexpr bool operator==(const optional&, nullopt_t) noexcept; - template constexpr bool operator==(nullopt_t, const optional&) noexcept; - template constexpr bool operator!=(const optional&, nullopt_t) noexcept; - template constexpr bool operator!=(nullopt_t, const optional&) noexcept; - template constexpr bool operator<(const optional&, nullopt_t) noexcept; - template constexpr bool operator<(nullopt_t, const optional&) noexcept; - template constexpr bool operator<=(const optional&, nullopt_t) noexcept; - template constexpr bool operator<=(nullopt_t, const optional&) noexcept; - template constexpr bool operator>(const optional&, nullopt_t) noexcept; - template constexpr bool operator>(nullopt_t, const optional&) noexcept; - template constexpr bool operator>=(const optional&, nullopt_t) noexcept; - template constexpr bool operator>=(nullopt_t, const optional&) noexcept; + template constexpr bool operator==(const optional&, nullopt_t) noexcept; + template constexpr bool operator==(nullopt_t, const optional&) noexcept; + template constexpr bool operator!=(const optional&, nullopt_t) noexcept; + template constexpr bool operator!=(nullopt_t, const optional&) noexcept; + template constexpr bool operator<(const optional&, nullopt_t) noexcept; + template constexpr bool operator<(nullopt_t, const optional&) noexcept; + template constexpr bool operator<=(const optional&, nullopt_t) noexcept; + template constexpr bool operator<=(nullopt_t, const optional&) noexcept; + template constexpr bool operator>(const optional&, nullopt_t) noexcept; + template constexpr bool operator>(nullopt_t, const optional&) noexcept; + template constexpr bool operator>=(const optional&, nullopt_t) noexcept; + template constexpr bool operator>=(nullopt_t, const optional&) noexcept; // \ref{optional.comp_with_t}, comparison with \tcode{T} - template constexpr bool operator==(const optional&, const T&); - template constexpr bool operator==(const T&, const optional&); - template constexpr bool operator!=(const optional&, const T&); - template constexpr bool operator!=(const T&, const optional&); - template constexpr bool operator<(const optional&, const T&); - template constexpr bool operator<(const T&, const optional&); - template constexpr bool operator<=(const optional&, const T&); - template constexpr bool operator<=(const T&, const optional&); - template constexpr bool operator>(const optional&, const T&); - template constexpr bool operator>(const T&, const optional&); - template constexpr bool operator>=(const optional&, const T&); - template constexpr bool operator>=(const T&, const optional&); + template constexpr bool operator==(const optional&, const T&); + template constexpr bool operator==(const T&, const optional&); + template constexpr bool operator!=(const optional&, const T&); + template constexpr bool operator!=(const T&, const optional&); + template constexpr bool operator<(const optional&, const T&); + template constexpr bool operator<(const T&, const optional&); + template constexpr bool operator<=(const optional&, const T&); + template constexpr bool operator<=(const T&, const optional&); + template constexpr bool operator>(const optional&, const T&); + template constexpr bool operator>(const T&, const optional&); + template constexpr bool operator>=(const optional&, const T&); + template constexpr bool operator>=(const T&, const optional&); // \ref{optional.specalg}, specialized algorithms - template + template void swap(optional&, optional&) noexcept(@\seebelow@); - template + template constexpr optional<@\seebelow@> make_optional(T&&); - template + template constexpr optional make_optional(Args&&... args); - template + template constexpr optional make_optional(initializer_list il, Args&&... args); // \ref{optional.hash}, hash support - template struct hash; - template struct hash>; + template struct hash; + template struct hash>; } \end{codeblock} @@ -2573,7 +2573,7 @@ \indexlibrary{\idxcode{optional}}% \begin{codeblock} -template +template class optional { public: using value_type = T; @@ -2583,15 +2583,15 @@ constexpr optional(nullopt_t) noexcept; optional(const optional&); optional(optional&&) noexcept(@\seebelow@); - template + template constexpr explicit optional(in_place_t, Args&&...); - template + template constexpr explicit optional(in_place_t, initializer_list, Args&&...); - template + template @\EXPLICIT@ constexpr optional(U&&); - template + template @\EXPLICIT@ optional(const optional&); - template + template @\EXPLICIT@ optional(optional&&); // \ref{optional.dtor}, destructor @@ -2601,11 +2601,11 @@ optional& operator=(nullopt_t) noexcept; optional& operator=(const optional&); optional& operator=(optional&&) noexcept(@\seebelow@); - template optional& operator=(U&&); - template optional& operator=(const optional&); - template optional& operator=(optional&&); - template void emplace(Args&&...); - template void emplace(initializer_list, Args&&...); + template optional& operator=(U&&); + template optional& operator=(const optional&); + template optional& operator=(optional&&); + template void emplace(Args&&...); + template void emplace(initializer_list, Args&&...); // \ref{optional.swap}, swap void swap(optional&) noexcept(@\seebelow@); @@ -2623,8 +2623,8 @@ constexpr T& value() &; constexpr T&& value() &&; constexpr const T&& value() const&&; - template constexpr T value_or(U&&) const&; - template constexpr T value_or(U&&) &&; + template constexpr T value_or(U&&) const&; + template constexpr T value_or(U&&) &&; // \ref{optional.mod}, modifiers void reset() noexcept; @@ -2725,7 +2725,7 @@ \indexlibrary{\idxcode{optional}!constructor}% \begin{itemdecl} -template constexpr explicit optional(in_place_t, Args&&... args); +template constexpr explicit optional(in_place_t, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -2750,7 +2750,7 @@ \indexlibrary{\idxcode{optional}!constructor}% \begin{itemdecl} -template +template constexpr explicit optional(in_place_t, initializer_list il, Args&&... args); \end{itemdecl} @@ -2782,7 +2782,7 @@ \indexlibrary{\idxcode{optional}!constructor}% \begin{itemdecl} -template @\EXPLICIT@ constexpr optional(U&& v); +template @\EXPLICIT@ constexpr optional(U&& v); \end{itemdecl} \begin{itemdescr} @@ -2813,7 +2813,7 @@ \indexlibrary{\idxcode{optional}!constructor}% \begin{itemdecl} -template @\EXPLICIT@ optional(const optional& rhs); +template @\EXPLICIT@ optional(const optional& rhs); \end{itemdecl} \begin{itemdescr} @@ -2851,7 +2851,7 @@ \indexlibrary{\idxcode{optional}!constructor}% \begin{itemdecl} -template @\EXPLICIT@ optional(optional&& rhs); +template @\EXPLICIT@ optional(optional&& rhs); \end{itemdecl} \begin{itemdescr} @@ -3020,7 +3020,7 @@ \indexlibrarymember{operator=}{optional}% \begin{itemdecl} -template optional& operator=(U&& v); +template optional& operator=(U&& v); \end{itemdecl} \begin{itemdescr} @@ -3048,7 +3048,7 @@ \indexlibrarymember{operator=}{optional}% \begin{itemdecl} -template optional& operator=(const optional& rhs); +template optional& operator=(const optional& rhs); \end{itemdecl} \begin{itemdescr} @@ -3109,7 +3109,7 @@ \indexlibrarymember{operator=}{optional}% \begin{itemdecl} -template optional& operator=(optional&& rhs); +template optional& operator=(optional&& rhs); \end{itemdecl} \begin{itemdescr} @@ -3171,7 +3171,7 @@ \indexlibrarymember{emplace}{optional}% \begin{itemdecl} -template void emplace(Args&&... args); +template void emplace(Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -3198,7 +3198,7 @@ \indexlibrarymember{emplace}{optional}% \begin{itemdecl} -template void emplace(initializer_list il, Args&&... args); +template void emplace(initializer_list il, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -3399,7 +3399,7 @@ \indexlibrarymember{value_or}{optional}% \begin{itemdecl} -template constexpr T value_or(U&& v) const&; +template constexpr T value_or(U&& v) const&; \end{itemdecl} \begin{itemdescr} @@ -3418,7 +3418,7 @@ \indexlibrarymember{value_or}{optional}% \begin{itemdecl} -template constexpr T value_or(U&& v) &&; +template constexpr T value_or(U&& v) &&; \end{itemdecl} \begin{itemdescr} @@ -3504,7 +3504,7 @@ \indexlibrarymember{operator==}{optional}% \begin{itemdecl} -template constexpr bool operator==(const optional& x, const optional& y); +template constexpr bool operator==(const optional& x, const optional& y); \end{itemdecl} \begin{itemdescr} @@ -3527,7 +3527,7 @@ \indexlibrarymember{operator"!=}{optional}% \begin{itemdecl} -template constexpr bool operator!=(const optional& x, const optional& y); +template constexpr bool operator!=(const optional& x, const optional& y); \end{itemdecl} \begin{itemdescr} @@ -3551,7 +3551,7 @@ \indexlibrarymember{operator<}{optional}% \begin{itemdecl} -template constexpr bool operator<(const optional& x, const optional& y); +template constexpr bool operator<(const optional& x, const optional& y); \end{itemdecl} \begin{itemdescr} @@ -3575,7 +3575,7 @@ \indexlibrarymember{operator>}{optional}% \begin{itemdecl} -template constexpr bool operator>(const optional& x, const optional& y); +template constexpr bool operator>(const optional& x, const optional& y); \end{itemdecl} \begin{itemdescr} @@ -3599,7 +3599,7 @@ \indexlibrarymember{operator<=}{optional}% \begin{itemdecl} -template constexpr bool operator<=(const optional& x, const optional& y); +template constexpr bool operator<=(const optional& x, const optional& y); \end{itemdecl} \begin{itemdescr} @@ -3623,7 +3623,7 @@ \indexlibrarymember{operator>=}{optional}% \begin{itemdecl} -template constexpr bool operator>=(const optional& x, const optional& y); +template constexpr bool operator>=(const optional& x, const optional& y); \end{itemdecl} \begin{itemdescr} @@ -3649,8 +3649,8 @@ \indexlibrarymember{operator==}{optional}% \begin{itemdecl} -template constexpr bool operator==(const optional& x, nullopt_t) noexcept; -template constexpr bool operator==(nullopt_t, const optional& x) noexcept; +template constexpr bool operator==(const optional& x, nullopt_t) noexcept; +template constexpr bool operator==(nullopt_t, const optional& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3661,8 +3661,8 @@ \indexlibrarymember{operator"!=}{optional}% \begin{itemdecl} -template constexpr bool operator!=(const optional& x, nullopt_t) noexcept; -template constexpr bool operator!=(nullopt_t, const optional& x) noexcept; +template constexpr bool operator!=(const optional& x, nullopt_t) noexcept; +template constexpr bool operator!=(nullopt_t, const optional& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3673,7 +3673,7 @@ \indexlibrarymember{operator<}{optional}% \begin{itemdecl} -template constexpr bool operator<(const optional& x, nullopt_t) noexcept; +template constexpr bool operator<(const optional& x, nullopt_t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3684,7 +3684,7 @@ \indexlibrarymember{operator<}{optional}% \begin{itemdecl} -template constexpr bool operator<(nullopt_t, const optional& x) noexcept; +template constexpr bool operator<(nullopt_t, const optional& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3695,7 +3695,7 @@ \indexlibrarymember{operator<=}{optional}% \begin{itemdecl} -template constexpr bool operator<=(const optional& x, nullopt_t) noexcept; +template constexpr bool operator<=(const optional& x, nullopt_t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3706,7 +3706,7 @@ \indexlibrarymember{operator<=}{optional}% \begin{itemdecl} -template constexpr bool operator<=(nullopt_t, const optional& x) noexcept; +template constexpr bool operator<=(nullopt_t, const optional& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3717,7 +3717,7 @@ \indexlibrarymember{operator>}{optional}% \begin{itemdecl} -template constexpr bool operator>(const optional& x, nullopt_t) noexcept; +template constexpr bool operator>(const optional& x, nullopt_t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3728,7 +3728,7 @@ \indexlibrarymember{operator>}{optional}% \begin{itemdecl} -template constexpr bool operator>(nullopt_t, const optional& x) noexcept; +template constexpr bool operator>(nullopt_t, const optional& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3739,7 +3739,7 @@ \indexlibrarymember{operator>=}{optional}% \begin{itemdecl} -template constexpr bool operator>=(const optional& x, nullopt_t) noexcept; +template constexpr bool operator>=(const optional& x, nullopt_t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3750,7 +3750,7 @@ \indexlibrarymember{operator>=}{optional}% \begin{itemdecl} -template constexpr bool operator>=(nullopt_t, const optional& x) noexcept; +template constexpr bool operator>=(nullopt_t, const optional& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -3763,7 +3763,7 @@ \indexlibrarymember{operator==}{optional}% \begin{itemdecl} -template constexpr bool operator==(const optional& x, const T& v); +template constexpr bool operator==(const optional& x, const T& v); \end{itemdecl} \begin{itemdescr} @@ -3774,7 +3774,7 @@ \indexlibrarymember{operator==}{optional}% \begin{itemdecl} -template constexpr bool operator==(const T& v, const optional& x); +template constexpr bool operator==(const T& v, const optional& x); \end{itemdecl} \begin{itemdescr} @@ -3785,7 +3785,7 @@ \indexlibrarymember{operator"!=}{optional}% \begin{itemdecl} -template constexpr bool operator!=(const optional& x, const T& v); +template constexpr bool operator!=(const optional& x, const T& v); \end{itemdecl} \begin{itemdescr} @@ -3796,7 +3796,7 @@ \indexlibrarymember{operator"!=}{optional}% \begin{itemdecl} -template constexpr bool operator!=(const T& v, const optional& x); +template constexpr bool operator!=(const T& v, const optional& x); \end{itemdecl} \begin{itemdescr} @@ -3807,7 +3807,7 @@ \indexlibrarymember{operator<}{optional}% \begin{itemdecl} -template constexpr bool operator<(const optional& x, const T& v); +template constexpr bool operator<(const optional& x, const T& v); \end{itemdecl} \begin{itemdescr} @@ -3818,7 +3818,7 @@ \indexlibrarymember{operator<}{optional}% \begin{itemdecl} -template constexpr bool operator<(const T& v, const optional& x); +template constexpr bool operator<(const T& v, const optional& x); \end{itemdecl} \begin{itemdescr} @@ -3829,7 +3829,7 @@ \indexlibrarymember{operator<=}{optional}% \begin{itemdecl} -template constexpr bool operator<=(const optional& x, const T& v); +template constexpr bool operator<=(const optional& x, const T& v); \end{itemdecl} \begin{itemdescr} @@ -3840,7 +3840,7 @@ \indexlibrarymember{operator<=}{optional}% \begin{itemdecl} -template constexpr bool operator<=(const T& v, const optional& x); +template constexpr bool operator<=(const T& v, const optional& x); \end{itemdecl} \begin{itemdescr} @@ -3851,7 +3851,7 @@ \indexlibrarymember{operator>}{optional}% \begin{itemdecl} -template constexpr bool operator>(const optional& x, const T& v); +template constexpr bool operator>(const optional& x, const T& v); \end{itemdecl} \begin{itemdescr} @@ -3862,7 +3862,7 @@ \indexlibrarymember{operator>}{optional}% \begin{itemdecl} -template constexpr bool operator>(const T& v, const optional& x); +template constexpr bool operator>(const T& v, const optional& x); \end{itemdecl} \begin{itemdescr} @@ -3873,7 +3873,7 @@ \indexlibrarymember{operator>=}{optional}% \begin{itemdecl} -template constexpr bool operator>=(const optional& x, const T& v); +template constexpr bool operator>=(const optional& x, const T& v); \end{itemdecl} \begin{itemdescr} @@ -3884,7 +3884,7 @@ \indexlibrarymember{operator>=}{optional}% \begin{itemdecl} -template constexpr bool operator>=(const T& v, const optional& x); +template constexpr bool operator>=(const T& v, const optional& x); \end{itemdecl} \begin{itemdescr} @@ -3898,7 +3898,7 @@ \indexlibrary{\idxcode{swap}!\idxcode{optional}}% \begin{itemdecl} -template void swap(optional& x, optional& y) noexcept(noexcept(x.swap(y))); +template void swap(optional& x, optional& y) noexcept(noexcept(x.swap(y))); \end{itemdecl} \begin{itemdescr} @@ -3914,7 +3914,7 @@ \indexlibrary{\idxcode{make_optional}}% \begin{itemdecl} -template constexpr optional> make_optional(T&& v); +template constexpr optional> make_optional(T&& v); \end{itemdecl} \begin{itemdescr} @@ -3925,7 +3925,7 @@ \indexlibrary{\idxcode{make_optional}}% \begin{itemdecl} -template +template constexpr optional make_optional(Args&&... args); \end{itemdecl} @@ -3936,7 +3936,7 @@ \indexlibrary{\idxcode{make_optional}}% \begin{itemdecl} -template +template constexpr optional make_optional(initializer_list il, Args&&... args); \end{itemdecl} @@ -3949,7 +3949,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{optional}}% \begin{itemdecl} -template struct hash>; +template struct hash>; \end{itemdecl} \begin{itemdescr} @@ -3980,84 +3980,84 @@ \begin{codeblock} namespace std { // \ref{variant.variant}, class template \tcode{variant} - template + template class variant; // \ref{variant.helper}, variant helper classes - template struct variant_size; // not defined - template struct variant_size; - template struct variant_size; - template struct variant_size; - template + template struct variant_size; // not defined + template struct variant_size; + template struct variant_size; + template struct variant_size; + template constexpr size_t variant_size_v = variant_size::value; - template + template struct variant_size>; - template struct variant_alternative; // not defined - template struct variant_alternative; - template struct variant_alternative; - template struct variant_alternative; - template + template struct variant_alternative; // not defined + template struct variant_alternative; + template struct variant_alternative; + template struct variant_alternative; + template using variant_alternative_t = typename variant_alternative::type; - template + template struct variant_alternative>; constexpr size_t variant_npos = -1; // \ref{variant.get}, value access - template + template constexpr bool holds_alternative(const variant&) noexcept; - template + template constexpr variant_alternative_t>& get(variant&); - template + template constexpr variant_alternative_t>&& get(variant&&); - template + template constexpr const variant_alternative_t>& get(const variant&); - template + template constexpr const variant_alternative_t>&& get(const variant&&); - template + template constexpr T& get(variant&); - template + template constexpr T&& get(variant&&); - template + template constexpr const T& get(const variant&); - template + template constexpr const T&& get(const variant&&); - template + template constexpr add_pointer_t>> get_if(variant*) noexcept; - template + template constexpr add_pointer_t>> get_if(const variant*) noexcept; - template + template constexpr add_pointer_t get_if(variant*) noexcept; - template + template constexpr add_pointer_t get_if(const variant*) noexcept; // \ref{variant.relops}, relational operators - template + template constexpr bool operator==(const variant&, const variant&); - template + template constexpr bool operator!=(const variant&, const variant&); - template + template constexpr bool operator<(const variant&, const variant&); - template + template constexpr bool operator>(const variant&, const variant&); - template + template constexpr bool operator<=(const variant&, const variant&); - template + template constexpr bool operator>=(const variant&, const variant&); // \ref{variant.visit}, visitation - template + template constexpr @\seebelow@ visit(Visitor&&, Variants&&...); // \ref{variant.monostate}, class \tcode{monostate} @@ -4072,20 +4072,20 @@ constexpr bool operator!=(monostate, monostate) noexcept; // \ref{variant.specalg}, specialized algorithms - template + template void swap(variant&, variant&) noexcept(@\seebelow@); // \ref{variant.bad.access}, class \tcode{bad_variant_access} class bad_variant_access; // \ref{variant.hash}, hash support - template struct hash; - template struct hash>; - template <> struct hash; + template struct hash; + template struct hash>; + template<> struct hash; // \ref{variant.traits}, allocator-related traits - template struct uses_allocator; - template struct uses_allocator, Alloc>; + template struct uses_allocator; + template struct uses_allocator, Alloc>; } \end{codeblock} @@ -4094,7 +4094,7 @@ \begin{codeblock} namespace std { - template + template class variant { public: // \ref{variant.ctor}, constructors @@ -4102,36 +4102,36 @@ variant(const variant&); variant(variant&&) noexcept(@\seebelow@); - template + template constexpr variant(T&&) noexcept(@\seebelow@); - template + template constexpr explicit variant(in_place_type_t, Args&&...); - template + template constexpr explicit variant(in_place_type_t, initializer_list, Args&&...); - template + template constexpr explicit variant(in_place_index_t, Args&&...); - template + template constexpr explicit variant(in_place_index_t, initializer_list, Args&&...); // allocator-extended constructors - template + template variant(allocator_arg_t, const Alloc&); - template + template variant(allocator_arg_t, const Alloc&, const variant&); - template + template variant(allocator_arg_t, const Alloc&, variant&&); - template + template variant(allocator_arg_t, const Alloc&, T&&); - template + template variant(allocator_arg_t, const Alloc&, in_place_type_t, Args&&...); - template + template variant(allocator_arg_t, const Alloc&, in_place_type_t, initializer_list, Args&&...); - template + template variant(allocator_arg_t, const Alloc&, in_place_index_t, Args&&...); - template + template variant(allocator_arg_t, const Alloc&, in_place_index_t, initializer_list, Args&&...); @@ -4142,16 +4142,16 @@ variant& operator=(const variant&); variant& operator=(variant&&) noexcept(@\seebelow@); - template variant& operator=(T&&) noexcept(@\seebelow@); + template variant& operator=(T&&) noexcept(@\seebelow@); // \ref{variant.mod}, modifiers - template + template void emplace(Args&&...); - template + template void emplace(initializer_list, Args&&...); - template + template void emplace(Args&&...); - template + template void emplace(initializer_list, Args&&...); // \ref{variant.status}, value status @@ -4272,7 +4272,7 @@ \indexlibrary{\idxcode{variant}!constructor}% \begin{itemdecl} -template constexpr variant(T&& t) noexcept(@\seebelow@); +template constexpr variant(T&& t) noexcept(@\seebelow@); \end{itemdecl} \begin{itemdescr} @@ -4326,7 +4326,7 @@ \indexlibrary{\idxcode{variant}!constructor}% \begin{itemdecl} -template constexpr explicit variant(in_place_type_t, Args&&... args); +template constexpr explicit variant(in_place_type_t, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4353,7 +4353,7 @@ \indexlibrary{\idxcode{variant}!constructor}% \begin{itemdecl} -template +template constexpr explicit variant(in_place_type_t, initializer_list il, Args&&... args); \end{itemdecl} @@ -4382,7 +4382,7 @@ \indexlibrary{\idxcode{variant}!constructor}% \begin{itemdecl} -template constexpr explicit variant(in_place_index_t, Args&&... args); +template constexpr explicit variant(in_place_index_t, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4409,7 +4409,7 @@ \indexlibrary{\idxcode{variant}!constructor}% \begin{itemdecl} -template +template constexpr explicit variant(in_place_index_t, initializer_list il, Args&&... args); \end{itemdecl} @@ -4435,22 +4435,22 @@ \indexlibrary{\idxcode{variant}!constructor}% \begin{itemdecl} // allocator-extended constructors -template +template variant(allocator_arg_t, const Alloc& a); -template +template variant(allocator_arg_t, const Alloc& a, const variant& v); -template +template variant(allocator_arg_t, const Alloc& a, variant&& v); -template +template variant(allocator_arg_t, const Alloc& a, T&& t); -template +template variant(allocator_arg_t, const Alloc& a, in_place_type_t, Args&&... args); -template +template variant(allocator_arg_t, const Alloc& a, in_place_type_t, initializer_list il, Args&&... args); -template +template variant(allocator_arg_t, const Alloc& a, in_place_index_t, Args&&... args); -template +template variant(allocator_arg_t, const Alloc& a, in_place_index_t, initializer_list il, Args&&... args); \end{itemdecl} @@ -4580,7 +4580,7 @@ \indexlibrarymember{operator=}{variant}% \begin{itemdecl} -template variant& operator=(T&& t) noexcept(@\seebelow@); +template variant& operator=(T&& t) noexcept(@\seebelow@); \end{itemdecl} \begin{itemdescr} @@ -4646,7 +4646,7 @@ \indexlibrarymember{emplace}{variant}% \begin{itemdecl} -template void emplace(Args&&... args); +template void emplace(Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4664,7 +4664,7 @@ \indexlibrarymember{emplace}{variant}% \begin{itemdecl} -template void emplace(initializer_list il, Args&&... args); +template void emplace(initializer_list il, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4682,7 +4682,7 @@ \indexlibrarymember{emplace}{variant}% \begin{itemdecl} -template void emplace(Args&&... args); +template void emplace(Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4715,7 +4715,7 @@ \indexlibrarymember{emplace}{variant}% \begin{itemdecl} -template void emplace(initializer_list il, Args&&... args); +template void emplace(initializer_list il, Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -4833,7 +4833,7 @@ \indexlibrary{\idxcode{variant_size}}% \begin{itemdecl} -template struct variant_size; +template struct variant_size; \end{itemdecl} \begin{itemdescr} @@ -4846,9 +4846,9 @@ \indexlibrary{\idxcode{variant_size}}% \begin{itemdecl} -template class variant_size; -template class variant_size; -template class variant_size; +template class variant_size; +template class variant_size; +template class variant_size; \end{itemdecl} \begin{itemdescr} @@ -4861,16 +4861,16 @@ \indexlibrary{\idxcode{variant_size}}% \begin{itemdecl} -template +template struct variant_size> : integral_constant { }; \end{itemdecl} % No itemdescr needed for variant_size> \indexlibrary{\idxcode{variant_alternative}}% \begin{itemdecl} -template class variant_alternative; -template class variant_alternative; -template class variant_alternative; +template class variant_alternative; +template class variant_alternative; +template class variant_alternative; \end{itemdecl} \begin{itemdescr} @@ -4904,7 +4904,7 @@ \indexlibrary{\idxcode{holds_alternative}} \indexlibrary{\idxcode{variant}!\idxcode{holds_alternative}} \begin{itemdecl} -template +template constexpr bool holds_alternative(const variant& v) noexcept; \end{itemdecl} @@ -4921,13 +4921,13 @@ \indexlibrarymember{get}{variant}% \begin{itemdecl} -template +template constexpr variant_alternative_t>& get(variant& v); -template +template constexpr variant_alternative_t>&& get(variant&& v); -template +template constexpr const variant_alternative_t>& get(const variant& v); -template +template constexpr const variant_alternative_t>&& get(const variant&& v); \end{itemdecl} @@ -4945,10 +4945,10 @@ \indexlibrarymember{get}{variant}% \begin{itemdecl} -template constexpr T& get(variant& v); -template constexpr T&& get(variant&& v); -template constexpr const T& get(const variant& v); -template constexpr const T&& get(const variant&& v); +template constexpr T& get(variant& v); +template constexpr T&& get(variant&& v); +template constexpr const T& get(const variant& v); +template constexpr const T&& get(const variant&& v); \end{itemdecl} \begin{itemdescr} @@ -4966,10 +4966,10 @@ \indexlibrary{\idxcode{get_if}}% \indexlibrary{\idxcode{variant}!\idxcode{get_if}}% \begin{itemdecl} -template +template constexpr add_pointer_t>> get_if(variant* v) noexcept; -template +template constexpr add_pointer_t>> get_if(const variant* v) noexcept; \end{itemdecl} @@ -4989,10 +4989,10 @@ \indexlibrary{\idxcode{get_if}}% \indexlibrary{\idxcode{variant}!\idxcode{get_if}}% \begin{itemdecl} -template +template constexpr add_pointer_t get_if(variant* v) noexcept; -template +template constexpr add_pointer_t get_if(const variant* v) noexcept; \end{itemdecl} @@ -5013,7 +5013,7 @@ \indexlibrarymember{operator==}{variant}% \begin{itemdecl} -template +template constexpr bool operator==(const variant& v, const variant& w); \end{itemdecl} @@ -5032,7 +5032,7 @@ \indexlibrarymember{operator"!=}{variant}% \begin{itemdecl} -template +template constexpr bool operator!=(const variant& v, const variant& w); \end{itemdecl} @@ -5051,7 +5051,7 @@ \indexlibrarymember{operator<}{variant}% \begin{itemdecl} -template +template constexpr bool operator<(const variant& v, const variant& w); \end{itemdecl} @@ -5072,7 +5072,7 @@ \indexlibrarymember{operator>}{variant}% \begin{itemdecl} -template +template constexpr bool operator>(const variant& v, const variant& w); \end{itemdecl} @@ -5093,7 +5093,7 @@ \indexlibrarymember{operator<=}{variant}% \begin{itemdecl} -template +template constexpr bool operator<=(const variant& v, const variant& w); \end{itemdecl} @@ -5114,7 +5114,7 @@ \indexlibrarymember{operator>=}{variant}% \begin{itemdecl} -template +template constexpr bool operator>=(const variant& v, const variant& w); \end{itemdecl} @@ -5138,7 +5138,7 @@ \indexlibrary{\idxcode{visit}}% \indexlibrary{\idxcode{variant}!\idxcode{visit}}% \begin{itemdecl} -template +template constexpr @\seebelow@ visit(Visitor&& vis, Variants&&... vars); \end{itemdecl} @@ -5212,7 +5212,7 @@ \indexlibrary{\idxcode{swap}!\idxcode{variant}}% \begin{itemdecl} -template +template void swap(variant& v, variant& w) noexcept(@\seebelow@); \end{itemdecl} @@ -5266,7 +5266,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{variant}}% \begin{itemdecl} -template struct hash>; +template struct hash>; \end{itemdecl} \begin{itemdescr} @@ -5277,7 +5277,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{monostate}}% \begin{itemdecl} -template <> struct hash; +template<> struct hash; \end{itemdecl} \begin{itemdescr} @@ -5290,7 +5290,7 @@ \indexlibrary{\idxcode{uses_allocator}!\idxcode{variant}}% \begin{itemdecl} -template +template struct uses_allocator, Alloc> : true_type { }; \end{itemdecl} @@ -5335,9 +5335,9 @@ // \ref{any.nonmembers}, non-member functions void swap(any& x, any& y) noexcept; - template + template any make_any(Args&& ...args); - template + template any make_any(initializer_list il, Args&& ...args); template @@ -5378,11 +5378,11 @@ any(const any& other); any(any&& other) noexcept; - template any(T&& value); + template any(T&& value); - template + template explicit any(in_place_type_t, Args&&...); - template + template explicit any(in_place_type_t, initializer_list, Args&&...); ~any(); @@ -5391,12 +5391,12 @@ any& operator=(const any& rhs); any& operator=(any&& rhs) noexcept; - template any& operator=(T&& rhs); + template any& operator=(T&& rhs); // \ref{any.modifiers}, modifiers - template + template void emplace(Args&& ...); - template + template void emplace(initializer_list, Args&&...); void reset() noexcept; void swap(any& rhs) noexcept; @@ -5499,7 +5499,7 @@ \indexlibrary{\idxcode{any}!constructor}% \begin{itemdecl} -template +template explicit any(in_place_type_t, Args&&... args); \end{itemdecl} @@ -5529,7 +5529,7 @@ \indexlibrary{\idxcode{any}!constructor}% \begin{itemdecl} -template +template explicit any(in_place_type_t, initializer_list il, Args&&... args); \end{itemdecl} @@ -5648,7 +5648,7 @@ \indexlibrarymember{emplace}{any}% \begin{itemdecl} -template +template void emplace(Args&&... args); \end{itemdecl} @@ -5682,7 +5682,7 @@ \indexlibrarymember{emplace}{any}% \begin{itemdecl} -template +template void emplace(initializer_list il, Args&&... args); \end{itemdecl} @@ -5786,7 +5786,7 @@ \indexlibrary{\idxcode{make_any}}% \begin{itemdecl} -template +template any make_any(Args&& ...args); \end{itemdecl} @@ -5798,7 +5798,7 @@ \indexlibrary{\idxcode{make_any}}% \begin{itemdecl} -template +template any make_any(initializer_list il, Args&& ...args); \end{itemdecl} @@ -5901,19 +5901,19 @@ #include // for \tcode{istream} (\ref{istream.syn}), \tcode{ostream} (\ref{ostream.syn}), see \ref{iosfwd.syn} namespace std { - template class bitset; + template class bitset; // \ref{bitset.operators}, bitset operators - template + template bitset operator&(const bitset&, const bitset&) noexcept; - template + template bitset operator|(const bitset&, const bitset&) noexcept; - template + template bitset operator^(const bitset&, const bitset&) noexcept; - template + template basic_istream& operator>>(basic_istream& is, bitset& x); - template + template basic_ostream& operator<<(basic_ostream& os, const bitset& x); } @@ -5957,7 +5957,7 @@ basic_string::npos, charT zero = charT('0'), charT one = charT('1')); - template + template explicit bitset( const charT* str, typename basic_string::size_type n = basic_string::npos, @@ -5984,9 +5984,9 @@ unsigned long to_ulong() const; unsigned long long to_ullong() const; - template , - class Allocator = allocator> + template, + class Allocator = allocator> basic_string to_string(charT zero = charT('0'), charT one = charT('1')) const; @@ -6003,8 +6003,8 @@ }; // \ref{bitset.hash}, hash support - template struct hash; - template struct hash>; + template struct hash; + template struct hash>; } \end{codeblock} @@ -6090,7 +6090,7 @@ \indexlibrary{\idxcode{bitset}!constructor}% \begin{itemdecl} -template +template explicit bitset(const basic_string& str, typename basic_string::size_type pos = 0, @@ -6145,7 +6145,7 @@ \indexlibrary{\idxcode{bitset}!constructor}% \begin{itemdecl} -template +template explicit bitset( const charT* str, typename basic_string::size_type n = basic_string::npos, @@ -6446,7 +6446,7 @@ \indexlibrarymember{to_string}{bitset}% \begin{itemdecl} -template , class Allocator = allocator> basic_string @@ -6648,7 +6648,7 @@ \indexlibrary{\idxcode{hash_code}}% \begin{itemdecl} -template struct hash>; +template struct hash>; \end{itemdecl} \begin{itemdescr} @@ -6693,7 +6693,7 @@ \indexlibrarymember{operator>>}{bitset}% \begin{itemdecl} -template +template basic_istream& operator>>(basic_istream& is, bitset& x); \end{itemdecl} @@ -6738,7 +6738,7 @@ \indexlibrarymember{operator<<}{bitset}% \begin{itemdecl} -template +template basic_ostream& operator<<(basic_ostream& os, const bitset& x); \end{itemdecl} @@ -6781,13 +6781,13 @@ \begin{codeblock} namespace std { // \ref{pointer.traits}, pointer traits - template struct pointer_traits; - template struct pointer_traits; + template struct pointer_traits; + template struct pointer_traits; // \ref{util.dynamic.safety}, pointer safety enum class pointer_safety { relaxed, preferred, strict }; void declare_reachable(void* p); - template T* undeclare_reachable(T* p); + template T* undeclare_reachable(T* p); void declare_no_pointers(char* p, size_t n); void undeclare_no_pointers(char* p, size_t n); pointer_safety get_pointer_safety() noexcept; @@ -6800,142 +6800,142 @@ constexpr allocator_arg_t allocator_arg{}; // \ref{allocator.uses}, \tcode{uses_allocator} - template struct uses_allocator; + template struct uses_allocator; // \ref{allocator.traits}, allocator traits - template struct allocator_traits; + template struct allocator_traits; // \ref{default.allocator}, the default allocator - template class allocator; - template + template class allocator; + template bool operator==(const allocator&, const allocator&) noexcept; - template + template bool operator!=(const allocator&, const allocator&) noexcept; // \ref{specialized.algorithms}, specialized algorithms - template constexpr T* addressof(T& r) noexcept; - template const T* addressof(const T&&) = delete; - template + template constexpr T* addressof(T& r) noexcept; + template const T* addressof(const T&&) = delete; + template void uninitialized_default_construct(ForwardIterator first, ForwardIterator last); - template + template void uninitialized_default_construct(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, ForwardIterator last); - template + template ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n); - template + template ForwardIterator uninitialized_default_construct_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, Size n); - template + template void uninitialized_value_construct(ForwardIterator first, ForwardIterator last); - template + template void uninitialized_value_construct(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, ForwardIterator last); - template + template ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n); - template + template ForwardIterator uninitialized_value_construct_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, Size n); - template + template ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); - template + template ForwardIterator uninitialized_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, ForwardIterator result); - template + template ForwardIterator uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result); - template + template ForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, Size n, ForwardIterator result); - template + template ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result); - template + template ForwardIterator uninitialized_move(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, InputIterator last, ForwardIterator result); - template + template pair uninitialized_move_n(InputIterator first, Size n, ForwardIterator result); - template + template pair uninitialized_move_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} InputIterator first, Size n, ForwardIterator result); - template + template void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); - template + template void uninitialized_fill(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, ForwardIterator last, const T& x); - template + template ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x); - template + template ForwardIterator uninitialized_fill_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, Size n, const T& x); - template + template void destroy_at(T* location); - template + template void destroy(ForwardIterator first, ForwardIterator last); - template + template void destroy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, ForwardIterator last); - template + template ForwardIterator destroy_n(ForwardIterator first, Size n); - template + template ForwardIterator destroy_n(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads} ForwardIterator first, Size n); // \ref{unique.ptr}, class template \tcode{unique_ptr} - template struct default_delete; - template struct default_delete; - template > class unique_ptr; - template class unique_ptr; + template struct default_delete; + template struct default_delete; + template> class unique_ptr; + template class unique_ptr; - template unique_ptr make_unique(Args&&... args); - template unique_ptr make_unique(size_t n); - template @\unspec@ make_unique(Args&&...) = delete; + template unique_ptr make_unique(Args&&... args); + template unique_ptr make_unique(size_t n); + template @\unspec@ make_unique(Args&&...) = delete; - template void swap(unique_ptr& x, unique_ptr& y) noexcept; + template void swap(unique_ptr& x, unique_ptr& y) noexcept; - template + template bool operator==(const unique_ptr& x, const unique_ptr& y); - template + template bool operator!=(const unique_ptr& x, const unique_ptr& y); - template + template bool operator<(const unique_ptr& x, const unique_ptr& y); - template + template bool operator<=(const unique_ptr& x, const unique_ptr& y); - template + template bool operator>(const unique_ptr& x, const unique_ptr& y); - template + template bool operator>=(const unique_ptr& x, const unique_ptr& y); - template + template bool operator==(const unique_ptr& x, nullptr_t) noexcept; - template + template bool operator==(nullptr_t, const unique_ptr& y) noexcept; - template + template bool operator!=(const unique_ptr& x, nullptr_t) noexcept; - template + template bool operator!=(nullptr_t, const unique_ptr& y) noexcept; - template + template bool operator<(const unique_ptr& x, nullptr_t); - template + template bool operator<(nullptr_t, const unique_ptr& y); - template + template bool operator<=(const unique_ptr& x, nullptr_t); - template + template bool operator<=(nullptr_t, const unique_ptr& y); - template + template bool operator>(const unique_ptr& x, nullptr_t); - template + template bool operator>(nullptr_t, const unique_ptr& y); - template + template bool operator>=(const unique_ptr& x, nullptr_t); - template + template bool operator>=(nullptr_t, const unique_ptr& y); // \ref{util.smartptr.weak.bad}, class \tcode{bad_weak_ptr} @@ -6964,29 +6964,29 @@ template bool operator>=(const shared_ptr& a, const shared_ptr& b) noexcept; - template + template bool operator==(const shared_ptr& x, nullptr_t) noexcept; - template + template bool operator==(nullptr_t, const shared_ptr& y) noexcept; - template + template bool operator!=(const shared_ptr& x, nullptr_t) noexcept; - template + template bool operator!=(nullptr_t, const shared_ptr& y) noexcept; - template + template bool operator<(const shared_ptr& x, nullptr_t) noexcept; - template + template bool operator<(nullptr_t, const shared_ptr& y) noexcept; - template + template bool operator<=(const shared_ptr& x, nullptr_t) noexcept; - template + template bool operator<=(nullptr_t, const shared_ptr& y) noexcept; - template + template bool operator>(const shared_ptr& x, nullptr_t) noexcept; - template + template bool operator>(nullptr_t, const shared_ptr& y) noexcept; - template + template bool operator>=(const shared_ptr& x, nullptr_t) noexcept; - template + template bool operator>=(nullptr_t, const shared_ptr& y) noexcept; // \ref{util.smartptr.shared.spec}, \tcode{shared_ptr} specialized algorithms @@ -7056,12 +7056,13 @@ memory_order success, memory_order failure); // \ref{util.smartptr.hash}, hash support - template struct hash; - template struct hash>; - template struct hash>; + template struct hash; + template struct hash>; + template struct hash>; // \ref{allocator.uses.trait}, \tcode{uses_allocator} - template + template + constexpr bool uses_allocator_v = uses_allocator::value; } \end{codeblock} @@ -7075,22 +7076,22 @@ \indexlibrary{\idxcode{pointer_traits}}% \begin{codeblock} namespace std { - template struct pointer_traits { + template struct pointer_traits { using pointer = Ptr; using element_type = @\seebelow@; using difference_type = @\seebelow@; - template using rebind = @\seebelow@; + template using rebind = @\seebelow@; static pointer pointer_to(@\seebelow@ r); }; - template struct pointer_traits { + template struct pointer_traits { using pointer = T*; using element_type = T; using difference_type = ptrdiff_t; - template using rebind = U*; + template using rebind = U*; static pointer pointer_to(@\seebelow@ r) noexcept; }; @@ -7129,7 +7130,7 @@ \indexlibrarymember{rebind}{pointer_traits}% \begin{itemdecl} -template using rebind = @\seebelow@; +template using rebind = @\seebelow@; \end{itemdecl} \begin{itemdescr} @@ -7193,7 +7194,7 @@ \indexlibrary{\idxcode{undeclare_reachable}}% \begin{itemdecl} -template T* undeclare_reachable(T* p); +template T* undeclare_reachable(T* p); \end{itemdecl} \begin{itemdescr} @@ -7348,7 +7349,7 @@ \indexlibrary{\idxcode{uses_allocator}}% \begin{itemdecl} -template struct uses_allocator; +template struct uses_allocator; \end{itemdecl} \begin{itemdescr} @@ -7412,7 +7413,7 @@ \indexlibrary{\idxcode{allocator_traits}}% \begin{codeblock} namespace std { - template struct allocator_traits { + template struct allocator_traits { using allocator_type = Alloc; using value_type = typename Alloc::value_type; @@ -7430,18 +7431,18 @@ using propagate_on_container_swap = @\seebelow@; using is_always_equal = @\seebelow@; - template using rebind_alloc = @\seebelow@; - template using rebind_traits = allocator_traits>; + template using rebind_alloc = @\seebelow@; + template using rebind_traits = allocator_traits>; static pointer allocate(Alloc& a, size_type n); static pointer allocate(Alloc& a, size_type n, const_void_pointer hint); static void deallocate(Alloc& a, pointer p, size_type n); - template + template static void construct(Alloc& a, T* p, Args&&... args); - template + template static void destroy(Alloc& a, T* p); static size_type max_size(const Alloc& a) noexcept; @@ -7584,7 +7585,7 @@ \indexlibrarymember{rebind_alloc}{allocator_traits}% \begin{itemdecl} -template using rebind_alloc = @\seebelow@; +template using rebind_alloc = @\seebelow@; \end{itemdecl} \begin{itemdescr} @@ -7634,7 +7635,7 @@ \indexlibrarymember{construct}{allocator_traits}% \begin{itemdecl} -template +template static void construct(Alloc& a, T* p, Args&&... args); \end{itemdecl} @@ -7647,7 +7648,7 @@ \indexlibrarymember{destroy}{allocator_traits}% \begin{itemdecl} -template +template static void destroy(Alloc& a, T* p); \end{itemdecl} @@ -7688,7 +7689,7 @@ \indexlibrary{\idxcode{allocator}}% \begin{codeblock} namespace std { - template class allocator { + template class allocator { public: using value_type = T; using propagate_on_container_move_assignment = true_type; @@ -7696,7 +7697,7 @@ allocator() noexcept; allocator(const allocator&) noexcept; - template allocator(const allocator&) noexcept; + template allocator(const allocator&) noexcept; ~allocator(); T* allocate(size_t n); @@ -7764,7 +7765,7 @@ \indexlibrarymember{operator==}{allocator}% \begin{itemdecl} -template +template bool operator==(const allocator&, const allocator&) noexcept; \end{itemdecl} @@ -7776,7 +7777,7 @@ \indexlibrarymember{operator"!=}{allocator}% \begin{itemdecl} -template +template bool operator!=(const allocator&, const allocator&) noexcept; \end{itemdecl} @@ -7810,7 +7811,7 @@ \indexlibrary{\idxcode{addressof}}% \begin{itemdecl} -template constexpr T* addressof(T& r) noexcept; +template constexpr T* addressof(T& r) noexcept; \end{itemdecl} \begin{itemdescr} @@ -7828,7 +7829,7 @@ \indexlibrary{\idxcode{uninitialized_default_construct}}% \begin{itemdecl} -template +template void uninitialized_default_construct(ForwardIterator first, ForwardIterator last); \end{itemdecl} @@ -7845,7 +7846,7 @@ \indexlibrary{\idxcode{uninitialized_default_construct_n}}% \begin{itemdecl} -template +template ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n); \end{itemdecl} @@ -7865,7 +7866,7 @@ \indexlibrary{\idxcode{uninitialized_value_construct}}% \begin{itemdecl} -template +template void uninitialized_value_construct(ForwardIterator first, ForwardIterator last); \end{itemdecl} @@ -7882,7 +7883,7 @@ \indexlibrary{\idxcode{uninitialized_value_construct_n}}% \begin{itemdecl} -template +template ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n); \end{itemdecl} @@ -7902,7 +7903,7 @@ \indexlibrary{\idxcode{uninitialized_copy}}% \begin{itemdecl} -template +template ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); \end{itemdecl} @@ -7924,7 +7925,7 @@ \indexlibrary{\idxcode{uninitialized_copy_n}}% \begin{itemdecl} -template +template ForwardIterator uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result); \end{itemdecl} @@ -7948,7 +7949,7 @@ \indexlibrary{\idxcode{uninitialized_move}}% \begin{itemdecl} -template +template ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result); \end{itemdecl} @@ -7972,7 +7973,7 @@ \indexlibrary{\idxcode{uninitialized_move_n}}% \begin{itemdecl} -template +template pair uninitialized_move_n(InputIterator first, Size n, ForwardIterator result); \end{itemdecl} @@ -7998,7 +7999,7 @@ \indexlibrary{\idxcode{uninitialized_fill}}% \begin{itemdecl} -template +template void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); \end{itemdecl} @@ -8016,7 +8017,7 @@ \indexlibrary{\idxcode{uninitialized_fill_n}}% \begin{itemdecl} -template +template ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x); \end{itemdecl} @@ -8036,7 +8037,7 @@ \indexlibrary{\idxcode{destroy_at}}% \begin{itemdecl} -template +template void destroy_at(T* location); \end{itemdecl} @@ -8051,7 +8052,7 @@ \indexlibrary{\idxcode{destroy}}% \begin{itemdecl} -template +template void destroy(ForwardIterator first, ForwardIterator last); \end{itemdecl} @@ -8067,7 +8068,7 @@ \indexlibrary{\idxcode{destroy_n}}% \begin{itemdecl} -template +template ForwardIterator destroy_n(ForwardIterator first, Size n); \end{itemdecl} @@ -8232,29 +8233,29 @@ template bool operator>=(const unique_ptr& x, const unique_ptr& y); - template + template bool operator==(const unique_ptr& x, nullptr_t) noexcept; - template + template bool operator==(nullptr_t, const unique_ptr& y) noexcept; - template + template bool operator!=(const unique_ptr& x, nullptr_t) noexcept; - template + template bool operator!=(nullptr_t, const unique_ptr& y) noexcept; - template + template bool operator<(const unique_ptr& x, nullptr_t); - template + template bool operator<(nullptr_t, const unique_ptr& y); - template + template bool operator<=(const unique_ptr& x, nullptr_t); - template + template bool operator<=(nullptr_t, const unique_ptr& y); - template + template bool operator>(const unique_ptr& x, nullptr_t); - template + template bool operator>(nullptr_t, const unique_ptr& y); - template + template bool operator>=(const unique_ptr& x, nullptr_t); - template + template bool operator>=(nullptr_t, const unique_ptr& y); } @@ -8276,9 +8277,9 @@ \begin{codeblock} namespace std { - template struct default_delete { + template struct default_delete { constexpr default_delete() noexcept = default; - template default_delete(const default_delete&) noexcept; + template default_delete(const default_delete&) noexcept; void operator()(T*) const; }; } @@ -8286,7 +8287,7 @@ \indexlibrary{\idxcode{default_delete}!constructor}% \begin{itemdecl} -template default_delete(const default_delete& other) noexcept; +template default_delete(const default_delete& other) noexcept; \end{itemdecl} \begin{itemdescr} @@ -8316,17 +8317,17 @@ \begin{codeblock} namespace std { - template struct default_delete { + template struct default_delete { constexpr default_delete() noexcept = default; - template default_delete(const default_delete&) noexcept; - template void operator()(U* ptr) const; + template default_delete(const default_delete&) noexcept; + template void operator()(U* ptr) const; }; } \end{codeblock} \indexlibrary{\idxcode{default_delete}!constructor} \begin{itemdecl} -template default_delete(const default_delete& other) noexcept; +template default_delete(const default_delete& other) noexcept; \end{itemdecl} \begin{itemdescr} @@ -8342,7 +8343,7 @@ \indexlibrarymember{operator()}{default_delete}% \begin{itemdecl} -template void operator()(U* ptr) const; +template void operator()(U* ptr) const; \end{itemdecl} \begin{itemdescr} @@ -8361,7 +8362,7 @@ \indexlibrary{\idxcode{unique_ptr}}% \begin{codeblock} namespace std { - template > class unique_ptr { + template> class unique_ptr { public: using pointer = @\seebelow@; using element_type = T; @@ -8375,7 +8376,7 @@ unique_ptr(unique_ptr&& u) noexcept; constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { } - template + template unique_ptr(unique_ptr&& u) noexcept; // \ref{unique.ptr.single.dtor}, destructor @@ -8383,7 +8384,7 @@ // \ref{unique.ptr.single.asgn}, assignment unique_ptr& operator=(unique_ptr&& u) noexcept; - template unique_ptr& operator=(unique_ptr&& u) noexcept; + template unique_ptr& operator=(unique_ptr&& u) noexcept; unique_ptr& operator=(nullptr_t) noexcept; // \ref{unique.ptr.single.observers}, observers @@ -8617,7 +8618,7 @@ \indexlibrary{\idxcode{unique_ptr}!constructor}% \begin{itemdecl} -template unique_ptr(unique_ptr&& u) noexcept; +template unique_ptr(unique_ptr&& u) noexcept; \end{itemdecl} \begin{itemdescr} @@ -8701,7 +8702,7 @@ \indexlibrarymember{operator=}{unique_ptr}% \begin{itemdecl} -template unique_ptr& operator=(unique_ptr&& u) noexcept; +template unique_ptr& operator=(unique_ptr&& u) noexcept; \end{itemdecl} \begin{itemdescr} @@ -8871,7 +8872,7 @@ \indexlibrary{\idxcode{unique_ptr}}% \begin{codeblock} namespace std { - template class unique_ptr { + template class unique_ptr { public: using pointer = @\seebelow@; using element_type = T; @@ -8879,11 +8880,11 @@ // \ref{unique.ptr.runtime.ctor}, constructors constexpr unique_ptr() noexcept; - template explicit unique_ptr(U p) noexcept; - template unique_ptr(U p, @\seebelow@ d) noexcept; - template unique_ptr(U p, @\seebelow@ d) noexcept; + template explicit unique_ptr(U p) noexcept; + template unique_ptr(U p, @\seebelow@ d) noexcept; + template unique_ptr(U p, @\seebelow@ d) noexcept; unique_ptr(unique_ptr&& u) noexcept; - template + template unique_ptr(unique_ptr&& u) noexcept; constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { } @@ -8892,7 +8893,7 @@ // assignment unique_ptr& operator=(unique_ptr&& u) noexcept; - template + template unique_ptr& operator=(unique_ptr&& u) noexcept; unique_ptr& operator=(nullptr_t) noexcept; @@ -8905,7 +8906,7 @@ // \ref{unique.ptr.runtime.modifiers}, modifiers pointer release() noexcept; - template void reset(U p) noexcept; + template void reset(U p) noexcept; void reset(nullptr_t = nullptr) noexcept; void swap(unique_ptr& u) noexcept; @@ -8949,9 +8950,9 @@ \indexlibrary{\idxcode{unique_ptr}!constructor}% \begin{itemdecl} -template explicit unique_ptr(U p) noexcept; -template unique_ptr(U p, @\seebelow@ d) noexcept; -template unique_ptr(U p, @\seebelow@ d) noexcept; +template explicit unique_ptr(U p) noexcept; +template unique_ptr(U p, @\seebelow@ d) noexcept; +template unique_ptr(U p, @\seebelow@ d) noexcept; \end{itemdecl} \begin{itemdescr} @@ -8973,7 +8974,7 @@ \indexlibrary{\idxcode{unique_ptr}!constructor}% \begin{itemdecl} -template +template unique_ptr(unique_ptr&& u) noexcept; \end{itemdecl} @@ -9002,7 +9003,7 @@ \indexlibrarymember{operator=}{unique_ptr}% \begin{itemdecl} -template +template unique_ptr& operator=(unique_ptr&& u)noexcept; \end{itemdecl} @@ -9057,7 +9058,7 @@ \indexlibrarymember{reset}{unique_ptr}% \begin{itemdecl} -template void reset(U p) noexcept; +template void reset(U p) noexcept; \end{itemdecl} \begin{itemdescr} @@ -9079,7 +9080,7 @@ \indexlibrary{\idxcode{make_unique}}% \begin{itemdecl} -template unique_ptr make_unique(Args&&... args); +template unique_ptr make_unique(Args&&... args); \end{itemdecl} \begin{itemdescr} @@ -9093,7 +9094,7 @@ \indexlibrary{\idxcode{make_unique}}% \begin{itemdecl} -template unique_ptr make_unique(size_t n); +template unique_ptr make_unique(size_t n); \end{itemdecl} \begin{itemdescr} @@ -9107,7 +9108,7 @@ \indexlibrary{\idxcode{make_unique}}% \begin{itemdecl} -template @\unspec@ make_unique(Args&&...) = delete; +template @\unspec@ make_unique(Args&&...) = delete; \end{itemdecl} \begin{itemdescr} @@ -9120,7 +9121,7 @@ \indexlibrary{\idxcode{swap(unique_ptr\&, unique_ptr\&)}}% \begin{itemdecl} -template void swap(unique_ptr& x, unique_ptr& y) noexcept; +template void swap(unique_ptr& x, unique_ptr& y) noexcept; \end{itemdecl} \begin{itemdescr} @@ -9134,7 +9135,7 @@ \indexlibrarymember{operator==}{unique_ptr}% \begin{itemdecl} -template +template bool operator==(const unique_ptr& x, const unique_ptr& y); \end{itemdecl} @@ -9145,7 +9146,7 @@ \indexlibrarymember{operator"!=}{unique_ptr}% \begin{itemdecl} -template +template bool operator!=(const unique_ptr& x, const unique_ptr& y); \end{itemdecl} @@ -9156,7 +9157,7 @@ \indexlibrarymember{operator<}{unique_ptr}% \begin{itemdecl} -template +template bool operator<(const unique_ptr& x, const unique_ptr& y); \end{itemdecl} @@ -9182,7 +9183,7 @@ \indexlibrarymember{operator<=}{unique_ptr}% \begin{itemdecl} -template +template bool operator<=(const unique_ptr& x, const unique_ptr& y); \end{itemdecl} @@ -9193,7 +9194,7 @@ \indexlibrarymember{operator>}{unique_ptr}% \begin{itemdecl} -template +template bool operator>(const unique_ptr& x, const unique_ptr& y); \end{itemdecl} @@ -9204,7 +9205,7 @@ \indexlibrarymember{operator>=}{unique_ptr}% \begin{itemdecl} -template +template bool operator>=(const unique_ptr& x, const unique_ptr& y); \end{itemdecl} @@ -9215,9 +9216,9 @@ \indexlibrarymember{operator==}{unique_ptr}% \begin{itemdecl} -template +template bool operator==(const unique_ptr& x, nullptr_t) noexcept; -template +template bool operator==(nullptr_t, const unique_ptr& x) noexcept; \end{itemdecl} @@ -9228,9 +9229,9 @@ \indexlibrarymember{operator"!=}{unique_ptr}% \begin{itemdecl} -template +template bool operator!=(const unique_ptr& x, nullptr_t) noexcept; -template +template bool operator!=(nullptr_t, const unique_ptr& x) noexcept; \end{itemdecl} @@ -9241,9 +9242,9 @@ \indexlibrarymember{operator<}{unique_ptr}% \begin{itemdecl} -template +template bool operator<(const unique_ptr& x, nullptr_t); -template +template bool operator<(nullptr_t, const unique_ptr& x); \end{itemdecl} @@ -9263,9 +9264,9 @@ \indexlibrarymember{operator>}{unique_ptr}% \begin{itemdecl} -template +template bool operator>(const unique_ptr& x, nullptr_t); -template +template bool operator>(nullptr_t, const unique_ptr& x); \end{itemdecl} @@ -9278,9 +9279,9 @@ \indexlibrarymember{operator<=}{unique_ptr}% \begin{itemdecl} -template +template bool operator<=(const unique_ptr& x, nullptr_t); -template +template bool operator<=(nullptr_t, const unique_ptr& x); \end{itemdecl} @@ -9293,9 +9294,9 @@ \indexlibrarymember{operator>=}{unique_ptr}% \begin{itemdecl} -template +template bool operator>=(const unique_ptr& x, nullptr_t); -template +template bool operator>=(nullptr_t, const unique_ptr& x); \end{itemdecl} @@ -9358,15 +9359,15 @@ template explicit shared_ptr(Y* p); template shared_ptr(Y* p, D d); template shared_ptr(Y* p, D d, A a); - template shared_ptr(nullptr_t p, D d); - template shared_ptr(nullptr_t p, D d, A a); + template shared_ptr(nullptr_t p, D d); + template shared_ptr(nullptr_t p, D d, A a); template shared_ptr(const shared_ptr& r, element_type* p) noexcept; shared_ptr(const shared_ptr& r) noexcept; template shared_ptr(const shared_ptr& r) noexcept; shared_ptr(shared_ptr&& r) noexcept; template shared_ptr(shared_ptr&& r) noexcept; template explicit shared_ptr(const weak_ptr& r); - template shared_ptr(unique_ptr&& r); + template shared_ptr(unique_ptr&& r); constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } // \ref{util.smartptr.shared.dest}, destructor @@ -9377,7 +9378,7 @@ template shared_ptr& operator=(const shared_ptr& r) noexcept; shared_ptr& operator=(shared_ptr&& r) noexcept; template shared_ptr& operator=(shared_ptr&& r) noexcept; - template shared_ptr& operator=(unique_ptr&& r); + template shared_ptr& operator=(unique_ptr&& r); // \ref{util.smartptr.shared.mod}, modifiers void swap(shared_ptr& r) noexcept; @@ -9417,29 +9418,29 @@ template bool operator>=(const shared_ptr& a, const shared_ptr& b) noexcept; - template + template bool operator==(const shared_ptr& a, nullptr_t) noexcept; - template + template bool operator==(nullptr_t, const shared_ptr& b) noexcept; - template + template bool operator!=(const shared_ptr& a, nullptr_t) noexcept; - template + template bool operator!=(nullptr_t, const shared_ptr& b) noexcept; - template + template bool operator<(const shared_ptr& a, nullptr_t) noexcept; - template + template bool operator<(nullptr_t, const shared_ptr& b) noexcept; - template + template bool operator<=(const shared_ptr& a, nullptr_t) noexcept; - template + template bool operator<=(nullptr_t, const shared_ptr& b) noexcept; - template + template bool operator>(const shared_ptr& a, nullptr_t) noexcept; - template + template bool operator>(nullptr_t, const shared_ptr& b) noexcept; - template + template bool operator>=(const shared_ptr& a, nullptr_t) noexcept; - template + template bool operator>=(nullptr_t, const shared_ptr& b) noexcept; // \ref{util.smartptr.shared.spec}, \tcode{shared_ptr} specialized algorithms @@ -9561,8 +9562,8 @@ \begin{itemdecl} template shared_ptr(Y* p, D d); template shared_ptr(Y* p, D d, A a); -template shared_ptr(nullptr_t p, D d); -template shared_ptr(nullptr_t p, D d, A a); +template shared_ptr(nullptr_t p, D d); +template shared_ptr(nullptr_t p, D d, A a); \end{itemdecl} \begin{itemdescr} @@ -9673,7 +9674,7 @@ \indexlibrary{\idxcode{shared_ptr}!constructor}% \indexlibrary{\idxcode{unique_ptr}}% \begin{itemdecl} -template shared_ptr(unique_ptr&& r); +template shared_ptr(unique_ptr&& r); \end{itemdecl} \begin{itemdescr} @@ -9764,7 +9765,7 @@ \indexlibrarymember{operator=}{shared_ptr}% \begin{itemdecl} -template shared_ptr& operator=(unique_ptr&& r); +template shared_ptr& operator=(unique_ptr&& r); \end{itemdecl} \begin{itemdescr} @@ -10032,9 +10033,9 @@ \indexlibrarymember{operator==}{shared_ptr}% \begin{itemdecl} -template +template bool operator==(const shared_ptr& a, nullptr_t) noexcept; -template +template bool operator==(nullptr_t, const shared_ptr& a) noexcept; \end{itemdecl} @@ -10045,9 +10046,9 @@ \indexlibrarymember{operator"!=}{shared_ptr}% \begin{itemdecl} -template +template bool operator!=(const shared_ptr& a, nullptr_t) noexcept; -template +template bool operator!=(nullptr_t, const shared_ptr& a) noexcept; \end{itemdecl} @@ -10058,9 +10059,9 @@ \indexlibrarymember{operator<}{shared_ptr}% \begin{itemdecl} -template +template bool operator<(const shared_ptr& a, nullptr_t) noexcept; -template +template bool operator<(nullptr_t, const shared_ptr& a) noexcept; \end{itemdecl} @@ -10075,9 +10076,9 @@ \indexlibrarymember{operator>}{shared_ptr}% \begin{itemdecl} -template +template bool operator>(const shared_ptr& a, nullptr_t) noexcept; -template +template bool operator>(nullptr_t, const shared_ptr& a) noexcept; \end{itemdecl} @@ -10090,9 +10091,9 @@ \indexlibrarymember{operator<=}{shared_ptr}% \begin{itemdecl} -template +template bool operator<=(const shared_ptr& a, nullptr_t) noexcept; -template +template bool operator<=(nullptr_t, const shared_ptr& a) noexcept; \end{itemdecl} @@ -10105,9 +10106,9 @@ \indexlibrarymember{operator>=}{shared_ptr}% \begin{itemdecl} -template +template bool operator>=(const shared_ptr& a, nullptr_t) noexcept; -template +template bool operator>=(nullptr_t, const shared_ptr& a) noexcept; \end{itemdecl} @@ -10848,7 +10849,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{unique_ptr}}% \begin{itemdecl} -template struct hash>; +template struct hash>; \end{itemdecl} \begin{itemdescr} @@ -10863,7 +10864,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{shared_ptr}}% \begin{itemdecl} -template struct hash>; +template struct hash>; \end{itemdecl} \begin{itemdescr} @@ -10889,12 +10890,12 @@ bool operator!=(const memory_resource& a, const memory_resource& b) noexcept; // \ref{mem.poly.allocator.class}, class template \tcode{polymorphic_allocator} - template class polymorphic_allocator; + template class polymorphic_allocator; - template + template bool operator==(const polymorphic_allocator& a, const polymorphic_allocator& b) noexcept; - template + template bool operator!=(const polymorphic_allocator& a, const polymorphic_allocator& b) noexcept; @@ -11084,7 +11085,7 @@ \indexlibrary{\idxcode{polymorphic_allocator}}% \begin{codeblock} -template +template class polymorphic_allocator { memory_resource* memory_rsrc; // \expos @@ -11097,7 +11098,7 @@ polymorphic_allocator(const polymorphic_allocator& other) = default; - template + template polymorphic_allocator(const polymorphic_allocator& other) noexcept; polymorphic_allocator& @@ -11107,22 +11108,22 @@ Tp* allocate(size_t n); void deallocate(Tp* p, size_t n); - template + template void construct(T* p, Args&&... args); - template + template void construct(pair* p, piecewise_construct_t, tuple x, tuple y); - template + template void construct(pair* p); - template + template void construct(pair* p, U&& x, V&& y); - template + template void construct(pair* p, const pair& pr); - template + template void construct(pair* p, pair&& pr); - template + template void destroy(T* p); polymorphic_allocator select_on_container_copy_construction() const; @@ -11171,7 +11172,7 @@ \indexlibrary{\idxcode{polymorphic_allocator}!constructor}% \begin{itemdecl} -template +template polymorphic_allocator(const polymorphic_allocator& other) noexcept; \end{itemdecl} @@ -11221,7 +11222,7 @@ \indexlibrarymember{construct}{polymorphic_allocator}% \begin{itemdecl} -template +template void construct(T* p, Args&&... args); \end{itemdecl} @@ -11249,7 +11250,7 @@ \indexlibrarymember{construct}{polymorphic_allocator}% \begin{itemdecl} -template +template void construct(pair* p, piecewise_construct_t, tuple x, tuple y); \end{itemdecl} @@ -11336,7 +11337,7 @@ \indexlibrarymember{construct}{polymorphic_allocator}% \begin{itemdecl} -template +template void construct(pair* p); \end{itemdecl} @@ -11351,7 +11352,7 @@ \indexlibrarymember{construct}{polymorphic_allocator}% \begin{itemdecl} -template +template void construct(pair* p, U&& x, V&& y); \end{itemdecl} @@ -11368,7 +11369,7 @@ \indexlibrarymember{construct}{polymorphic_allocator}% \begin{itemdecl} -template +template void construct(pair* p, const pair& pr); \end{itemdecl} @@ -11385,7 +11386,7 @@ \indexlibrarymember{construct}{polymorphic_allocator}% \begin{itemdecl} -template +template void construct(pair* p, pair&& pr); \end{itemdecl} @@ -11402,7 +11403,7 @@ \indexlibrarymember{destroy}{polymorphic_allocator}% \begin{itemdecl} -template +template void destroy(T* p); \end{itemdecl} @@ -11443,7 +11444,7 @@ \indexlibrarymember{operator==}{polymorphic_allocator}% \begin{itemdecl} -template +template bool operator==(const polymorphic_allocator& a, const polymorphic_allocator& b) noexcept; \end{itemdecl} @@ -11456,7 +11457,7 @@ \indexlibrarymember{operator"!=}{polymorphic_allocator}% \begin{itemdecl} -template +template bool operator!=(const polymorphic_allocator& a, const polymorphic_allocator& b) noexcept; \end{itemdecl} @@ -12098,12 +12099,12 @@ \indexlibrary{\idxhdr{scoped_allocator}}% \begin{codeblock} // scoped allocator adaptor - template + template class scoped_allocator_adaptor; - template + template bool operator==(const scoped_allocator_adaptor& a, const scoped_allocator_adaptor& b) noexcept; - template + template bool operator!=(const scoped_allocator_adaptor& a, const scoped_allocator_adaptor& b) noexcept; \end{codeblock} @@ -12130,7 +12131,7 @@ \indexlibrary{\idxcode{scoped_allocator_adaptor}}% \begin{codeblock} namespace std { - template + template class scoped_allocator_adaptor : public OuterAlloc { private: using OuterTraits = allocator_traits; // \expos @@ -12152,24 +12153,24 @@ using propagate_on_container_swap = @\seebelow@; using is_always_equal = @\seebelow@; - template + template struct rebind { using other = scoped_allocator_adaptor< OuterTraits::template rebind_alloc, InnerAllocs...>; }; scoped_allocator_adaptor(); - template + template scoped_allocator_adaptor(OuterA2&& outerAlloc, const InnerAllocs&... innerAllocs) noexcept; scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept; scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept; - template + template scoped_allocator_adaptor( const scoped_allocator_adaptor& other) noexcept; - template + template scoped_allocator_adaptor( scoped_allocator_adaptor&& other) noexcept; @@ -12188,30 +12189,30 @@ void deallocate(pointer p, size_type n); size_type max_size() const; - template + template void construct(T* p, Args&&... args); - template + template void construct(pair* p, piecewise_construct_t, tuple x, tuple y); - template + template void construct(pair* p); - template + template void construct(pair* p, U&& x, V&& y); - template + template void construct(pair* p, const pair& x); - template + template void construct(pair* p, pair&& x); - template + template void destroy(T* p); scoped_allocator_adaptor select_on_container_copy_construction() const; }; - template + template bool operator==(const scoped_allocator_adaptor& a, const scoped_allocator_adaptor& b) noexcept; - template + template bool operator!=(const scoped_allocator_adaptor& a, const scoped_allocator_adaptor& b) noexcept; } @@ -12297,7 +12298,7 @@ \indexlibrary{\idxcode{scoped_allocator_adaptor}!constructor}% \begin{itemdecl} -template +template scoped_allocator_adaptor(OuterA2&& outerAlloc, const InnerAllocs&... innerAllocs) noexcept; \end{itemdecl} @@ -12337,7 +12338,7 @@ \indexlibrary{\idxcode{scoped_allocator_adaptor}!constructor}% \begin{itemdecl} -template +template scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept; \end{itemdecl} @@ -12353,7 +12354,7 @@ \indexlibrary{\idxcode{scoped_allocator_adaptor}!constructor}% \begin{itemdecl} -template +template scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept; \end{itemdecl} @@ -12458,7 +12459,7 @@ \indexlibrarymember{construct}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void construct(T* p, Args&&... args); \end{itemdecl} @@ -12499,7 +12500,7 @@ \indexlibrarymember{construct}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void construct(pair* p, piecewise_construct_t, tuple x, tuple y); \end{itemdecl} @@ -12573,7 +12574,7 @@ \indexlibrarymember{construct}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void construct(pair* p); \end{itemdecl} @@ -12587,7 +12588,7 @@ \indexlibrarymember{construct}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void construct(pair* p, U&& x, V&& y); \end{itemdecl} @@ -12603,7 +12604,7 @@ \indexlibrarymember{construct}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void construct(pair* p, const pair& x); \end{itemdecl} @@ -12619,7 +12620,7 @@ \indexlibrarymember{construct}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void construct(pair* p, pair&& x); \end{itemdecl} @@ -12635,7 +12636,7 @@ \indexlibrarymember{destroy}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template void destroy(T* p); \end{itemdecl} @@ -12661,7 +12662,7 @@ \indexlibrarymember{operator==}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template bool operator==(const scoped_allocator_adaptor& a, const scoped_allocator_adaptor& b) noexcept; \end{itemdecl} @@ -12680,7 +12681,7 @@ \indexlibrarymember{operator"!=}{scoped_allocator_adaptor}% \begin{itemdecl} -template +template bool operator!=(const scoped_allocator_adaptor& a, const scoped_allocator_adaptor& b) noexcept; \end{itemdecl} @@ -12712,68 +12713,68 @@ \begin{codeblock} namespace std { // \ref{func.invoke}, invoke - template + template result_of_t invoke(F&& f, Args&&... args); // \ref{refwrap}, \tcode{reference_wrapper} template class reference_wrapper; - template reference_wrapper ref(T&) noexcept; - template reference_wrapper cref(const T&) noexcept; - template void ref(const T&&) = delete; - template void cref(const T&&) = delete; + template reference_wrapper ref(T&) noexcept; + template reference_wrapper cref(const T&) noexcept; + template void ref(const T&&) = delete; + template void cref(const T&&) = delete; - template reference_wrapper ref(reference_wrapper) noexcept; - template reference_wrapper cref(reference_wrapper) noexcept; + template reference_wrapper ref(reference_wrapper) noexcept; + template reference_wrapper cref(reference_wrapper) noexcept; // \ref{arithmetic.operations}, arithmetic operations - template struct plus; - template struct minus; - template struct multiplies; - template struct divides; - template struct modulus; - template struct negate; - template <> struct plus; - template <> struct minus; - template <> struct multiplies; - template <> struct divides; - template <> struct modulus; - template <> struct negate; + template struct plus; + template struct minus; + template struct multiplies; + template struct divides; + template struct modulus; + template struct negate; + template<> struct plus; + template<> struct minus; + template<> struct multiplies; + template<> struct divides; + template<> struct modulus; + template<> struct negate; // \ref{comparisons}, comparisons - template struct equal_to; - template struct not_equal_to; - template struct greater; - template struct less; - template struct greater_equal; - template struct less_equal; - template <> struct equal_to; - template <> struct not_equal_to; - template <> struct greater; - template <> struct less; - template <> struct greater_equal; - template <> struct less_equal; + template struct equal_to; + template struct not_equal_to; + template struct greater; + template struct less; + template struct greater_equal; + template struct less_equal; + template<> struct equal_to; + template<> struct not_equal_to; + template<> struct greater; + template<> struct less; + template<> struct greater_equal; + template<> struct less_equal; // \ref{logical.operations}, logical operations - template struct logical_and; - template struct logical_or; - template struct logical_not; - template <> struct logical_and; - template <> struct logical_or; - template <> struct logical_not; + template struct logical_and; + template struct logical_or; + template struct logical_not; + template<> struct logical_and; + template<> struct logical_or; + template<> struct logical_not; // \ref{bitwise.operations}, bitwise operations - template struct bit_and; - template struct bit_or; - template struct bit_xor; - template struct bit_not; - template <> struct bit_and; - template <> struct bit_or; - template <> struct bit_xor; - template <> struct bit_not; + template struct bit_and; + template struct bit_or; + template struct bit_xor; + template struct bit_not; + template<> struct bit_and; + template<> struct bit_or; + template<> struct bit_xor; + template<> struct bit_not; // \ref{func.not_fn}, function template \tcode{not_fn} - template + template @\unspec@ not_fn(F&& f); // \ref{func.bind}, bind @@ -12859,20 +12860,20 @@ BinaryPredicate pred = BinaryPredicate()); // \ref{unord.hash}, hash function primary template - template + template struct hash; // \ref{func.default.traits}, default functor traits - template + template struct default_order; - template + template using default_order_t = typename default_order::type; // \ref{func.bind}, function object binders - template + template constexpr bool is_bind_expression_v = is_bind_expression::value; - template + template constexpr int is_placeholder_v = is_placeholder::value; } \end{codeblock} @@ -13003,7 +13004,7 @@ \indexlibrary{\idxcode{invoke}}% \indexlibrary{invoke@\tcode{\textit{INVOKE}}}% \begin{itemdecl} -template +template result_of_t invoke(F&& f, Args&&... args); \end{itemdecl} @@ -13019,7 +13020,7 @@ \indextext{function object!\idxcode{reference_wrapper}}% \begin{codeblock} namespace std { - template class reference_wrapper { + template class reference_wrapper { public : // types using type = T; @@ -13037,7 +13038,7 @@ T& get() const noexcept; // invocation - template + template result_of_t operator() (ArgTypes&&...) const; }; @@ -13110,7 +13111,7 @@ \indexlibrarymember{operator()}{reference_wrapper}% \begin{itemdecl} -template +template result_of_t operator()(ArgTypes&&... args) const; \end{itemdecl} @@ -13124,7 +13125,7 @@ \indexlibrarymember{ref}{reference_wrapper}% \begin{itemdecl} -template reference_wrapper ref(T& t) noexcept; +template reference_wrapper ref(T& t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -13133,7 +13134,7 @@ \indexlibrarymember{ref}{reference_wrapper}% \begin{itemdecl} -template reference_wrapper ref(reference_wrapper t) noexcept; +template reference_wrapper ref(reference_wrapper t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -13142,7 +13143,7 @@ \indexlibrarymember{cref}{reference_wrapper}% \begin{itemdecl} -template reference_wrapper cref(const T& t) noexcept; +template reference_wrapper cref(const T& t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -13151,7 +13152,7 @@ \indexlibrarymember{cref}{reference_wrapper}% \begin{itemdecl} -template reference_wrapper cref(reference_wrapper t) noexcept; +template reference_wrapper cref(reference_wrapper t) noexcept; \end{itemdecl} \begin{itemdescr} @@ -13168,7 +13169,7 @@ \indexlibrary{\idxcode{plus}}% \begin{itemdecl} -template struct plus { +template struct plus { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13184,8 +13185,8 @@ \indexlibrary{\idxcode{plus<>}}% \begin{itemdecl} -template <> struct plus { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct plus { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) + std::forward(u)); using is_transparent = @\unspec@; @@ -13194,7 +13195,7 @@ \indexlibrarymember{operator()}{plus<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) + std::forward(u)); \end{itemdecl} @@ -13206,7 +13207,7 @@ \indexlibrary{\idxcode{minus}}% \begin{itemdecl} -template struct minus { +template struct minus { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13222,8 +13223,8 @@ \indexlibrary{\idxcode{minus<>}}% \begin{itemdecl} -template <> struct minus { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct minus { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) - std::forward(u)); using is_transparent = @\unspec@; @@ -13232,7 +13233,7 @@ \indexlibrarymember{operator()}{minus<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) - std::forward(u)); \end{itemdecl} @@ -13244,7 +13245,7 @@ \indexlibrary{\idxcode{multiplies}}% \begin{itemdecl} -template struct multiplies { +template struct multiplies { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13260,8 +13261,8 @@ \indexlibrary{\idxcode{multiplies<>}}% \begin{itemdecl} -template <> struct multiplies { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct multiplies { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) * std::forward(u)); using is_transparent = @\unspec@; @@ -13270,7 +13271,7 @@ \indexlibrarymember{operator()}{multiplies<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) * std::forward(u)); \end{itemdecl} @@ -13282,7 +13283,7 @@ \indexlibrary{\idxcode{divides}}% \begin{itemdecl} -template struct divides { +template struct divides { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13298,8 +13299,8 @@ \indexlibrary{\idxcode{divides<>}}% \begin{itemdecl} -template <> struct divides { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct divides { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) / std::forward(u)); using is_transparent = @\unspec@; @@ -13308,7 +13309,7 @@ \indexlibrarymember{operator()}{divides<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) / std::forward(u)); \end{itemdecl} @@ -13320,7 +13321,7 @@ \indexlibrary{\idxcode{modulus}}% \begin{itemdecl} -template struct modulus { +template struct modulus { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13336,8 +13337,8 @@ \indexlibrary{\idxcode{modulus<>}}% \begin{itemdecl} -template <> struct modulus { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct modulus { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) % std::forward(u)); using is_transparent = @\unspec@; @@ -13346,7 +13347,7 @@ \indexlibrarymember{operator()}{modulus<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) % std::forward(u)); \end{itemdecl} @@ -13358,7 +13359,7 @@ \indexlibrary{\idxcode{negate}}% \begin{itemdecl} -template struct negate { +template struct negate { constexpr T operator()(const T& x) const; }; \end{itemdecl} @@ -13374,8 +13375,8 @@ \indexlibrary{\idxcode{negate<>}}% \begin{itemdecl} -template <> struct negate { - template constexpr auto operator()(T&& t) const +template<> struct negate { + template constexpr auto operator()(T&& t) const -> decltype(-std::forward(t)); using is_transparent = @\unspec@; @@ -13384,7 +13385,7 @@ \indexlibrarymember{operator()}{negate<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t) const +template constexpr auto operator()(T&& t) const -> decltype(-std::forward(t)); \end{itemdecl} @@ -13420,7 +13421,7 @@ \indexlibrary{\idxcode{equal_to}}% \begin{itemdecl} -template struct equal_to { +template struct equal_to { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13436,8 +13437,8 @@ \indexlibrary{\idxcode{equal_to<>}}% \begin{itemdecl} -template <> struct equal_to { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct equal_to { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) == std::forward(u)); using is_transparent = @\unspec@; @@ -13446,7 +13447,7 @@ \indexlibrarymember{operator()}{equal_to<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) == std::forward(u)); \end{itemdecl} @@ -13458,7 +13459,7 @@ \indexlibrary{\idxcode{not_equal_to}}% \begin{itemdecl} -template struct not_equal_to { +template struct not_equal_to { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13474,8 +13475,8 @@ \indexlibrary{\idxcode{not_equal_to<>}}% \begin{itemdecl} -template <> struct not_equal_to { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct not_equal_to { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) != std::forward(u)); using is_transparent = @\unspec@; @@ -13484,7 +13485,7 @@ \indexlibrarymember{operator()}{not_equal_to<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) != std::forward(u)); \end{itemdecl} @@ -13496,7 +13497,7 @@ \indexlibrary{\idxcode{greater}}% \begin{itemdecl} -template struct greater { +template struct greater { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13512,8 +13513,8 @@ \indexlibrary{\idxcode{greater<>}}% \begin{itemdecl} -template <> struct greater { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct greater { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) > std::forward(u)); using is_transparent = @\unspec@; @@ -13522,7 +13523,7 @@ \indexlibrarymember{operator()}{greater<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) > std::forward(u)); \end{itemdecl} @@ -13534,7 +13535,7 @@ \indexlibrary{\idxcode{less}}% \begin{itemdecl} -template struct less { +template struct less { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13550,8 +13551,8 @@ \indexlibrary{\idxcode{less<>}}% \begin{itemdecl} -template <> struct less { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct less { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) < std::forward(u)); using is_transparent = @\unspec@; @@ -13560,7 +13561,7 @@ \indexlibrarymember{operator()}{less<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) < std::forward(u)); \end{itemdecl} @@ -13572,7 +13573,7 @@ \indexlibrary{\idxcode{greater_equal}}% \begin{itemdecl} -template struct greater_equal { +template struct greater_equal { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13588,8 +13589,8 @@ \indexlibrary{\idxcode{greater_equal<>}}% \begin{itemdecl} -template <> struct greater_equal { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct greater_equal { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) >= std::forward(u)); using is_transparent = @\unspec@; @@ -13598,7 +13599,7 @@ \indexlibrarymember{operator()}{greater_equal<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) >= std::forward(u)); \end{itemdecl} @@ -13610,7 +13611,7 @@ \indexlibrary{\idxcode{less_equal}}% \begin{itemdecl} -template struct less_equal { +template struct less_equal { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13626,8 +13627,8 @@ \indexlibrary{\idxcode{less_equal<>}}% \begin{itemdecl} -template <> struct less_equal { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct less_equal { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) <= std::forward(u)); using is_transparent = @\unspec@; @@ -13636,7 +13637,7 @@ \indexlibrarymember{operator()}{less_equal<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) <= std::forward(u)); \end{itemdecl} @@ -13655,7 +13656,7 @@ \indexlibrary{\idxcode{logical_and}}% \begin{itemdecl} -template struct logical_and { +template struct logical_and { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13671,8 +13672,8 @@ \indexlibrary{\idxcode{logical_and<>}}% \begin{itemdecl} -template <> struct logical_and { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct logical_and { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) && std::forward(u)); using is_transparent = @\unspec@; @@ -13681,7 +13682,7 @@ \indexlibrarymember{operator()}{logical_and<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) && std::forward(u)); \end{itemdecl} @@ -13693,7 +13694,7 @@ \indexlibrary{\idxcode{logical_or}}% \begin{itemdecl} -template struct logical_or { +template struct logical_or { constexpr bool operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13709,8 +13710,8 @@ \indexlibrary{\idxcode{logical_or<>}}% \begin{itemdecl} -template <> struct logical_or { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct logical_or { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) || std::forward(u)); using is_transparent = @\unspec@; @@ -13719,7 +13720,7 @@ \indexlibrarymember{operator()}{logical_or<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) || std::forward(u)); \end{itemdecl} @@ -13731,7 +13732,7 @@ \indexlibrary{\idxcode{logical_not}}% \begin{itemdecl} -template struct logical_not { +template struct logical_not { constexpr bool operator()(const T& x) const; }; \end{itemdecl} @@ -13747,8 +13748,8 @@ \indexlibrary{\idxcode{logical_not<>}}% \begin{itemdecl} -template <> struct logical_not { - template constexpr auto operator()(T&& t) const +template<> struct logical_not { + template constexpr auto operator()(T&& t) const -> decltype(!std::forward(t)); using is_transparent = @\unspec@; @@ -13757,7 +13758,7 @@ \indexlibrarymember{operator()}{logical_not<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t) const +template constexpr auto operator()(T&& t) const -> decltype(!std::forward(t)); \end{itemdecl} @@ -13777,7 +13778,7 @@ \indexlibrary{\idxcode{bit_and}}% \begin{itemdecl} -template struct bit_and { +template struct bit_and { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13793,8 +13794,8 @@ \indexlibrary{\idxcode{bit_and<>}}% \begin{itemdecl} -template <> struct bit_and { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct bit_and { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) & std::forward(u)); using is_transparent = @\unspec@; @@ -13803,7 +13804,7 @@ \indexlibrarymember{operator()}{bit_and<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) & std::forward(u)); \end{itemdecl} @@ -13815,7 +13816,7 @@ \indexlibrary{\idxcode{bit_or}}% \begin{itemdecl} -template struct bit_or { +template struct bit_or { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13831,8 +13832,8 @@ \indexlibrary{\idxcode{bit_or<>}}% \begin{itemdecl} -template <> struct bit_or { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct bit_or { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) | std::forward(u)); using is_transparent = @\unspec@; @@ -13841,7 +13842,7 @@ \indexlibrarymember{operator()}{bit_or<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) | std::forward(u)); \end{itemdecl} @@ -13853,7 +13854,7 @@ \indexlibrary{\idxcode{bit_xor}}% \begin{itemdecl} -template struct bit_xor { +template struct bit_xor { constexpr T operator()(const T& x, const T& y) const; }; \end{itemdecl} @@ -13869,8 +13870,8 @@ \indexlibrary{\idxcode{bit_xor<>}}% \begin{itemdecl} -template <> struct bit_xor { - template constexpr auto operator()(T&& t, U&& u) const +template<> struct bit_xor { + template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) ^ std::forward(u)); using is_transparent = @\unspec@; @@ -13879,7 +13880,7 @@ \indexlibrarymember{operator()}{bit_xor<>}% \begin{itemdecl} -template constexpr auto operator()(T&& t, U&& u) const +template constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) ^ std::forward(u)); \end{itemdecl} @@ -13890,7 +13891,7 @@ \rSec3[bitwise.operations.not]{Class template \tcode{bit_not}} \begin{itemdecl} -template struct bit_not { +template struct bit_not { constexpr T operator()(const T& x) const; }; \end{itemdecl} @@ -13906,8 +13907,8 @@ \indexlibrary{\idxcode{bit_not<>}}% \begin{itemdecl} -template <> struct bit_not { - template constexpr auto operator()(T&& t) const +template<> struct bit_not { + template constexpr auto operator()(T&& t) const -> decltype(~std::forward(t)); using is_transparent = @\unspec@; @@ -13916,7 +13917,7 @@ \indexlibrarymember{operator()}{bit_not<>}% \begin{itemdecl} -template constexpr auto operator()(T&&) const +template constexpr auto operator()(T&&) const -> decltype(~std::forward(t)); \end{itemdecl} @@ -13929,7 +13930,7 @@ \indexlibrary{\idxcode{not_fn}}% \begin{itemdecl} -template @\unspec@ not_fn(F&& f); +template @\unspec@ not_fn(F&& f); \end{itemdecl} \begin{itemdescr} @@ -14347,20 +14348,20 @@ }; // \ref{func.wrap.func.nullptr}, Null pointer comparisons - template + template bool operator==(const function&, nullptr_t) noexcept; - template + template bool operator==(nullptr_t, const function&) noexcept; - template + template bool operator!=(const function&, nullptr_t) noexcept; - template + template bool operator!=(nullptr_t, const function&) noexcept; // \ref{func.wrap.func.alg}, specialized algorithms - template + template void swap(function&, function&) noexcept; } \end{codeblock} @@ -14636,9 +14637,9 @@ \indexlibrarymember{operator==}{function}% \begin{itemdecl} -template +template bool operator==(const function& f, nullptr_t) noexcept; -template +template bool operator==(nullptr_t, const function& f) noexcept; \end{itemdecl} @@ -14648,9 +14649,9 @@ \indexlibrarymember{operator"!=}{function}% \begin{itemdecl} -template +template bool operator!=(const function& f, nullptr_t) noexcept; -template +template bool operator!=(nullptr_t, const function& f) noexcept; \end{itemdecl} @@ -14707,7 +14708,7 @@ \indexlibrary{\idxcode{default_searcher}}% \begin{codeblock} -template > +template> class default_searcher { public: default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last, @@ -14766,7 +14767,7 @@ \indexlibrary{\idxcode{make_default_searcher}}% \begin{itemdecl} -template > +template> default_searcher make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last, BinaryPredicate pred = BinaryPredicate()); @@ -14785,7 +14786,7 @@ \indexlibrary{\idxcode{boyer_moore_searcher}}% \begin{codeblock} -template ::value_type>, class BinaryPredicate = equal_to<>> class boyer_moore_searcher { @@ -14795,7 +14796,7 @@ Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); - template + template pair operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const; @@ -14841,7 +14842,7 @@ \indexlibrarymember{operator()}{boyer_moore_searcher}% \begin{itemdecl} -template +template pair operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const; \end{itemdecl} @@ -14878,7 +14879,7 @@ \indexlibrary{\idxcode{make_boyer_moore_searcher}}% \begin{itemdecl} -template ::value_type>, class BinaryPredicate = equal_to<>> boyer_moore_searcher @@ -14902,7 +14903,7 @@ \indexlibrary{\idxcode{boyer_moore_horspool_searcher}}% \begin{codeblock} -template ::value_type>, class BinaryPredicate = equal_to<>> class boyer_moore_horspool_searcher { @@ -14912,7 +14913,7 @@ Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate()); - template + template pair operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const; @@ -14958,7 +14959,7 @@ \indexlibrarymember{operator()}{boyer_moore_horspool_searcher}% \begin{itemdecl} -template +template pair operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const; \end{itemdecl} @@ -14995,7 +14996,7 @@ \indexlibrary{\idxcode{make_boyer_moore_horspool_searcher}}% \begin{itemdecl} -template ::value_type>, class BinaryPredicate = equal_to<>> boyer_moore_horspool_searcher @@ -15077,7 +15078,7 @@ \indexlibrary{\idxcode{default_order}}% \begin{codeblock} namespace std { - template + template struct default_order { using type = less; }; @@ -15178,204 +15179,204 @@ \begin{codeblock} namespace std { // \ref{meta.help}, helper class - template struct integral_constant; + template struct integral_constant; - template + template using bool_constant = integral_constant; using true_type = bool_constant; using false_type = bool_constant; // \ref{meta.unary.cat}, primary type categories - template struct is_void; - template struct is_null_pointer; - template struct is_integral; - template struct is_floating_point; - template struct is_array; - template struct is_pointer; - template struct is_lvalue_reference; - template struct is_rvalue_reference; - template struct is_member_object_pointer; - template struct is_member_function_pointer; - template struct is_enum; - template struct is_union; - template struct is_class; - template struct is_function; + template struct is_void; + template struct is_null_pointer; + template struct is_integral; + template struct is_floating_point; + template struct is_array; + template struct is_pointer; + template struct is_lvalue_reference; + template struct is_rvalue_reference; + template struct is_member_object_pointer; + template struct is_member_function_pointer; + template struct is_enum; + template struct is_union; + template struct is_class; + template struct is_function; // \ref{meta.unary.comp}, composite type categories - template struct is_reference; - template struct is_arithmetic; - template struct is_fundamental; - template struct is_object; - template struct is_scalar; - template struct is_compound; - template struct is_member_pointer; + template struct is_reference; + template struct is_arithmetic; + template struct is_fundamental; + template struct is_object; + template struct is_scalar; + template struct is_compound; + template struct is_member_pointer; // \ref{meta.unary.prop}, type properties - template struct is_const; - template struct is_volatile; - template struct is_trivial; - template struct is_trivially_copyable; - template struct is_standard_layout; - template struct is_pod; - template struct is_empty; - template struct is_polymorphic; - template struct is_abstract; - template struct is_final; + template struct is_const; + template struct is_volatile; + template struct is_trivial; + template struct is_trivially_copyable; + template struct is_standard_layout; + template struct is_pod; + template struct is_empty; + template struct is_polymorphic; + template struct is_abstract; + template struct is_final; - template struct is_signed; - template struct is_unsigned; + template struct is_signed; + template struct is_unsigned; - template struct is_constructible; - template struct is_default_constructible; - template struct is_copy_constructible; - template struct is_move_constructible; + template struct is_constructible; + template struct is_default_constructible; + template struct is_copy_constructible; + template struct is_move_constructible; - template struct is_assignable; - template struct is_copy_assignable; - template struct is_move_assignable; + template struct is_assignable; + template struct is_copy_assignable; + template struct is_move_assignable; - template struct is_swappable_with; - template struct is_swappable; + template struct is_swappable_with; + template struct is_swappable; - template struct is_destructible; + template struct is_destructible; - template struct is_trivially_constructible; - template struct is_trivially_default_constructible; - template struct is_trivially_copy_constructible; - template struct is_trivially_move_constructible; + template struct is_trivially_constructible; + template struct is_trivially_default_constructible; + template struct is_trivially_copy_constructible; + template struct is_trivially_move_constructible; - template struct is_trivially_assignable; - template struct is_trivially_copy_assignable; - template struct is_trivially_move_assignable; - template struct is_trivially_destructible; + template struct is_trivially_assignable; + template struct is_trivially_copy_assignable; + template struct is_trivially_move_assignable; + template struct is_trivially_destructible; - template struct is_nothrow_constructible; - template struct is_nothrow_default_constructible; - template struct is_nothrow_copy_constructible; - template struct is_nothrow_move_constructible; + template struct is_nothrow_constructible; + template struct is_nothrow_default_constructible; + template struct is_nothrow_copy_constructible; + template struct is_nothrow_move_constructible; - template struct is_nothrow_assignable; - template struct is_nothrow_copy_assignable; - template struct is_nothrow_move_assignable; + template struct is_nothrow_assignable; + template struct is_nothrow_copy_assignable; + template struct is_nothrow_move_assignable; - template struct is_nothrow_swappable_with; - template struct is_nothrow_swappable; + template struct is_nothrow_swappable_with; + template struct is_nothrow_swappable; - template struct is_nothrow_destructible; + template struct is_nothrow_destructible; - template struct has_virtual_destructor; + template struct has_virtual_destructor; - template struct has_unique_object_representations; + template struct has_unique_object_representations; // \ref{meta.unary.prop.query}, type property queries - template struct alignment_of; - template struct rank; - template struct extent; + template struct alignment_of; + template struct rank; + template struct extent; // \ref{meta.rel}, type relations - template struct is_same; - template struct is_base_of; - template struct is_convertible; + template struct is_same; + template struct is_base_of; + template struct is_convertible; - template struct is_callable; // not defined - template + template struct is_callable; // not defined + template struct is_callable; - template struct is_nothrow_callable; // not defined - template + template struct is_nothrow_callable; // not defined + template struct is_nothrow_callable; // \ref{meta.trans.cv}, const-volatile modifications - template struct remove_const; - template struct remove_volatile; - template struct remove_cv; - template struct add_const; - template struct add_volatile; - template struct add_cv; - - template + template struct remove_const; + template struct remove_volatile; + template struct remove_cv; + template struct add_const; + template struct add_volatile; + template struct add_cv; + + template using remove_const_t = typename remove_const::type; - template + template using remove_volatile_t = typename remove_volatile::type; - template + template using remove_cv_t = typename remove_cv::type; - template + template using add_const_t = typename add_const::type; - template + template using add_volatile_t = typename add_volatile::type; - template + template using add_cv_t = typename add_cv::type; // \ref{meta.trans.ref}, reference modifications - template struct remove_reference; - template struct add_lvalue_reference; - template struct add_rvalue_reference; + template struct remove_reference; + template struct add_lvalue_reference; + template struct add_rvalue_reference; - template + template using remove_reference_t = typename remove_reference::type; - template + template using add_lvalue_reference_t = typename add_lvalue_reference::type; - template + template using add_rvalue_reference_t = typename add_rvalue_reference::type; // \ref{meta.trans.sign}, sign modifications - template struct make_signed; - template struct make_unsigned; + template struct make_signed; + template struct make_unsigned; - template + template using make_signed_t = typename make_signed::type; - template + template using make_unsigned_t = typename make_unsigned::type; // \ref{meta.trans.arr}, array modifications - template struct remove_extent; - template struct remove_all_extents; + template struct remove_extent; + template struct remove_all_extents; - template + template using remove_extent_t = typename remove_extent::type; - template + template using remove_all_extents_t = typename remove_all_extents::type; // \ref{meta.trans.ptr}, pointer modifications - template struct remove_pointer; - template struct add_pointer; + template struct remove_pointer; + template struct add_pointer; - template + template using remove_pointer_t = typename remove_pointer::type; - template + template using add_pointer_t = typename add_pointer::type; // \ref{meta.trans.other}, other transformations - template // see \ref{meta.trans.other} struct aligned_storage; - template struct aligned_union; - template struct decay; - template struct enable_if; - template struct conditional; - template struct common_type; - template struct underlying_type; - template class result_of; // not defined - template class result_of; - - template struct aligned_union; + template struct decay; + template struct enable_if; + template struct conditional; + template struct common_type; + template struct underlying_type; + template class result_of; // not defined + template class result_of; + + template // see \ref{meta.trans.other} using aligned_storage_t = typename aligned_storage::type; - template + template using aligned_union_t = typename aligned_union::type; - template + template using decay_t = typename decay::type; - template + template using enable_if_t = typename enable_if::type; - template + template using conditional_t = typename conditional::type; - template + template using common_type_t = typename common_type::type; - template + template using underlying_type_t = typename underlying_type::type; - template + template using result_of_t = typename result_of::type; - template + template using void_t = void; // \ref{meta.logical}, logical operator traits @@ -15384,155 +15385,155 @@ template struct negation; // \ref{meta.unary.cat}, primary type categories - template constexpr bool is_void_v + template constexpr bool is_void_v = is_void::value; - template constexpr bool is_null_pointer_v + template constexpr bool is_null_pointer_v = is_null_pointer::value; - template constexpr bool is_integral_v + template constexpr bool is_integral_v = is_integral::value; - template constexpr bool is_floating_point_v + template constexpr bool is_floating_point_v = is_floating_point::value; - template constexpr bool is_array_v + template constexpr bool is_array_v = is_array::value; - template constexpr bool is_pointer_v + template constexpr bool is_pointer_v = is_pointer::value; - template constexpr bool is_lvalue_reference_v + template constexpr bool is_lvalue_reference_v = is_lvalue_reference::value; - template constexpr bool is_rvalue_reference_v + template constexpr bool is_rvalue_reference_v = is_rvalue_reference::value; - template constexpr bool is_member_object_pointer_v + template constexpr bool is_member_object_pointer_v = is_member_object_pointer::value; - template constexpr bool is_member_function_pointer_v + template constexpr bool is_member_function_pointer_v = is_member_function_pointer::value; - template constexpr bool is_enum_v + template constexpr bool is_enum_v = is_enum::value; - template constexpr bool is_union_v + template constexpr bool is_union_v = is_union::value; - template constexpr bool is_class_v + template constexpr bool is_class_v = is_class::value; - template constexpr bool is_function_v + template constexpr bool is_function_v = is_function::value; // \ref{meta.unary.comp}, composite type categories - template constexpr bool is_reference_v + template constexpr bool is_reference_v = is_reference::value; - template constexpr bool is_arithmetic_v + template constexpr bool is_arithmetic_v = is_arithmetic::value; - template constexpr bool is_fundamental_v + template constexpr bool is_fundamental_v = is_fundamental::value; - template constexpr bool is_object_v + template constexpr bool is_object_v = is_object::value; - template constexpr bool is_scalar_v + template constexpr bool is_scalar_v = is_scalar::value; - template constexpr bool is_compound_v + template constexpr bool is_compound_v = is_compound::value; - template constexpr bool is_member_pointer_v + template constexpr bool is_member_pointer_v = is_member_pointer::value; // \ref{meta.unary.prop}, type properties - template constexpr bool is_const_v + template constexpr bool is_const_v = is_const::value; - template constexpr bool is_volatile_v + template constexpr bool is_volatile_v = is_volatile::value; - template constexpr bool is_trivial_v + template constexpr bool is_trivial_v = is_trivial::value; - template constexpr bool is_trivially_copyable_v + template constexpr bool is_trivially_copyable_v = is_trivially_copyable::value; - template constexpr bool is_standard_layout_v + template constexpr bool is_standard_layout_v = is_standard_layout::value; - template constexpr bool is_pod_v + template constexpr bool is_pod_v = is_pod::value; - template constexpr bool is_empty_v + template constexpr bool is_empty_v = is_empty::value; - template constexpr bool is_polymorphic_v + template constexpr bool is_polymorphic_v = is_polymorphic::value; - template constexpr bool is_abstract_v + template constexpr bool is_abstract_v = is_abstract::value; - template constexpr bool is_final_v + template constexpr bool is_final_v = is_final::value; - template constexpr bool is_signed_v + template constexpr bool is_signed_v = is_signed::value; - template constexpr bool is_unsigned_v + template constexpr bool is_unsigned_v = is_unsigned::value; - template constexpr bool is_constructible_v + template constexpr bool is_constructible_v = is_constructible::value; - template constexpr bool is_default_constructible_v + template constexpr bool is_default_constructible_v = is_default_constructible::value; - template constexpr bool is_copy_constructible_v + template constexpr bool is_copy_constructible_v = is_copy_constructible::value; - template constexpr bool is_move_constructible_v + template constexpr bool is_move_constructible_v = is_move_constructible::value; - template constexpr bool is_assignable_v + template constexpr bool is_assignable_v = is_assignable::value; - template constexpr bool is_copy_assignable_v + template constexpr bool is_copy_assignable_v = is_copy_assignable::value; - template constexpr bool is_move_assignable_v + template constexpr bool is_move_assignable_v = is_move_assignable::value; - template constexpr bool is_swappable_with_v + template constexpr bool is_swappable_with_v = is_swappable_with::value; - template constexpr bool is_swappable_v + template constexpr bool is_swappable_v = is_swappable::value; - template constexpr bool is_destructible_v + template constexpr bool is_destructible_v = is_destructible::value; - template constexpr bool is_trivially_constructible_v + template constexpr bool is_trivially_constructible_v = is_trivially_constructible::value; - template constexpr bool is_trivially_default_constructible_v + template constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible::value; - template constexpr bool is_trivially_copy_constructible_v + template constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible::value; - template constexpr bool is_trivially_move_constructible_v + template constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible::value; - template constexpr bool is_trivially_assignable_v + template constexpr bool is_trivially_assignable_v = is_trivially_assignable::value; - template constexpr bool is_trivially_copy_assignable_v + template constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable::value; - template constexpr bool is_trivially_move_assignable_v + template constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable::value; - template constexpr bool is_trivially_destructible_v + template constexpr bool is_trivially_destructible_v = is_trivially_destructible::value; - template constexpr bool is_nothrow_constructible_v + template constexpr bool is_nothrow_constructible_v = is_nothrow_constructible::value; - template constexpr bool is_nothrow_default_constructible_v + template constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible::value; - template constexpr bool is_nothrow_copy_constructible_v + template constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible::value; - template constexpr bool is_nothrow_move_constructible_v + template constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible::value; - template constexpr bool is_nothrow_assignable_v + template constexpr bool is_nothrow_assignable_v = is_nothrow_assignable::value; - template constexpr bool is_nothrow_copy_assignable_v + template constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable::value; - template constexpr bool is_nothrow_move_assignable_v + template constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable::value; - template constexpr bool is_nothrow_swappable_with_v + template constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with::value; - template constexpr bool is_nothrow_swappable_v + template constexpr bool is_nothrow_swappable_v = is_nothrow_swappable::value; - template constexpr bool is_nothrow_destructible_v + template constexpr bool is_nothrow_destructible_v = is_nothrow_destructible::value; - template constexpr bool has_virtual_destructor_v + template constexpr bool has_virtual_destructor_v = has_virtual_destructor::value; - template constexpr bool has_unique_object_representations_v + template constexpr bool has_unique_object_representations_v = has_unique_object_representations::value; // \ref{meta.unary.prop.query}, type property queries - template constexpr size_t alignment_of_v + template constexpr size_t alignment_of_v = alignment_of::value; - template constexpr size_t rank_v + template constexpr size_t rank_v = rank::value; - template constexpr size_t extent_v + template constexpr size_t extent_v = extent::value; // \ref{meta.rel}, type relations - template constexpr bool is_same_v + template constexpr bool is_same_v = is_same::value; - template constexpr bool is_base_of_v + template constexpr bool is_base_of_v = is_base_of::value; - template constexpr bool is_convertible_v + template constexpr bool is_convertible_v = is_convertible::value; - template constexpr bool is_callable_v + template constexpr bool is_callable_v = is_callable::value; - template constexpr bool is_nothrow_callable_v + template constexpr bool is_nothrow_callable_v = is_nothrow_callable::value; // \ref{meta.logical}, logical operator traits @@ -15554,7 +15555,7 @@ \begin{codeblock} namespace std { - template + template struct integral_constant { static constexpr T value = v; using value_type = T; @@ -15615,63 +15616,63 @@ \lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\ \capsep \endhead \indexlibrary{\idxcode{is_void}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_void;} & \tcode{T} is \tcode{void} & \\ \rowsep \indexlibrary{\idxcode{is_null_pointer}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_null_pointer;} & \tcode{T} is \tcode{nullptr_t}~(\ref{basic.fundamental}) & \\ \rowsep \indexlibrary{\idxcode{is_integral}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_integral;} & \tcode{T} is an integral type~(\ref{basic.fundamental}) & \\ \rowsep \indexlibrary{\idxcode{is_floating_point}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_floating_point;} & \tcode{T} is a floating-point type~(\ref{basic.fundamental}) & \\ \rowsep \indexlibrary{\idxcode{is_array}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_array;} & \tcode{T} is an array type~(\ref{basic.compound}) of known or unknown extent & Class template \tcode{array}~(\ref{array}) is not an array type. \\ \rowsep \indexlibrary{\idxcode{is_pointer}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_pointer;} & \tcode{T} is a pointer type~(\ref{basic.compound}) & Includes pointers to functions but not pointers to non-static members. \\ \rowsep \indexlibrary{\idxcode{is_lvalue_reference}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_lvalue_reference;} & \tcode{T} is an lvalue reference type~(\ref{dcl.ref}) & \\ \rowsep \indexlibrary{\idxcode{is_rvalue_reference}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_rvalue_reference;} & \tcode{T} is an rvalue reference type~(\ref{dcl.ref}) & \\ \rowsep \indexlibrary{\idxcode{is_member_object_pointer}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_member_object_pointer;}& \tcode{T} is a pointer to non-static data member & \\ \rowsep \indexlibrary{\idxcode{is_member_function_pointer}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_member_function_pointer;}& \tcode{T} is a pointer to non-static member function & \\ \rowsep \indexlibrary{\idxcode{is_enum}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_enum;} & \tcode{T} is an enumeration type~(\ref{basic.compound}) & \\ \rowsep \indexlibrary{\idxcode{is_union}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_union;} & \tcode{T} is a union type~(\ref{basic.compound}) & \\ \rowsep \indexlibrary{\idxcode{is_class}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_class;} & \tcode{T} is a non-union class type~(\ref{basic.compound}) & \\ \rowsep \indexlibrary{\idxcode{is_function}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_function;} & \tcode{T} is a function type~(\ref{basic.compound}) & \\ \end{libreqtab3e} @@ -15695,31 +15696,31 @@ \lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\ \capsep \endhead \indexlibrary{\idxcode{is_reference}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_reference;} & \tcode{T} is an lvalue reference or an rvalue reference & \\ \rowsep \indexlibrary{\idxcode{is_arithmetic}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_arithmetic;} & \tcode{T} is an arithmetic type~(\ref{basic.fundamental}) & \\ \rowsep \indexlibrary{\idxcode{is_fundamental}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_fundamental;} & \tcode{T} is a fundamental type~(\ref{basic.fundamental}) & \\ \rowsep \indexlibrary{\idxcode{is_object}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_object;} & \tcode{T} is an object type~(\ref{basic.types}) & \\ \rowsep \indexlibrary{\idxcode{is_scalar}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_scalar;} & \tcode{T} is a scalar type~(\ref{basic.types}) & \\ \rowsep \indexlibrary{\idxcode{is_compound}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_compound;} & \tcode{T} is a compound type~(\ref{basic.compound}) & \\ \rowsep \indexlibrary{\idxcode{is_member_pointer}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_member_pointer;} & \tcode{T} is a pointer to non-static data member or non-static member function & \\ @@ -15760,46 +15761,46 @@ \endhead \indexlibrary{\idxcode{is_const}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_const;} & \tcode{T} is const-qualified~(\ref{basic.type.qualifier}) & \\ \rowsep \indexlibrary{\idxcode{is_volatile}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_volatile;} & \tcode{T} is volatile-qualified~(\ref{basic.type.qualifier}) & \\ \rowsep \indexlibrary{\idxcode{is_trivial}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivial;} & \tcode{T} is a trivial type~(\ref{basic.types}) & \tcode{remove_all_extents_t} shall be a complete type or \cv{}~\tcode{void}. \\ \rowsep \indexlibrary{\idxcode{is_trivially_copyable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_copyable;} & \tcode{T} is a trivially copyable type~(\ref{basic.types}) & \tcode{remove_all_extents_t} shall be a complete type or \cv{}~\tcode{void}. \\ \rowsep \indexlibrary{\idxcode{is_standard_layout}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_standard_layout;} & \tcode{T} is a standard-layout type~(\ref{basic.types}) & \tcode{remove_all_extents_t} shall be a complete type or \cv{}~\tcode{void}. \\ \rowsep \indexlibrary{\idxcode{is_pod}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_pod;} & \tcode{T} is a POD type~(\ref{basic.types}) & \tcode{remove_all_extents_t} shall be a complete type or \cv{}~\tcode{void}. \\ \rowsep \indexlibrary{\idxcode{is_empty}!class}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_empty;} & \tcode{T} is a class type, but not a union type, with no non-static data members other than bit-fields of length 0, no virtual member functions, @@ -15808,19 +15809,19 @@ If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep \indexlibrary{\idxcode{is_polymorphic}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_polymorphic;} & \tcode{T} is a polymorphic class~(\ref{class.virtual}) & If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep \indexlibrary{\idxcode{is_abstract}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_abstract;} & \tcode{T} is an abstract class~(\ref{class.abstract}) & If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep \indexlibrary{\idxcode{is_final}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_final;} & \tcode{T} is a class type marked with the \grammarterm{class-virt-specifier} \tcode{final} (Clause~\ref{class}). \begin{note} A union is a class type that @@ -15828,21 +15829,21 @@ If \tcode{T} is a class type, \tcode{T} shall be a complete type. \\ \rowsep \indexlibrary{\idxcode{is_signed}!class}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_signed;} & If \tcode{is_arithmetic_v} is \tcode{true}, the same result as \tcode{T(-1) < T(0)}; otherwise, \tcode{false} & \\ \rowsep \indexlibrary{\idxcode{is_unsigned}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_unsigned;} & If \tcode{is_arithmetic_v} is \tcode{true}, the same result as \tcode{T(0) < T(-1)}; otherwise, \tcode{false} & \\ \rowsep \indexlibrary{\idxcode{is_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_constructible;} & For a function type \tcode{T} or for a \cv{}~\tcode{void} type \tcode{T}, @@ -15853,14 +15854,14 @@ or arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_default_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_default_constructible;} & \tcode{is_constructible_v} is \tcode{true}. & \tcode{T} shall be a complete type, \cv{}~\tcode{void}, or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_copy_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_copy_constructible;} & For a referenceable type \tcode{T} (\ref{defns.referenceable}), the same result as \tcode{is_constructible_v}, otherwise \tcode{false}. & @@ -15868,7 +15869,7 @@ or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_move_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_move_constructible;} & For a referenceable type \tcode{T}, the same result as \tcode{is_constructible_v}, otherwise \tcode{false}. & @@ -15876,7 +15877,7 @@ or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_assignable;} & The expression \tcode{declval() =} \tcode{declval()} is well-formed when treated as an unevaluated @@ -15891,7 +15892,7 @@ or arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_copy_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_copy_assignable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_assignable_v}, otherwise \tcode{false}. & @@ -15899,7 +15900,7 @@ or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_move_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_move_assignable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_assignable_v}, otherwise \tcode{false}. & @@ -15907,7 +15908,7 @@ or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_swappable_with}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_swappable_with;} & The expressions \tcode{swap(declval(), declval())} and \tcode{swap(declval(), declval())} are each well-formed @@ -15931,7 +15932,7 @@ arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_swappable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_swappable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_swappable_with_v}, @@ -15941,7 +15942,7 @@ an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_destructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_destructible;} & Either \tcode{T} is a reference type, or \tcode{T} is a complete object type @@ -15955,7 +15956,7 @@ or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct}\br \tcode{is_trivially_constructible;} & \tcode{is_constructible_v}\br +\tcode{template}\br \tcode{struct is_trivially_default_constructible;} & \tcode{is_trivially_constructible_v} is \tcode{true}. & \tcode{T} shall be a complete type, @@ -15974,7 +15975,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_copy_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_copy_constructible;} & For a referenceable type \tcode{T}, the same result as \tcode{is_trivially_constructible_v}, otherwise \tcode{false}. & @@ -15983,7 +15984,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_move_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_move_constructible;} & For a referenceable type \tcode{T}, the same result as \tcode{is_trivially_constructible_v}, otherwise \tcode{false}. & @@ -15992,7 +15993,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_assignable;} & \tcode{is_assignable_v} is \tcode{true} and the assignment, as defined by \tcode{is_assignable}, is known to call no operation that is not trivial @@ -16001,7 +16002,7 @@ or arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_copy_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_copy_assignable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_trivially_assignable_v}, otherwise \tcode{false}. & @@ -16010,7 +16011,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_move_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_move_assignable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_trivially_assignable_v}, otherwise \tcode{false}. & @@ -16018,7 +16019,7 @@ \cv{}~\tcode{void}, or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_trivially_destructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_trivially_destructible;} & \tcode{is_destructible_v} is \tcode{true} and the indicated destructor is known to be trivial. & @@ -16027,7 +16028,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_constructible;} & \tcode{is_constructible_v} is \tcode{true} and the @@ -16039,7 +16040,7 @@ or arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_default_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_default_constructible;} & \tcode{is_nothrow_constructible_v} is \tcode{true}. & \tcode{T} shall be a complete type, @@ -16047,7 +16048,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_copy_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_copy_constructible;} & For a referenceable type \tcode{T}, the same result as \tcode{is_nothrow_constructible_v}, otherwise \tcode{false}. & @@ -16056,7 +16057,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_move_constructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_move_constructible;} & For a referenceable type \tcode{T}, the same result as \tcode{is_nothrow_constructible_v}, otherwise \tcode{false}. & @@ -16064,7 +16065,7 @@ \cv{}~\tcode{void}, or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_assignable;} & \tcode{is_assignable_v} is \tcode{true} and the assignment is known not to throw any exceptions~(\ref{expr.unary.noexcept}). & @@ -16072,7 +16073,7 @@ or arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_copy_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_copy_assignable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_nothrow_assignable_v}, otherwise \tcode{false}. & @@ -16081,7 +16082,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_move_assignable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_move_assignable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_nothrow_assignable_v}, otherwise \tcode{false}. & @@ -16090,7 +16091,7 @@ bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_swappable_with}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_swappable_with;} & \tcode{is_swappable_with_v} is \tcode{true} and each \tcode{swap} expression of the definition of @@ -16101,7 +16102,7 @@ arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_swappable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_swappable;} & For a referenceable type \tcode{T}, the same result as \tcode{is_nothrow_swappable_with_v}, @@ -16111,7 +16112,7 @@ an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_destructible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_destructible;} & \tcode{is_destructible_v} is \tcode{true} and the indicated destructor is known not to throw any exceptions~(\ref{expr.unary.noexcept}). & @@ -16120,13 +16121,13 @@ bound. \\ \rowsep \indexlibrary{\idxcode{has_virtual_destructor}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct has_virtual_destructor;} & \tcode{T} has a virtual destructor~(\ref{class.dtor}) & If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep \indexlibrary{\idxcode{has_unique_object_representations}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct has_unique_object_representations;} & For an array type \tcode{T}, the same result as \tcode{has_unique_object_representations_v>}, @@ -16227,20 +16228,20 @@ \endhead \indexlibrary{\idxcode{alignment_of}}% -\tcode{template \br +\tcode{template\br struct alignment_of;} & \tcode{alignof(T)}.\br \requires{} \tcode{alignof(T)} shall be a valid expression~(\ref{expr.alignof}) \\ \rowsep \indexlibrary{\idxcode{rank}}% -\tcode{template \br +\tcode{template\br struct rank;} & If \tcode{T} names an array type, an integer value representing the number of dimensions of \tcode{T}; otherwise, 0. \\ \rowsep \indexlibrary{\idxcode{extent}}% -\tcode{template \br struct extent;} & If \tcode{T} is not an array type, or if it has rank less @@ -16300,12 +16301,12 @@ \topline \lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\ \capsep \endhead -\tcode{template }\br +\tcode{template}\br \tcode{struct is_same;} & \tcode{T} and \tcode{U} name the same type with the same cv-qualifications & \\ \rowsep \indexlibrary{\idxcode{is_base_of}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_base_of;} & \tcode{Base} is a base class of \tcode{Derived} (Clause~\ref{class.derived}) without regard to cv-qualifiers @@ -16321,7 +16322,7 @@ are, nonetheless, base classes. \end{note} \\ \rowsep \indexlibrary{\idxcode{is_convertible}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_convertible;} & \seebelow & \tcode{From} and \tcode{To} shall be complete @@ -16329,7 +16330,7 @@ bound, or \cv{}~\tcode{void} types. \\ \rowsep \indexlibrary{\idxcode{is_callable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_callable<}\br \tcode{Fn(ArgTypes...), R>;} & The expression \tcode{\textit{INVOKE}(declval(), declval()..., R)} @@ -16339,7 +16340,7 @@ arrays of unknown bound. \\ \rowsep \indexlibrary{\idxcode{is_nothrow_callable}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct is_nothrow_callable<}\br \tcode{Fn(ArgTypes...), R>;} & \tcode{is_callable_v<}\br\tcode{Fn(ArgTypes...), R>} is \tcode{true} and @@ -16421,7 +16422,7 @@ \endhead \indexlibrary{\idxcode{remove_const}}% -\tcode{template \br +\tcode{template\br struct remove_const;} & The member typedef \tcode{type} names the same type as \tcode{T} @@ -16431,7 +16432,7 @@ \tcode{const int*}. \end{example} \\ \rowsep \indexlibrary{\idxcode{remove_volatile}}% -\tcode{template \br +\tcode{template\br struct remove_volatile;} & The member typedef \tcode{type} names the same type as \tcode{T} @@ -16442,7 +16443,7 @@ \end{example} \\ \rowsep \indexlibrary{\idxcode{remove_cv}}% -\tcode{template \br +\tcode{template\br struct remove_cv;} & The member typedef \tcode{type} shall be the same as \tcode{T} except that any top-level cv-qualifier has been removed. @@ -16451,7 +16452,7 @@ evaluates to \tcode{const volatile int*}. \end{example} \\ \rowsep \indexlibrary{\idxcode{add_const}}% -\tcode{template \br +\tcode{template\br struct add_const;} & If \tcode{T} is a reference, function, or top-level const-qualified type, then \tcode{type} names @@ -16459,7 +16460,7 @@ \tcode{T const}. \\ \rowsep \indexlibrary{\idxcode{add_volatile}}% -\tcode{template \br +\tcode{template\br struct add_volatile;} & If \tcode{T} is a reference, function, or top-level volatile-qualified type, then \tcode{type} names @@ -16467,7 +16468,7 @@ \tcode{T volatile}. \\ \rowsep \indexlibrary{\idxcode{add_cv}}% -\tcode{template \br +\tcode{template\br struct add_cv;} & The member typedef \tcode{type} names the same type as @@ -16486,14 +16487,14 @@ \endhead \indexlibrary{\idxcode{remove_reference}}% -\tcode{template \br +\tcode{template\br struct remove_reference;} & If \tcode{T} has type ``reference to \tcode{T1}'' then the member typedef \tcode{type} names \tcode{T1}; otherwise, \tcode{type} names \tcode{T}.\\ \rowsep \indexlibrary{\idxcode{add_lvalue_reference}}% -\tcode{template \br +\tcode{template\br struct add_lvalue_reference;} & If \tcode{T} names a referenceable type (\ref{defns.referenceable}) then the member typedef \tcode{type} names \tcode{T\&}; @@ -16503,7 +16504,7 @@ \end{note}\\ \rowsep \indexlibrary{\idxcode{add_rvalue_reference}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct add_rvalue_reference;} & If \tcode{T} names a referenceable type then the member typedef \tcode{type} names \tcode{T\&\&}; @@ -16525,7 +16526,7 @@ \endhead \indexlibrary{\idxcode{make_signed}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct make_signed;} & If \tcode{T} names a (possibly cv-qualified) signed integer type~(\ref{basic.fundamental}) then the member typedef @@ -16542,7 +16543,7 @@ but not a \tcode{bool} type.\\ \rowsep \indexlibrary{\idxcode{make_unsigned}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct make_unsigned;} & If \tcode{T} names a (possibly cv-qualified) unsigned integer type~(\ref{basic.fundamental}) then the member typedef @@ -16571,7 +16572,7 @@ \endhead \indexlibrary{\idxcode{remove_extent}}% -\tcode{template \br +\tcode{template\br struct remove_extent;} & If \tcode{T} names a type ``array of \tcode{U}'', the member typedef \tcode{type} shall @@ -16581,7 +16582,7 @@ \tcode{const U}. \end{note} \\ \rowsep \indexlibrary{\idxcode{remove_all_extents}}% -\tcode{template \br +\tcode{template\br struct remove_all_extents;} & If \tcode{T} is ``multi-dimensional array of \tcode{U}'', the resulting member typedef \tcode{type} is \tcode{U}, otherwise \tcode{T}. \\ @@ -16620,14 +16621,14 @@ \endhead \indexlibrary{\idxcode{remove_pointer}}% -\tcode{template \br +\tcode{template\br struct remove_pointer;} & If \tcode{T} has type ``(possibly cv-qualified) pointer to \tcode{T1}'' then the member typedef \tcode{type} names \tcode{T1}; otherwise, it names \tcode{T}.\\ \rowsep \indexlibrary{\idxcode{add_pointer}}% -\tcode{template \br +\tcode{template\br struct add_pointer;} & If \tcode{T} names a referenceable type (\ref{defns.referenceable}) or a \cv{}~\tcode{void} type then @@ -16649,7 +16650,7 @@ \endhead \indexlibrary{\idxcode{aligned_storage}}% -\tcode{template \br struct aligned_storage;} @@ -16664,7 +16665,7 @@ \tcode{alignof(T)} for some type \tcode{T} or to \textit{default-alignment}.\\ \rowsep \indexlibrary{\idxcode{aligned_union}}% -\tcode{template \br struct aligned_union;} & @@ -16677,7 +16678,7 @@ \\ \rowsep \indexlibrary{\idxcode{decay}}% -\tcode{template \br struct decay;} +\tcode{template\br struct decay;} & Let \tcode{U} be \tcode{remove_reference_t}. If \tcode{is_array_v} is \tcode{true}, the member typedef \tcode{type} shall equal @@ -16692,20 +16693,20 @@ \\ \rowsep \indexlibrary{\idxcode{enable_if}}% -\tcode{template } \tcode{struct enable_if;} +\tcode{template} \tcode{struct enable_if;} & If \tcode{B} is \tcode{true}, the member typedef \tcode{type} shall equal \tcode{T}; otherwise, there shall be no member \tcode{type}. \\ \rowsep -\tcode{template }\br \tcode{struct conditional;} & If \tcode{B} is \tcode{true}, the member typedef \tcode{type} shall equal \tcode{T}. If \tcode{B} is \tcode{false}, the member typedef \tcode{type} shall equal \tcode{F}. \\ \rowsep - \tcode{template } \tcode{struct common_type;} + \tcode{template} \tcode{struct common_type;} & Unless this trait is specialized (as specified in Note B, below), the member \tcode{type} shall be defined or omitted as specified in Note A, below. @@ -16714,14 +16715,14 @@ complete, \cv{}~\tcode{void}, or an array of unknown bound. \\ \rowsep \indexlibrary{\idxcode{underlying_type}}% -\tcode{template }\br +\tcode{template}\br \tcode{struct underlying_type;} & The member typedef \tcode{type} names the underlying type of \tcode{T}.\br \requires{} \tcode{T} shall be a complete enumeration type~(\ref{dcl.enum}) \\ \rowsep -\tcode{template }\br \tcode{struct result_of<}\br \tcode{Fn(ArgTypes...)>;} @@ -16751,7 +16752,7 @@ \begin{note} A typical implementation would define \tcode{aligned_storage} as: \begin{codeblock} -template +template struct aligned_storage { typedef struct { alignas(Alignment) unsigned char __data[Len]; @@ -17000,21 +17001,21 @@ \begin{codeblockdigitsep} namespace std { // \ref{ratio.ratio}, class template \tcode{ratio} - template class ratio; + template class ratio; // \ref{ratio.arithmetic}, ratio arithmetic - template using ratio_add = @\seebelow@; - template using ratio_subtract = @\seebelow@; - template using ratio_multiply = @\seebelow@; - template using ratio_divide = @\seebelow@; + template using ratio_add = @\seebelow@; + template using ratio_subtract = @\seebelow@; + template using ratio_multiply = @\seebelow@; + template using ratio_divide = @\seebelow@; // \ref{ratio.comparison}, ratio comparison - template struct ratio_equal; - template struct ratio_not_equal; - template struct ratio_less; - template struct ratio_less_equal; - template struct ratio_greater; - template struct ratio_greater_equal; + template struct ratio_equal; + template struct ratio_not_equal; + template struct ratio_less; + template struct ratio_less_equal; + template struct ratio_greater; + template struct ratio_greater_equal; template constexpr bool ratio_equal_v = ratio_equal::value; @@ -17058,7 +17059,7 @@ \indexlibrary{\idxcode{ratio}}% \begin{codeblock} namespace std { - template + template class ratio { public: static constexpr intmax_t num; @@ -17160,19 +17161,19 @@ \indexlibrary{\idxcode{ratio_equal}}% \begin{itemdecl} -template +template struct ratio_equal : bool_constant { }; \end{itemdecl} \indexlibrary{\idxcode{ratio_not_equal}}% \begin{itemdecl} -template +template struct ratio_not_equal : bool_constant> { }; \end{itemdecl} \indexlibrary{\idxcode{ratio_less}}% \begin{itemdecl} -template +template struct ratio_less : bool_constant<@\seebelow@> { }; \end{itemdecl} @@ -17187,19 +17188,19 @@ \indexlibrary{\idxcode{ratio_less_equal}}% \begin{itemdecl} -template +template struct ratio_less_equal : bool_constant> { }; \end{itemdecl} \indexlibrary{\idxcode{ratio_greater}}% \begin{itemdecl} -template +template struct ratio_greater : bool_constant> { }; \end{itemdecl} \indexlibrary{\idxcode{ratio_greater_equal}}% \begin{itemdecl} -template +template struct ratio_greater_equal : bool_constant> { }; \end{itemdecl} @@ -17230,86 +17231,86 @@ namespace std { namespace chrono { // \ref{time.duration}, class template \tcode{duration} - template > class duration; + template> class duration; // \ref{time.point}, class template \tcode{time_point} - template class time_point; + template class time_point; } // \ref{time.traits.specializations}, \tcode{common_type} specializations - template + template struct common_type, chrono::duration>; - template + template struct common_type, chrono::time_point>; namespace chrono { // \ref{time.traits}, customization traits - template struct treat_as_floating_point; - template struct duration_values; - template constexpr bool treat_as_floating_point_v + template struct treat_as_floating_point; + template struct duration_values; + template constexpr bool treat_as_floating_point_v = treat_as_floating_point::value; // \ref{time.duration.nonmember}, \tcode{duration} arithmetic - template + template common_type_t, duration> constexpr operator+(const duration& lhs, const duration& rhs); - template + template common_type_t, duration> constexpr operator-(const duration& lhs, const duration& rhs); - template + template duration, Period> constexpr operator*(const duration& d, const Rep2& s); - template + template duration, Period> constexpr operator*(const Rep1& s, const duration& d); - template + template duration, Period> constexpr operator/(const duration& d, const Rep2& s); - template + template common_type_t constexpr operator/(const duration& lhs, const duration& rhs); - template + template duration, Period> constexpr operator%(const duration& d, const Rep2& s); - template + template common_type_t, duration> constexpr operator%(const duration& lhs, const duration& rhs); // \ref{time.duration.comparisons}, \tcode{duration} comparisons - template + template constexpr bool operator==(const duration& lhs, const duration& rhs); - template + template constexpr bool operator!=(const duration& lhs, const duration& rhs); - template + template constexpr bool operator< (const duration& lhs, const duration& rhs); - template + template constexpr bool operator<=(const duration& lhs, const duration& rhs); - template + template constexpr bool operator> (const duration& lhs, const duration& rhs); - template + template constexpr bool operator>=(const duration& lhs, const duration& rhs); // \ref{time.duration.cast}, \tcode{duration_cast} - template + template constexpr ToDuration duration_cast(const duration& d); - template + template constexpr ToDuration floor(const duration& d); - template + template constexpr ToDuration ceil(const duration& d); - template + template constexpr ToDuration round(const duration& d); // convenience typedefs @@ -17321,59 +17322,59 @@ using hours = duration<@\term{signed integer type of at least 23 bits}@, ratio<3600>>; // \ref{time.point.nonmember}, \tcode{time_point} arithmetic - template + template constexpr time_point>> operator+(const time_point& lhs, const duration& rhs); - template + template constexpr time_point, Duration2>> operator+(const duration& lhs, const time_point& rhs); - template + template constexpr time_point>> operator-(const time_point& lhs, const duration& rhs); - template + template constexpr common_type_t operator-(const time_point& lhs, const time_point& rhs); // \ref{time.point.comparisons}, \tcode{time_point} comparisons - template + template constexpr bool operator==(const time_point& lhs, const time_point& rhs); - template + template constexpr bool operator!=(const time_point& lhs, const time_point& rhs); - template + template constexpr bool operator< (const time_point& lhs, const time_point& rhs); - template + template constexpr bool operator<=(const time_point& lhs, const time_point& rhs); - template + template constexpr bool operator> (const time_point& lhs, const time_point& rhs); - template + template constexpr bool operator>=(const time_point& lhs, const time_point& rhs); // \ref{time.point.cast}, \tcode{time_point_cast} - template + template constexpr time_point time_point_cast(const time_point& t); - template + template constexpr time_point floor(const time_point& tp); - template + template constexpr time_point ceil(const time_point& tp); - template + template constexpr time_point round(const time_point& tp); // \ref{time.duration.alg}, specialized algorithms - template + template constexpr duration abs(duration d); // \ref{time.clock}, clocks @@ -17497,7 +17498,7 @@ \indexlibrary{\idxcode{treat_as_floating_point}}% \begin{itemdecl} -template struct treat_as_floating_point +template struct treat_as_floating_point : is_floating_point { }; \end{itemdecl} @@ -17519,7 +17520,7 @@ \indexlibrary{\idxcode{duration_values}}% \begin{itemdecl} -template +template struct duration_values { public: static constexpr Rep zero(); @@ -17581,7 +17582,7 @@ \indexlibrary{\idxcode{common_type}}% \begin{itemdecl} -template +template struct common_type, chrono::duration> { using type = chrono::duration, @\seebelow@>; }; @@ -17605,7 +17606,7 @@ \indexlibrary{\idxcode{common_type}}% \begin{itemdecl} -template +template struct common_type, chrono::time_point> { using type = chrono::time_point>; }; @@ -17625,7 +17626,7 @@ \indexlibrary{\idxcode{duration}}% \begin{codeblock} -template > +template> class duration { public: using rep = Rep; @@ -17635,9 +17636,9 @@ public: // \ref{time.duration.cons}, construct/copy/destroy constexpr duration() = default; - template + template constexpr explicit duration(const Rep2& r); - template + template constexpr duration(const duration& d); ~duration() = default; duration(const duration&) = default; @@ -17702,7 +17703,7 @@ \indexlibrary{\idxcode{duration}!constructor}% \begin{itemdecl} -template +template constexpr explicit duration(const Rep2& r); \end{itemdecl} @@ -17731,7 +17732,7 @@ \indexlibrary{\idxcode{duration}!constructor}% \begin{itemdecl} -template +template constexpr duration(const duration& d); \end{itemdecl} @@ -17957,7 +17958,7 @@ \indexlibrary{\idxcode{common_type}}% \begin{itemdecl} -template +template constexpr common_type_t, duration> operator+(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -17969,7 +17970,7 @@ \indexlibrary{\idxcode{common_type}}% \begin{itemdecl} -template +template constexpr common_type_t, duration> operator-(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -17981,7 +17982,7 @@ \indexlibrarymember{operator*}{duration}% \begin{itemdecl} -template +template constexpr duration, Period> operator*(const duration& d, const Rep2& s); \end{itemdecl} @@ -17997,7 +17998,7 @@ \indexlibrarymember{operator*}{duration}% \begin{itemdecl} -template +template constexpr duration, Period> operator*(const Rep1& s, const duration& d); \end{itemdecl} @@ -18013,7 +18014,7 @@ \indexlibrarymember{operator/}{duration}% \begin{itemdecl} -template +template constexpr duration, Period> operator/(const duration& d, const Rep2& s); \end{itemdecl} @@ -18030,7 +18031,7 @@ \indexlibrarymember{operator/}{duration}% \begin{itemdecl} -template +template constexpr common_type_t operator/(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18042,7 +18043,7 @@ \indexlibrarymember{operator\%}{duration}% \begin{itemdecl} -template +template constexpr duration, Period> operator%(const duration& d, const Rep2& s); \end{itemdecl} @@ -18059,7 +18060,7 @@ \indexlibrarymember{operator\%}{duration}% \begin{itemdecl} -template +template constexpr common_type_t, duration> operator%(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18079,7 +18080,7 @@ \indexlibrarymember{operator==}{duration}% \begin{itemdecl} -template +template constexpr bool operator==(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18091,7 +18092,7 @@ \indexlibrarymember{operator"!=}{duration}% \begin{itemdecl} -template +template constexpr bool operator!=(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18103,7 +18104,7 @@ \indexlibrarymember{operator<}{duration}% \begin{itemdecl} -template +template constexpr bool operator<(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18115,7 +18116,7 @@ \indexlibrarymember{operator<=}{duration}% \begin{itemdecl} -template +template constexpr bool operator<=(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18127,7 +18128,7 @@ \indexlibrarymember{operator>}{duration}% \begin{itemdecl} -template +template constexpr bool operator>(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18139,7 +18140,7 @@ \indexlibrarymember{operator>=}{duration}% \begin{itemdecl} -template +template constexpr bool operator>=(const duration& lhs, const duration& rhs); \end{itemdecl} @@ -18154,7 +18155,7 @@ \indexlibrary{\idxcode{duration}!\idxcode{duration_cast}}% \indexlibrary{\idxcode{duration_cast}}% \begin{itemdecl} -template +template constexpr ToDuration duration_cast(const duration& d); \end{itemdecl} @@ -18204,7 +18205,7 @@ \indexlibrarymember{floor}{duration}% \begin{itemdecl} -template +template constexpr ToDuration floor(const duration& d); \end{itemdecl} @@ -18220,7 +18221,7 @@ \indexlibrarymember{ceil}{duration}% \begin{itemdecl} -template +template constexpr ToDuration ceil(const duration& d); \end{itemdecl} @@ -18236,7 +18237,7 @@ \indexlibrarymember{round}{duration}% \begin{itemdecl} -template +template constexpr ToDuration round(const duration& d); \end{itemdecl} @@ -18365,7 +18366,7 @@ \indexlibrarymember{abs}{duration}% \begin{itemdecl} -template +template constexpr duration abs(duration d); \end{itemdecl} @@ -18383,7 +18384,7 @@ \indexlibrary{\idxcode{time_point}}% \begin{codeblock} -template +template class time_point { public: using clock = Clock; @@ -18397,7 +18398,7 @@ // \ref{time.point.cons}, construct constexpr time_point(); // has value epoch constexpr explicit time_point(const duration& d); // same as \tcode{time_point() + d} - template + template constexpr time_point(const time_point& t); // \ref{time.point.observer}, observer @@ -18448,7 +18449,7 @@ \indexlibrary{\idxcode{time_point}!constructor}% \begin{itemdecl} -template +template constexpr time_point(const time_point& t); \end{itemdecl} @@ -18529,7 +18530,7 @@ \indexlibrarymember{operator+}{time_point}% \indexlibrarymember{operator+}{duration}% \begin{itemdecl} -template +template constexpr time_point>> operator+(const time_point& lhs, const duration& rhs); \end{itemdecl} @@ -18542,7 +18543,7 @@ \indexlibrarymember{operator+}{time_point}% \indexlibrarymember{operator+}{duration}% \begin{itemdecl} -template +template constexpr time_point, Duration2>> operator+(const duration& lhs, const time_point& rhs); \end{itemdecl} @@ -18555,7 +18556,7 @@ \indexlibrarymember{operator-}{time_point}% \indexlibrarymember{operator-}{duration}% \begin{itemdecl} -template +template constexpr time_point>> operator-(const time_point& lhs, const duration& rhs); \end{itemdecl} @@ -18568,7 +18569,7 @@ \indexlibrarymember{operator-}{time_point}% \begin{itemdecl} -template +template constexpr common_type_t operator-(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18582,7 +18583,7 @@ \indexlibrarymember{operator==}{time_point}% \begin{itemdecl} -template +template constexpr bool operator==(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18594,7 +18595,7 @@ \indexlibrarymember{operator"!=}{time_point}% \begin{itemdecl} -template +template constexpr bool operator!=(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18606,7 +18607,7 @@ \indexlibrarymember{operator<}{time_point}% \begin{itemdecl} -template +template constexpr bool operator<(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18618,7 +18619,7 @@ \indexlibrarymember{operator<=}{time_point}% \begin{itemdecl} -template +template constexpr bool operator<=(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18630,7 +18631,7 @@ \indexlibrarymember{operator>}{time_point}% \begin{itemdecl} -template +template constexpr bool operator>(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18642,7 +18643,7 @@ \indexlibrarymember{operator>=}{time_point}% \begin{itemdecl} -template +template constexpr bool operator>=(const time_point& lhs, const time_point& rhs); \end{itemdecl} @@ -18657,7 +18658,7 @@ \indexlibrary{\idxcode{time_point}!\idxcode{time_point_cast}}% \indexlibrary{\idxcode{time_point_cast}}% \begin{itemdecl} -template +template constexpr time_point time_point_cast(const time_point& t); \end{itemdecl} @@ -18676,7 +18677,7 @@ \indexlibrarymember{floor}{time_point}% \begin{itemdecl} -template +template constexpr time_point floor(const time_point& tp); \end{itemdecl} @@ -18692,7 +18693,7 @@ \indexlibrarymember{ceil}{time_point}% \begin{itemdecl} -template +template constexpr time_point ceil(const time_point& tp); \end{itemdecl} @@ -18708,7 +18709,7 @@ \indexlibrarymember{round}{time_point}% \begin{itemdecl} -template +template constexpr time_point round(const time_point& tp); \end{itemdecl} @@ -18913,7 +18914,7 @@ \begin{codeblock} namespace std { class type_index; - template struct hash; + template struct hash; template<> struct hash; } \end{codeblock} @@ -19045,7 +19046,7 @@ \indexlibrary{\idxcode{hash}!\idxcode{type_index}}% \begin{itemdecl} -template <> struct hash; +template<> struct hash; \end{itemdecl} \begin{itemdescr}