During the Rapperswil meeting the Library Working Group decided to revise the library to change specifications stating Throws: Nothing to specify noexcept
This paper presents proposed wording for this change. However, it does not go further than removing Throws: Nothing. For example, it does not eliminate cluases of the form Throws: Nothing unless ... and similiar clauses.
The paper partially addresses National Body comments CH 16 and GB 60.
All changes in this paper are against N3126.
typedef unspecified exception_ptr; exception_ptr current_exception()noexcept;
exception_ptr current_exception() noexcept;
8 Throws: nothing.
Header <initializer_list> synopsis
namespace std { template<class E> class initializer_list { public: typedef E value_type; typedef const E& reference; typedef const E& const_reference; typedef size_t size_type; typedef const E* iterator; typedef const E* const_iterator; initializer_list() noexcept; size_t size() const noexcept; // number of elements const E* begin() const noexcept; // first element const E* end() const noexcept; // one past the last element }; // 18.9.3 initializer list range access template<class E> const E* begin(initializer_list<E> il); template<class E> const E* end(initializer_list<E> il); }
initializer_list() noexcept;
3. Throws: nothing.
const E* begin() const noexcept;
2. Throws: nothing.
const E* end() const noexcept;
4. Throws: nothing.
size_t size() const noexcept;
6. Throws: nothing.
... // 19.5.4 Comparison operators: bool operator==(const error_code& lhs, const error_code& rhs) noexcept; bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
namespace std { class error_category { public: virtual ~error_category(); error_category(const error_category&) = delete; error_category& operator=(const error_category&) = delete; virtual const char* name() const noexcept = 0; virtual error_condition default_error_condition(int ev) const noexcept; virtual bool equivalent(int code, const error_condition& condition) const noexcept; virtual bool equivalent(const error_code& code, int condition) const noexcept; virtual string message(int ev) const = 0; bool operator==(const error_category& rhs) const; bool operator!=(const error_category& rhs) const; bool operator<(const error_category& rhs) const noexcept; }; const error_category& generic_category(); const error_category& system_category(); } // namespace std
virtual const char* name()const noexcept = 0;
2. Throws: nothing.
virtual error_condition default_error_condition(int ev) const noexcept;
4. Throws: nothing.
virtual bool equivalent(int code, const error_condition& condition) const noexcept;
6. Throws: nothing.
virtual bool equivalent(const error_code& code, int condition) const noexcept;
8. Throws: nothing.
bool operator<(const error_category& rhs) const noexcept;
4. Throws: nothing.
Before p.1
virtual const char* name() const noexcept = 0;
2. Throws: nothing.
After p. 2
virtual error_condition default_error_condition(int ev) const noexcept;
4. Throws: nothing.
After p. 4
virtual bool equivalent(int code, const error_condition& condition) const noexcept;
6. Throws: nothing.
After p. 6
virtual bool equivalent(const error_code& code, int condition) const noexcept;
8. Throws: nothing.
After p.1
namespace std { class error_code { public: // 19.5.2.2 constructors: error_code() noexcept; error_code(int val, const error_category& cat) noexcept; template <class ErrorCodeEnum> error_code(ErrorCodeEnum e) noexcept; // 19.5.2.3 modifiers: void assign(int val, const error_category& cat) noexcept; template <class ErrorCodeEnum> errorcode& operator=(ErrorCodeEnum e) noexcept; void clear(); // 19.5.2.4 observers: int value() const noexcept; const error_category& category() const noexcept; error_condition default_error_condition() const noexcept; string message() const; explicit operator bool() const noexcept; private: int val_; // exposition only const error_category* cat_; // exposition only }; // 19.5.2.5 non-member functions: bool operator<(const error_code& lhs, const error_code& rhs) noexcept; template <class charT, class traits> basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& os, const error_code& ec); } // namespace std
Before p. 1
error_code() noexcept;
3. Throws: Nothing.
After p. 3
error_code(int val, const error_category& cat) noexcept;
6. Throws: Nothing.
After p. 6
template <class ErrorCodeEnum> error_code(ErrorCodeEnum e) noexcept;
9. Throws: Nothing.
Before p. 1
void assign(int val, const error_category& cat) noexcept;
2. Throws: Nothing.
After p. 2
template <class ErrorCodeEnum> error_code& operator=(ErrorCodeEnum e) noexcept;
5. Throws: Nothing.
Before p. 1
int value() const noexcept;
2. Throws: Nothing.
After p. 2
const error_category& category() const noexcept;
4. Throws: Nothing.
After p. 4
error_condition default_error_condition() const noexcept;
6. Throws: Nothing.
After p. 7
explicit operator bool() const noexcept;
9. Throws: Nothing.
Before p. 1
bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
2. Throws: Nothing.
After p.1
namespace std { class error_condition { public: // 19.5.3.2 constructors: error_condition() noexcept; error_condition(int val, const error_category& cat) noexcept; template <class ErrorConditionEnum> error_condition(ErrorConditionEnum e) noexcept; // 19.5.3.3 modifiers: void assign(int val, const error_category& cat) noexcept; template<class ErrorConditionEnum> error_condition& operator=(ErrorConditionEnum e) noexcept; void clear(); // 19.5.3.4 observers: int value() const noexcept; const error_category& category() const noexcept; string message() const; explicit operator bool() const noexcept; private: int val_; // exposition only const error_category* cat_; // exposition only }; // 19.5.3.5 non-member functions: bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; } // namespace std
Before p. 1
error_condition() noexcept;
3 Throws: Nothing.
After p. 3
error_condition(int val, const error_category& cat) noexcept;
6 Throws: Nothing.
After p. 6
template <class ErrorConditionEnum> error_condition(ErrorConditionEnum e) noexcept;
9 Throws: Nothing.
Before p. 1
void assign(int val, const error_category& cat) noexcept;
2 Throws: Nothing.
After p. 2
template <class ErrorConditionEnum> error_condition& operator=(ErrorConditionEnum e) noexcept;
5 Throws: Nothing.
Before p. 1
int value() const noexcept;
2 Throws: Nothing.
After p. 2
const error_category& category() const noexcept;
4 Throws: Nothing.
After p. 5
explicit operator bool() const noexcept;
7 Throws: Nothing.
Before p. 1
bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
2 Throws: Nothing.
Before p. 1
bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
2 Throws: Nothing.
After p. 2
bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
4 Throws: Nothing.
After p. 4
bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
6 Throws: Nothing.
After p. 6
bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
8 Throws: Nothing.
After p. 8
bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
10 Throws: Nothing.
After p. 1
... template<size_t I, class T1, class T2> typename tuple_element<I, std::pair<T1, T2> >::type& get(pair<T1, T2>&) noexcept; template<size_t I, class T1, class T2> const typename tuple_element<I, std::pair<T1, T2> >::type& get(const pair<T1, T2>&) noexcept; ...
After p. 4
template<size_t I, class T1, class T2> typename tuple_element<I, std::pair<T1, T2> >::type& get(pair<T1, T2>&) noexcept; template<size_t I, class T1, class T2> const typename tuple_element<I, std::pair<T1, T2> >::type& get(const pair<T1, T2>&) noexcept;
6 Throws: Nothing.
After p. 1
... template <size_t I, class... Types> typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>&) noexcept; template <size_t I, class... Types> typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>&) noexcept; ...
Before p. 1
template <size_t I, class... Types> typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>& t) noexcept;
3 Throws: Nothing.
After p. 3
template <size_t I, class... Types> typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>& t) noexcept;
6 Throws: Nothing.
After p. 1
... // element access: constexpr bool operator[](size_t pos) const noexcept; // for b[i]; reference operator[](size_t pos) noexcept; // for b[i]; ...
After p. 48
constexpr bool operator[](size_t pos) noexcept;
50 Throws: Nothing.
After p. 51
bitset<N>::reference operator[](size_t pos) noexcept;
53 Throws: Nothing.
After p. 1
... // 20.8.4, reference_wrapper: template <class T>class reference_wrapper; template <class T>reference_wrapper<T> ref(T&) noexcept; template <class T>reference_wrapper<const T> cref(const T&) noexcept; template <class T>void ref(const T&&) = delete; template <class T>void cref(const T&&) = delete; template <class T>reference_wrapper<T> ref(reference_wrapper<T>) noexcept; template <class T>reference_wrapper<const T> cref(reference_wrapper<T>) noexcept; ... // 20.8.13, member function adaptors: template<class R, class T> unspecified mem_fn(R T::*) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...)) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&) noexcept; ...
namespace std { template <class T> class reference_wrapper : public unary_function<T1, R> // see below : public binary_function<T1, T2, R> // see below { public : // types typedef T type; typedef see below result_type; // not always defined // construct/copy/destroy reference_wrapper(T&) noexcept; reference_wrapper(T&&) = delete; // do not bind to temporary objects reference_wrapper(const reference_wrapper<T>& x) noexcept; // assignment reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept; // access operator T& () const noexcept; T& get() const noexcept; // invocation template <class... ArgTypes> typename result_of<T(ArgTypes...)>::type operator() (ArgTypes&&...) const; }; }
Before p. 1
reference_wrapper(T& t) noexcept;
2 Throws: nothing.
After p. 2
reference_wrapper(const reference_wrapper<T>& x) noexcept;
4 Throws: nothing.
Before p. 1
reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
2 Throws: nothing.
Before p. 1
operator T& () const noexcept;
2 Throws: nothing.
After p. 2
T& get() const noexcept;
4 Throws: nothing.
Before p. 1
template <class T> reference_wrapper<T> ref(T& t) noexcept;
2 Throws: nothing.
After p. 2
template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
4 Throws: nothing.
After p. 4
template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
6 Throws: nothing.
After p. 6
template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
8 Throws: nothing.
Before p. 1
template<class R, class T> unspecified mem_fn(R T::* pm) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...)) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) const) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) const &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) &&) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) const &&) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&) noexcept; template<class R, class T, class... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&) noexcept;
4 Throws: nothing.
Before p.1
namespace std { template<class> class function; // undefined template<class R, class... ArgTypes> class function<R(ArgTypes...)> : public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and ArgTypes contains T1 : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and ArgTypes contains T1 and T2 { public: typedef R result_type; // 20.8.14.2.1, construct/copy/destroy: function() noexcept; function(nullptr_t) noexcept; function(const function&); function(function&&); template<class F> function(F); template<class A> function(allocator_arg_t, const A&) noexcept; template<class A> function(allocator_arg_t, const A&, nullptr_t) noexcept; template<class A> function(allocator_arg_t, const A&, const function&); template<class A> function(allocator_arg_t, const A&, function&&); template<class F, class A> function(allocator_arg_t, const A&, F); function& operator=(const function&); function& operator=(function&&); function& operator=(nullptr_t); template<class F> function& operator=(F&&); template<class F> function& operator=(reference_wrapper<F>) noexcept; ~function(); // 20.8.14.2.2, function modifiers: void swap(function&) noexcept; template<class F, class A> void assign(F&&, const A&); // 20.8.14.2.3, function capacity: explicit operator bool() const noexcept; // deleted overloads close possible hole in the type system template<class R2, class... ArgTypes2> bool operator==(const function<R2(ArgTypes2...)>&) = delete; template<class R2, class... ArgTypes2> bool operator!=(const function<R2(ArgTypes2...)>&) = delete; // 20.8.14.2.4, function invocation: R operator()(ArgTypes...) const; // 20.8.14.2.5, function target access: const std::type_info& target_type() const noexcept; template <typename T> T* target() noexcept; template <typename T> const T* target() const noexcept; }; // 20.8.14.2.6, Null pointer comparisons: template <class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; template <class R, class... ArgTypes> bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; // 20.8.14.2.7, specialized algorithms: template <class R, class... ArgTypes> void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&); template<class R, class... ArgTypes, class Alloc> struct uses_allocator<function<R(ArgTypes...)>, Alloc> : true_type { }; }
After p. 1
function() noexcept; template <class A> function(allocator_arg_t, const A& a) noexcept;
3 Throws: nothing.
After p. 3
function(nullptr_t) noexcept; template <class A> function(allocator_arg_t, const A& a, nullptr_t) noexcept;
3 Throws: nothing.
After p. 21
template<class F> function& operator=(reference_wrapper<F> f) noexcept;
24 Throws: nothing.
Before p. 1
void swap(function& other) noexcept;
2 Throws: nothing.
Before p. 1
explicit operator bool() const noexcept;
2 Throws: nothing.
Before p. 1
const std::type_info& target_type() const noexcept;
2 Throws: nothing.
After p. 2
template<typename T> T* target() noexcept; template<typename T> const T* target() const noexcept;
5 Throws: nothing.
Before p. 1
template <class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator==(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;
2 Throws: nothing.
After p. 2
template <class R, class... ArgTypes> bool operator!=(const function<R(ArgTypes...)>& f, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator!=(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;
4 Throws: nothing.
After p. 1
... // 20.9.9, specialized algorithms: template <class T> T* addressof(T& r) noexcept; ... // 20.9.11.5, shared_ptr atomic access: template<class T> bool atomic_is_lock_free(const shared_ptr<T>* p) noexcept; template<class T> shared_ptr<T> atomic_load(const shared_ptr<T>* p); template<class T> shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo) noexcept; template<class T> void atomic_store(shared_ptr<T>* p, shared_ptr<T> r); template<class T> void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo) noexcept; template<class T> shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r); template<class T> shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo) noexcept; template<class T> bool atomic_compare_exchange_weak( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); template<class T> bool atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); template<class T> bool atomic_compare_exchange_weak_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure) noexcept; template<class T> bool atomic_compare_exchange_strong_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure) noexcept; ... // 20.9.12, Pointer safety enum class pointer_safety { relaxed, preferred, strict }; void declare_reachable(void *p); template <class T> T *undeclare_reachable(T *p) noexcept; void declare_no_pointers(char *p, size_t n) noexcept; void undeclare_no_pointers(char *p, size_t n) noexcept; pointer_safety get_pointer_safety() noexcept; ...
Before p. 1
template <class T> T* addressof(T& r) noexcept;
At the end of p. 1
Throws: nothing.
Before p. 1
namespace std { template <class T, class D = default_delete<T>> class unique_ptr { public: typedef see below pointer; typedef T element_type; typedef D deleter_type; // constructors constexpr unique_ptr() noexcept; explicit unique_ptr(pointer p) noexcept; unique_ptr(pointer p, implementation-defined d1) noexcept; unique_ptr(pointer p, implementation-defined d2) noexcept; unique_ptr(unique_ptr&& u) noexcept; constexpr unique_ptr(nullptr_t) : unique_ptr() { } template <class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept; template <class U> unique_ptr(auto_ptr<U>&& u) noexcept; // destructor ~unique_ptr(); // assignment unique_ptr& operator=(unique_ptr&& u) noexcept; template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; unique_ptr& operator=(nullptr_t) noexcept; // observers typename add_lvalue_reference<T>::type operator*() const; pointer operator->() const noexcept; pointer get() const noexcept; deleter_type& get_deleter() noexcept; const deleter_type& get_deleter() const noexcept; explicit operator bool() const noexcept; // modifiers pointer release() noexcept; void reset(pointer p = pointer()) noexcept; void swap(unique_ptr& u) noexcept; // disable copy from lvalue unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; }; }
Before p. 1
constexpr unique_ptr() noexcept;
4 Throws: nothing.
After p. 5
unique_ptr(pointer p) noexcept;
9 Throws: nothing.
After p. 10
unique_ptr(pointer p, see below d1) noexcept; unique_ptr(pointer p, see below d2) noexcept;
17 Throws: nothing.
After p. 17
unique_ptr(unique_ptr&& u) noexcept;
21 Throws: nothing.
After p. 21
template <class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
26 Throws: nothing.
After p. 26
template <class U> unique_ptr(auto_ptr<U>&& u) noexcept;
29 Throws: nothing.
Before p. 1
~unique_ptr();
3 Throws: nothing.
Before p. 1
unique_ptr& operator=(unique_ptr&& u) noexcept;
4 Throws: nothing.
After p. 4
template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
9 Throws: nothing.
After p. 9
unique_ptr& operator=(nullptr_t) noexcept;
13 Throws: nothing.
After p. 2
pointer operator->() const noexcept;
5 Throws: nothing.
After p. 6
pointer get() const noexcept;
8 Throws: nothing.
After p. 8
deleter_type& get_deleter() noexcept; const deleter_type& get_deleter() const noexcept;
10 Throws: nothing.
After p. 10
explicit operator bool() const noexcept;
12 Throws: nothing.
Before p. 1
pointer release() noexcept;
3 Throws: nothing.
After p. 3
void reset(pointer p = pointer()) noexcept;
7 Throws: nothing.
After p. 7
void swap(unique_ptr& u) noexcept;
10 Throws: nothing.
Before p. 1
namespace std { template <class T, class D> class unique_ptr<T[], D> { public: typedef implementation-defined pointer; typedef T element_type; typedef D deleter_type; // constructors constexpr unique_ptr() noexcept; explicit unique_ptr(pointer p) noexcept; unique_ptr(pointer p, implementation-defined d) noexcept; unique_ptr(pointer p, implementation-defined d) noexcept; unique_ptr(unique_ptr&& u) noexcept; constexpr unique_ptr(nullptr_t) : unique_ptr() { } // destructor unique_ptr() noexcept; // assignment unique_ptr& operator=(unique_ptr&& u) noexcept; unique_ptr& operator=(nullptr_t) noexcept; // observers T& operator[](size_t i) const; pointer get() const noexcept; deleter_type& get_deleter() noexcept; const deleter_type& get_deleter() const noexcept; explicit operator bool() const noexcept; // modifiers pointer release() noexcept; void reset(pointer p = pointer()) noexcept; void reset(nullptr_t) noexcept; template <class U> void reset(U) = delete; void swap(unique_ptr& u) noexcept; // disable copy from lvalue unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; }; }
Before p. 1
unique_ptr(pointer p) noexcept; unique_ptr(pointer p, implementation-defined d) noexcept; unique_ptr(pointer p, implementation-defined d) noexcept;
Before p. 1
void reset(pointer p = pointer()) noexcept; void reset(nullptr_t p) noexcept;
3 Throws: nothing.
Before p. 1
namespace std { class bad_weak_ptr: public std::exception { public: bad_weak_ptr() noexcept; }; } // namespace std
After p. 1
bad_weak_ptr()noexcept;
3 Throws: nothing.
After p. 1
namespace std { template<class T> class shared_ptr { public: typedef T element_type; // 20.9.11.2.1, constructors: constexpr shared_ptr() noexcept; template<class Y> explicit shared_ptr(Y* p); template<class Y, class D> shared_ptr(Y* p, D d); template<class Y, class D, class A> shared_ptr(Y* p, D d, A a); template <class D> shared_ptr(nullptr_t p, D d) template <class D, class A> shared_ptr(nullptr_t p, D d, A a) template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept; shared_ptr(const shared_ptr& r) noexcept; template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept; shared_ptr(shared_ptr&& r) noexcept; template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept; template<class Y> explicit shared_ptr(const weak_ptr<Y>& r); template<class Y> shared_ptr(auto_ptr<Y>&& r); template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r); constexpr shared_ptr(nullptr_t) : shared_ptr() { } // 20.9.11.2.2, destructor: ~shared_ptr(); // 20.9.11.2.3, assignment: shared_ptr& operator=(const shared_ptr& r); template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r); shared_ptr& operator=(shared_ptr&& r); template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r); template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r); // 20.9.11.2.4, modifiers: void swap(shared_ptr& r) noexcept; void reset(); template<class Y> void reset(Y* p); template<class Y, class D> void reset(Y* p, D d); template<class Y, class D, class A> void reset(Y* p, D d, A a); // 20.9.11.2.5, observers: T* get() const noexcept; T& operator*() const noexcept; T* operator->() const noexcept; long use_count() const noexcept; bool unique() const noexcept; explicit operator bool() const noexcept; template<class U> bool owner_before(shared_ptr<U> const& b) const; template<class U> bool owner_before(weak_ptr<U> const& b) const; }; // 20.9.11.2.6, shared_ptr creation template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args); template<class T, class A, class... Args> shared_ptr<T> allocate_shared(const A& a, Args&&... args); // 20.9.11.2.7, shared_ptr comparisons: template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept; template<class T, class U> bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b); template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept; // 20.9.11.2.8, shared_ptr I/O: template<class E, class T, class Y> basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, const shared_ptr<Y>& p); // 20.9.11.2.9, shared_ptr specialized algorithms: template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept; // 20.9.11.2.10, shared_ptr casts: template<class T, class U> shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept; template<class T, class U> shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept; template<class T, class U> shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept; // 20.9.11.2.11, shared_ptr get_deleter: template<class D, class T> D* get_deleter(const shared_ptr<T>& p) noexcept; } // namespace std
Before p. 1
constexpr shared_ptr() noexcept;
3 Throws: nothing.
After p. 13
template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
16 Throws: nothing.
After p. 18
shared_ptr(const shared_ptr& r) noexcept; template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
22 Throws: nothing.
After p. 22
shared_ptr(shared_ptr&& r) noexcept; template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
26 Throws: nothing.
Before p. 1
~shared_ptr();
2 Throws: nothing.
Before p. 1
void swap(shared_ptr& r) noexcept;
2 Throws: nothing.
Before p. 1
T* get() const noexcept;
2 Throws: nothing.
After p. 2
T& operator*() const noexcept;
5 Throws: nothing.
After p. 6
T* operator->() const noexcept;
9 Throws: nothing.
After p. 9
long use_count() const noexcept;
11 Throws: nothing.
After p. 12
bool unique() const noexcept;
14 Throws: nothing.
After p. 15
explicit operator bool() const noexcept;
17 Throws: nothing.
Before p. 1
template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
2 Throws: nothing.
After p. 2
template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
4 Throws: nothing.
Before p. 1
template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
2 Throws: nothing.
Before p. 1
template<class T, class U> shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
4 Throws: nothing.
After p. 5
template<class T, class U> shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
9 Throws: nothing.
After p. 10
template<class T, class U> shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
14 Throws: nothing.
Before p. 1
template<class D, class T> D* get_deleter(const shared_ptr<T>& p) noexcept;
2 Throws: nothing.
Before p. 1
namespace std { template<class T> class weak_ptr { public: typedef T element_type; // constructors constexpr weak_ptr() noexcept; template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept; weak_ptr(weak_ptr const& r) noexcept; template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept; // destructor ~weak_ptr(); // assignment weak_ptr& operator=(weak_ptr const& r) noexcept; template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept; template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept; // modifiers void swap(weak_ptr& r) noexcept; void reset(); // observers long use_count() const noexcept; bool expired() const noexcept; shared_ptr<T> lock() const noexcept; template<class U> bool owner_before(shared_ptr<U> const& b); template<class U> bool owner_before(weak_ptr<U> const& b); }; // specialized algorithms template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept; } // namespace std
Before p. 1
constexpr weak_ptr() noexcept;
3 Throws: nothing.
After p. 3
weak_ptr(const weak_ptr& r) noexcept; template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept; template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
7 Throws: nothing.
Before p. 1
~weak_ptr();
2 Throws: nothing.
Before p. 1
weak_ptr& operator=(const weak_ptr& r) noexcept; template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept; template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
2 Throws: nothing.
Before p. 1
void swap(weak_ptr& r) noexcept;
2 Throws: nothing.
Before p. 1
long use_count() const noexcept;
2 Throws: nothing.
After p. 3
bool expired() const noexcept;
5 Throws: nothing.
After p. 6
shared_ptr<T> lock() const noexcept;
8 Throws: nothing.
Before p. 1
template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
2 Throws: nothing.
After p. 2
namespace std { template<class T> class enable_shared_from_this { protected: constexpr enable_shared_from_this() noexcept; enable_shared_from_this(enable_shared_from_this const&) noexcept; enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept; ~enable_shared_from_this(); public: shared_ptr<T> shared_from_this(); shared_ptr<T const> shared_from_this() const; }; } // namespace std
After p. 3
constexpr enable_shared_from_this() noexcept; enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;
5 Throws: nothing.
After p. 5
enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
7 Throws: nothing.
After p. 7
~enable_shared_from_this();
9 Throws: nothing.
After p. 2
template<class T> bool atomic_is_lock_free(const shared_ptr<T>* p) noexcept;
5 Throws: nothing.
After p. 7
template<class T> shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo) noexcept;
11 Throws: nothing.
After p. 13
template<class T> void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo) noexcept;
17 Throws: nothing.
After p. 19
template<class T> shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo) noexcept;
23 Throws: nothing.
After p. 26
template<class T> bool atomic_compare_exchange_weak_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure) noexcept; template<class T> bool atomic_compare_exchange_strong_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure) noexcept;
31 Throws: nothing.
After p. 4
template <class T> T *undeclare_reachable(T *p) noexcept;
7 Throws: nothing.
After p. 8
void declare_no_pointers(char *p, size_t n) noexcept;
11 Throws: nothing.[ Note: Under some conditions implementations may need to allocate memory.
However, the request can be ignored if memory allocation fails. —end note ]
After p. 11
void undeclare_no_pointers(char *p, size_t n) noexcept;
14 Throws: nothing.
After p. 14
pointer_safety get_pointer_safety() noexcept;
16 Throws: Nothing.
After p. 5
namespace std { template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_string { public: ... basic_string& operator=(basic_string&& str) noexcept; ... // 21.4.4 capacity: size_type size() const noexcept; ... // 21.4.5 element access: const_reference operator[](size_type pos) const noexcept; reference operator[](size_type pos) noexcept; ... basic_string& assign(basic_string&& str) noexcept; ... void swap(basic_string& str) noexcept; ... // 21.4.7 string operations: const charT* c_str() const noexcept; // explicit const charT* data() const noexcept; ... };
After p. 20
basic_string<charT,traits,Allocator>& operator=(basic_string<charT,traits,Allocator>&& str) noexcept;
23 Throws: Nothing.
Before p. 1
size_type size() const noexcept;
2 Throws: nothing.
Before p. 1
const_reference operator[](size_type pos) const noexcept; reference operator[](size_type pos) noexcept;
3 Throws: nothing.
After p. 2
basic_string& assign(basic_string&& str) noexcept;
3 Throws: nothing.
Before p. 1
void swap(basic_string<charT,traits,Allocator>& s) noexcept;
1 Throws: Nothing.
Before p. 1
const charT* c_str() const noexcept; const charT* data() const noexcept;
2 Throws: nothing.
After p. 1
namespace std { #include <initializer_list> ... template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept; }
After p. 4
template <size_t I, class T, size_t N> T& get(array<T, N>& a) noexcept;
7 Throws: nothing.
After p. 7
template <size_t I, class T, size_t N> const T& get(const array<T, N>& a) noexcept;
10 Throws: nothing.
After p. 3
namespace std { template <class T, class Allocator = allocator<T> > class forward_list { public: ... iterator erase_after(const_iterator position) noexcept; iterator erase_after(const_iterator position, iterator last) noexcept; ... // 23.3.3.5 forward_list operations: void splice_after(const_iterator position, forward_list<T,Allocator>&& x) noexcept; void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator i) noexcept; ... void reverse() noexcept; }; ... }
After p. 18
iterator erase_after(const_iterator position) noexcept;
22 Throws: Nothing.
After p. 22
iterator erase_after(const_iterator position, iterator last) noexcept;
26 Throws: Nothing.
Before p. 1
void splice_after(const_iterator position, forward_list<T,Allocator>&& x) noexcept;
3 Throws: Nothing.
After p. 4
void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator i) noexcept;
7 Throws: Nothing.
After p. 23
void reverse() noexcept;
25 Throws: Nothing.
After p. 2
namespace std { template <class T, class Allocator = allocator<T> > class list { public: ... void pop_front() noexcept; ... void pop_back() noexcept; ... iterator erase(const_iterator position) noexcept; iterator erase(const_iterator first, const_iterator last) noexcept; ... void clear() noexcept; // 23.3.4.4 list operations: void splice(const_iterator position, list<T,Allocator>& x) noexcept; void splice(const_iterator position, list<T,Allocator>&& x) noexcept; void splice(const_iterator position, list<T,Allocator>& x, const_iterator i) noexcept; void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i) noexcept; void splice(const_iterator position, list<T,Allocator>& x, const_iterator first, const_iterator last) noexcept; void splice(const_iterator position, list<T,Allocator>&& x, const_iterator first, const_iterator last) noexcept; ... void reverse() noexcept; }; ... }
After p. 2
iterator erase(const_iterator position) noexcept; iterator erase(const_iterator first, const_iterator last) noexcept; void pop_front() noexcept; void pop_back() noexcept; void clear() noexcept;
4 Throws: Nothing.
After p. 2
void splice(const_iterator position, list<T,Allocator>& x) noexcept; void splice(const_iterator position, list<T,Allocator>&& x) noexcept;
5 Throws: Nothing
After p. 6
void splice(const_iterator position, list<T,Allocator>& x, const_iterator i) noexcept; void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i) noexcept;
8 Throws: Nothing
After p. 10
void splice(const_iterator position, list<T,Allocator>& x, const_iterator first, const_iterator last) noexcept; void splice(const_iterator position, list<T,Allocator>&& x, const_iterator first, const_iterator last) noexcept;
13 Throws: Nothing
After p. 25
void reverse() noexcept;
27 Throws: Nothing
After p. 2
namespace std { template <class T, class Allocator = allocator<T> > class vector { public: ... // 23.4.1.3 data access T* data() noexcept; const T* data() const noexcept; ... }; ... }
Before p. 1
T* data() noexcept; const T* data() const noexcept;
3 Throws: Nothing.
After p. 2
class random_device { public: // types typedef unsigned int result_type; // generator characteristics static constexpr result_type min() { return numeric_limits<result_type>::min(); } static constexpr result_type max() { return numeric_limits<result_type>::max(); } // constructors explicit random_device(const string& token = implementation-defined); // generating functions result_type operator()(); // property functions double entropy() const noexcept; // no copy functions random_device(const random_device& ) = delete; void operator=(const random_device& ) = delete; };
After p. 4
double entropy() const noexcept;
namespace std { template<class T> class valarray { public: ... valarray(valarray&&) noexcept; ... valarray<T>& operator=(valarray<T>&&) noexcept; ... // 26.6.2.7 member functions: void swap(valarray&) noexcept; ... }; }
After p. 5
valarray(valarray<T>&& v) noexcept;
8 Throws: Nothing.
After p. 2
valarray<T>& operator=(valarray<T>&& v) noexcept;
5 Throws: Nothing.
Before p. 1
void swap(valarray& v) noexcept;
3 Throws: Nothing.
Before p. 1
namespace std { template <class charT, class traits = char_traits<charT> > class basic_ios : public ios_base { public: ... void swap(basic_ios& rhs) noexcept; void set_rdbuf(basic_streambuf<charT, traits>* sb) noexcept; }; }
After p. 20
void swap(basic_ios& rhs) noexcept;
22 Throws: Nothing.
After p. 22
void set_rdbuf(basic_streambuf<charT, traits>* sb) noexcept;
25 Throws: Nothing.
Before p. 1
namespace std { template <class charT,class traits = char_traits<charT> > class basic_ostream<charT,traits>::sentry { bool ok_; // exposition only public: explicit sentry(basic_ostream<charT,traits>& os); ~sentry(); explicit operator bool() const { return ok_; } sentry(const sentry&) = delete; sentry& operator=(const sentry&) = delete; }; }
After p. 3
~sentry();
After p. 4
Throws: Nothing.
After p. 3
namespace std { template <class charT, class traits = regex_traits<charT> > class basic_regex { public: ... basic_regex(basic_regex&&) noexcept; ... basic_regex& assign(basic_regex&& that) noexcept; ... }; }
After p. 11
basic_regex(basic_regex&& e) noexcept;
14 Throws: nothing.
After p. 8
basic_regex& assign(basic_regex&& that) noexcept;
11 Throws: nothing.
After p. 3
namespace std { template <class BidirectionalIterator, class Allocator = allocator<sub_match<BidirectionalIterator> > class match_results { public: ... match_results& operator=(match_results&& m) noexcept; ... }; }
After p. 7
match_results& operator=(match_results&& m) noexcept;
9 Throws: Nothing.
After p. 1
namespace std { class thread { public: // types: class id; typedef implementation-defined native_handle_type; // See 30.2.3 // construct/copy/destroy: thread() noexcept; template <class F, class ...Args> explicit thread(F&& f, Args&&... args); ~thread(); thread(const thread&) = delete; thread(thread&&) noexcept; thread& operator=(const thread&) = delete; thread& operator=(thread&&) noexcept; // members: void swap(thread&) noexcept; bool joinable() const noexcept; void join(); void detach(); id get_id() const noexcept; native_handle_type native_handle(); // See 30.2.3 // static members: static unsigned hardware_concurrency() noexcept; }; }
Before p. 1
namespace std { class thread::id { public: id() noexcept; }; bool operator==(thread::id x, thread::id y) noexcept; bool operator!=(thread::id x, thread::id y) noexcept; bool operator<(thread::id x, thread::id y) noexcept; bool operator<=(thread::id x, thread::id y) noexcept; bool operator>(thread::id x, thread::id y) noexcept; bool operator>=(thread::id x, thread::id y) noexcept; template<class charT, class traits> basic_ostream<charT, traits>& operator<< (basic_ostream<charT, traits>& out, thread::id id); // Hash support template <class T> struct hash; template <> struct hash<thread::id>; }
After p. 3
id() noexcept;
5 Throws: Nothing
After p. 6
bool operator==(thread::id x, thread::id y) noexcept;.
8 Throws: Nothing
After p. 8
bool operator!=(thread::id x, thread::id y) noexcept;
10 Throws: Nothing
After p. 10
bool operator<(thread::id x, thread::id y) noexcept;
12 Throws: Nothing
After p. 12
bool operator<=(thread::id x, thread::id y) noexcept;
14 Throws: Nothing
After p. 14
bool operator>(thread::id x, thread::id y) noexcept;
16 Throws: Nothing
After p. 16
bool operator>=(thread::id x, thread::id y) noexcept;
18 Throws: Nothing
Before p. 1
thread() noexcept;
3 Throws: Nothing.
After p. 9
thread(thread&& x) noexcept;
12 Throws: Nothing.
Before p. 1
~thread();
1 Throws: Nothing.
Before p. 1
thread& operator=(thread&& x) noexcept;
1 Throws: Nothing.
Before p. 1
void swap(thread& x) noexcept;
2 Throws: Nothing.
After p. 2
bool joinable() const noexcept;
4 Throws: Nothing.
After p. 15
id get_id() const noexcept;
17 Throws: Nothing.
Before p. 1
unsigned hardware_concurrency() noexcept;
2 Throws: Nothing.
Before p. 1
namespace std { namespace this_thread { thread::id get_id() noexcept; void yield() noexcept; template <class Clock, class Duration> void sleep_until(const chrono::time_point<Clock, Duration>& abs_time) noexcept; template <class Rep, class Period> void sleep_for(const chrono::duration<Rep, Period>& rel_time) noexcept; } } thread::id this_thread::get_id() noexcept;
2 Throws: Nothing.
After p. 2
void this_thread::yield() noexcept;
5 Throws: Nothing.
After p. 5
template <class Clock, class Duration> void sleep_until(const chrono::time_point<Clock, Duration>& abs_time) noexcept;
8 Throws: Nothing.
After p. 8
template <class Rep, class Period> void sleep_for(const chrono::duration<Rep, Period>& rel_time) noexcept;
11 Throws: Nothing.
After p. 1
namespace std { ... struct once_flag { constexpr once_flag() noexcept; once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; }; ... }
Before p. 1
namespace std { class mutex { public: constexpr mutex(); ~mutex(); mutex(const mutex&) = delete; mutex& operator=(const mutex&) = delete; void lock(); bool try_lock() noexcept; void unlock() noexcept; typedef implementation-defined native_handle_type; // See 30.2.3 native_handle_type native_handle(); // See 30.2.3 }; }
namespace std { class recursive_mutex { public: recursive_mutex(); ~recursive_mutex(); recursive_mutex(const recursive_mutex&) = delete; recursive_mutex& operator=(const recursive_mutex&) = delete; void lock(); bool try_lock() noexcept; void unlock() noexcept; typedef implementation-defined native_handle_type; // See 30.2.3 native_handle_type native_handle(); // See 30.2.3 }; }
Before p. 1
namespace std { class timed_mutex { public: timed_mutex(); ~timed_mutex(); timed_mutex(const timed_mutex&) = delete; timed_mutex& operator=(const timed_mutex&) = delete; void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) noexcept; template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) noexcept; void unlock(); typedef implementation-defined native_handle_type; // See 30.2.3 native_handle_type native_handle(); // See 30.2.3 }; }
Before p. 1
namespace std { class recursive_timed_mutex { public: recursive_timed_mutex(); ~recursive_timed_mutex(); recursive_timed_mutex(const recursive_timed_mutex&) = delete; recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) noexcept; template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) noexcept; void unlock(); typedef implementation-defined native_handle_type; // See 30.2.3 native_handle_type native_handle(); // See 30.2.3 }; }
Before p. 1
namespace std { template <class Mutex> class lock_guard { public: typedef Mutex mutex_type; explicit lock_guard(mutex_type& m); lock_guard(mutex_type& m, adopt_lock_t) noexcept; ~lock_guard(); lock_guard(lock_guard const&) = delete; lock_guard& operator=(lock_guard const&) = delete; private: mutex_type& pm; // exposition only }; }
After p. 4
lock_guard(mutex_type& m, adopt_lock_t) noexcept;
7 Throws: Nothing.
After p. 7
~lock_guard();
9 Throws: Nothing.
Before p. 1
namespace std { template <class Mutex> class unique_lock { public: typedef Mutex mutex_type; // 30.4.3.2.1 construct/copy/destroy unique_lock() noexcept; explicit unique_lock(mutex_type& m); unique_lock(mutex_type& m, defer_lock_t) noexcept; unique_lock(mutex_type& m, try_to_lock_t) noexcept; unique_lock(mutex_type& m, adopt_lock_t) noexcept; template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time) noexcept; template <class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time) noexcept; ~unique_lock(); unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete; unique_lock(unique_lock&& u) noexcept; unique_lock& operator=(unique_lock&& u) noexcept; // 30.4.3.2.2 locking void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); // 30.4.3.2.3 modifiers void swap(unique_lock& u) noexcept; mutex_type *release() noexcept; // 30.4.3.2.4 observers bool owns_lock() const noexcept; explicit operator bool () const noexcept; mutex_type* mutex() const noexcept; private: mutex_type *pm; // exposition only bool owns; // exposition only }; template <class Mutex> void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept; }
Before p. 1
unique_lock() noexcept;
3 Throws: Nothing.
After p. 6
unique_lock(mutex_type& m, defer_lock_t) noexcept;
9 Throws: Nothing.
After p. 9
unique_lock(mutex_type& m, try_to_lock_t) noexcept;
13 Throws: Nothing.
After p. 13
unique_lock(mutex_type& m, adopt_lock_t) noexcept;
17 Throws: Nothing.
After p. 17
template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time) noexcept;
21 Throws: Nothing.
After p. 21
template <class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time) noexcept;
25 Throws: Nothing.
After p. 25
unique_lock(unique_lock&& u) noexcept;
27 Throws: Nothing.
After p. 27
unique_lock& operator=(unique_lock&& u) noexcept;
30 Throws: Nothing.
After p. 30
~unique_lock();
33 Throws: Nothing.
Before p. 1
void swap(unique_lock& u) noexcept;
2 Throws: Nothing.
After p. 2
mutex_type *release() noexcept;
5 Throws: Nothing.
After p. 5
template <class Mutex> void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
7 Throws: Nothing.
Before p. 1
bool owns_lock() const noexcept;
2 Throws: Nothing.
After p. 2
explicit operator bool() const noexcept;
4 Throws: Nothing.
After p. 4
mutex_type *mutex() const noexcept;
6 Throws: Nothing.
Before p. 1
constexpr once_flag() noexcept;
4 Throws: nothing.
Before p. 1
namespace std { class condition_variable { public: condition_variable(); ~condition_variable(); ... void notify_one() noexcept; void notify_all() noexcept; ... }; }
After p. 4
~condition_variable();
7 Throws: nothing.
After p. 7
void notify_one() noexcept;
9 Throws: nothing.
After p. 9
void notify_all() noexcept;
11 Throws: nothing.
After p. 1
namespace std { class condition_variable_any { public: condition_variable_any(); ~condition_variable_any(); ... void notify_one() noexcept; void notify_all() noexcept; ... }; }
After p. 2
~condition_variable_any();
5 Throws: Nothing.
After p. 5
void notify_one() noexcept;
7 Throws: Nothing.
After p. 7
void notify_all() noexcept;
9 Throws: Nothing.
Before p. 1
namespace std { template <class R> class promise { public: ... promise(promise&& rhs) noexcept; ... // assignment promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; void swap(promise& other) noexcept; ... }; ... }
After p. 3
promise(promise&& rhs) noexcept;
6 Throws: Nothing.
After p. 7
promise& operator=(promise&& rhs) noexcept;
11 Throws: Nothing.
After p. 11
void swap(promise& other) noexcept;
14 Throws: Nothing.
After p. 3
namespace std { template <class R> class future { public: future(); future(future &&) noexcept; ... }; }
After p. 6
future(future&& rhs) noexcept;
9 Throws: nothing.
After p. 3
namespace std { template <class R> class shared_future { public: shared_future() noexcept; shared_future(const shared_future& rhs); shared_future(future&&) noexcept; shared_future(shared_future&& rhs) noexcept; ... }; }
After p. 4
shared_future() noexcept;
7 Throws: Nothing.
After p. 9
shared_future(future<R>&& rhs) noexcept; shared_future(shared_future&& rhs) noexcept;
12 Throws: nothing.
After p. 3
namespace std { template<class> class packaged_task; // undefined template<class R, class... ArgTypes> class packaged_task<R(ArgTypes...)> { public: typedef R result_type; // construction and destruction packaged_task() noexcept; template <class F> explicit packaged_task(F f); template <class F, class Allocator> explicit packaged_task(allocator_arg_t, const Allocator& a, F f); explicit packaged_task(R(*f)(ArgTypes...)); template <class F> explicit packaged_task(F&& f); template <class F, class Allocator> explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f); ~packaged_task(); // no copy packaged_task(packaged_task&) = delete; packaged_task& operator=(packaged_task&) = delete; // move support packaged_task(packaged_task&& other) noexcept; packaged_task& operator=(packaged_task&& other); void swap(packaged_task& other) noexcept; explicit operator bool() const noexcept; // result retrieval future<R> get_future(); // execution void operator()(ArgTypes... ); void make_ready_at_thread_exit(ArgTypes...); void reset(); }; template <class R, class... ArgTypes> void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept; template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>; }
Before p. 1
packaged_task() noexcept;
2 Throws: nothing.
After p. 5
packaged_task(packaged_task&& other) noexcept;
8 Throws: nothing.
After p. 9
~packaged_task();
11 Throws: nothing.
After p. 11
void swap(packaged_task& other) noexcept;
14 Throws: nothing.
After p. 14
explicit operator bool() const noexcept;
16 Throws: nothing.
Before p. 1
template <class R, class... ArgTypes> void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
2 Throws: Nothing.