N3195 - From Throws: Nothing to noexcept (version 2)

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.

Revision history

• Remove originally proposed changes to requirements Mutex and TimedMutex.
• Removed noexcept from every destructor.

Acknowledgments

Proposed Wording

18.8 Exception handling

typedef unspecified exception_ptr;
exception_ptr current_exception()noexcept;

18.8.6 Exception Propagation

exception_ptr current_exception() noexcept;

8 Throws: nothing.

18.9 Initializer list

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);
}

18.9.1 Initializer list constructors

initializer_list() noexcept;

3. Throws: nothing.

18.9.2 Initializer list access

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 System error support

...
// 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;

19.5.1.1 Class error_category overview

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

19.5.1.2 Class error_category virtual members

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.

19.5.1.3 Class error_category non-virtual members

bool operator<(const error_category& rhs) const noexcept;

4. Throws: nothing.

19.5.1.4 Program defined classes derived from error_category

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.

19.5.2.1 Class error_code overview

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

19.5.2.2 Class error_code constructors

error_code() noexcept;

3. Throws: Nothing.

error_code(int val, const error_category& cat) noexcept;

6. Throws: Nothing.

template <class ErrorCodeEnum>
  error_code(ErrorCodeEnum e) noexcept;

9. Throws: Nothing.

Class error_code modifiers

void assign(int val, const error_category& cat) noexcept;

2. Throws: Nothing.

template <class ErrorCodeEnum>
error_code& operator=(ErrorCodeEnum e) noexcept;

5. Throws: Nothing.

19.5.2.4 Class error_code observers

int value() const noexcept;

2. Throws: Nothing.

const error_category& category() const noexcept;

4. Throws: Nothing.

error_condition default_error_condition() const noexcept;

6. Throws: Nothing.

explicit operator bool() const noexcept;

9. Throws: Nothing.

19.5.2.5 Class error_code non-member functions

bool operator<(const error_code& lhs, const error_code& rhs) noexcept;

2. Throws: Nothing.

Class error_condition overview

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

19.5.3.2 Class error_condition constructors

error_condition() noexcept;

3 Throws: Nothing.

error_condition(int val, const error_category& cat) noexcept;

6 Throws: Nothing.

template <class ErrorConditionEnum>
  error_condition(ErrorConditionEnum e) noexcept;

9 Throws: Nothing.

19.5.3.3 Class error_condition modifiers

void assign(int val, const error_category& cat) noexcept;

2 Throws: Nothing.

template <class ErrorConditionEnum>
  error_condition& operator=(ErrorConditionEnum e) noexcept;

5 Throws: Nothing.

19.5.3.4 Class error_condition observers

int value() const noexcept;

2 Throws: Nothing.

const error_category& category() const noexcept;

4 Throws: Nothing.

explicit operator bool() const noexcept;

7 Throws: Nothing.

19.5.3.5 Class error_condition non-member functions

bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;

2 Throws: Nothing.

19.5.4 Comparison operators

bool operator==(const error_code& lhs, const error_code& rhs) noexcept;

2 Throws: Nothing.

bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;

4 Throws: Nothing.

bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;

6 Throws: Nothing.

bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;

8 Throws: Nothing.

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.

20.3 Utility components

...
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;
...

20.3.5.4 Tuple-like access to pair

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.

20.4.1 In general

...
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;
...

20.4.2.6 Element access

template <size_t I, class... Types>
  typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>& t) noexcept;

3 Throws: Nothing.

template <size_t I, class... Types>
  typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>& t) noexcept;

6 Throws: Nothing.

20.5 Class template bitset

...
// element access:
constexpr bool operator[](size_t pos) const noexcept; // for b[i];
reference operator[](size_t pos) noexcept; // for b[i];
...

20.5.2 bitset members

constexpr bool operator[](size_t pos) noexcept;

50 Throws: Nothing.

bitset<N>::reference operator[](size_t pos) noexcept;

53 Throws: Nothing.

20.8 Function objects

...
  // 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;
...

20.8.4 Class template reference_wrapper

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; 
  }; 
}

20.8.4.1 reference_wrapper construct/copy/destroy

reference_wrapper(T& t) noexcept;

2 Throws: nothing.

reference_wrapper(const reference_wrapper<T>& x) noexcept;

4 Throws: nothing.

20.8.4.2 reference_wrapper assignment

reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;

2 Throws: nothing.

20.8.4.3 reference_wrapper access

operator T& () const noexcept;

2 Throws: nothing.

T& get() const noexcept;

4 Throws: nothing.

20.8.4.5 reference_wrapper helper functions

template <class T> reference_wrapper<T> ref(T& t) noexcept;

2 Throws: nothing.

template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;

4 Throws: nothing.

template <class T> reference_wrapper<const T> cref(const T& t) noexcept;

6 Throws: nothing.

template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;

8 Throws: nothing.

20.8.13 Function template mem_fn

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.

20.8.14.2 Class template function

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 { };
}

20.8.14.2.1 function construct/copy/destroy

function() noexcept;
template <class A> function(allocator_arg_t, const A& a) noexcept;

3 Throws: nothing.

function(nullptr_t) noexcept;
template <class A> function(allocator_arg_t, const A& a, nullptr_t) noexcept;

3 Throws: nothing.

template<class F> function& operator=(reference_wrapper<F> f) noexcept;

24 Throws: nothing.

20.8.14.2.2 function modifiers

void swap(function& other) noexcept;

2 Throws: nothing.

20.8.14.2.3 function capacity

explicit operator bool() const noexcept;

2 Throws: nothing.

20.8.14.2.5 function target access

const std::type_info& target_type() const noexcept;

2 Throws: nothing.

template<typename T> T* target() noexcept;
template<typename T> const T* target() const noexcept;

5 Throws: nothing.

20.8.14.2.6 null pointer comparison operators

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.

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.

20.9 Memory

...
  // 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;
...

20.9.9.1 addressof

template <class T> T* addressof(T& r) noexcept;

Throws: nothing.

20.9.10.2 unique_ptr for single objects

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;
  };
}

20.9.10.2.1 unique_ptr constructors

constexpr unique_ptr() noexcept;

4 Throws: nothing.

unique_ptr(pointer p) noexcept;

9 Throws: nothing.

unique_ptr(pointer p, see below d1) noexcept;
unique_ptr(pointer p, see below d2) noexcept;

17 Throws: nothing.

unique_ptr(unique_ptr&& u) noexcept;

21 Throws: nothing.

template <class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;

26 Throws: nothing.

template <class U>
  unique_ptr(auto_ptr<U>&& u) noexcept;

29 Throws: nothing.

20.9.10.2.2 unique_ptr destructor

~unique_ptr();

3 Throws: nothing.

20.9.10.2.3 unique_ptr assignment

unique_ptr& operator=(unique_ptr&& u) noexcept;

4 Throws: nothing.

template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;

9 Throws: nothing.

unique_ptr& operator=(nullptr_t) noexcept;

13 Throws: nothing.

20.9.10.2.4 unique_ptr observers

pointer operator->() const noexcept;

5 Throws: nothing.

pointer get() const noexcept;

8 Throws: nothing.

deleter_type& get_deleter() noexcept;
const deleter_type& get_deleter() const noexcept;

10 Throws: nothing.

explicit operator bool() const noexcept;

12 Throws: nothing.

20.9.10.2.5 unique_ptr modifiers

pointer release() noexcept;

3 Throws: nothing.

void reset(pointer p = pointer()) noexcept;

7 Throws: nothing.

void swap(unique_ptr& u) noexcept;

10 Throws: nothing.

20.9.10.3 unique_ptr for array objects with a runtime length

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;
  };
}

20.9.10.3.1 unique_ptr constructors

unique_ptr(pointer p) noexcept;
unique_ptr(pointer p, implementation-defined d) noexcept;
unique_ptr(pointer p, implementation-defined d) noexcept;

20.9.10.3.3 unique_ptr modifiers

void reset(pointer p = pointer()) noexcept;
void reset(nullptr_t p) noexcept;

3 Throws: nothing.

20.9.11.1 Class bad_weak_ptr

namespace std {
  class bad_weak_ptr: public std::exception {
  public:
    bad_weak_ptr() noexcept;
  };
} // namespace std

bad_weak_ptr()noexcept;

3 Throws: nothing.

20.9.11.2 Class template shared_ptr

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

20.9.11.2.1 shared_ptr constructors

constexpr shared_ptr() noexcept;

3 Throws: nothing.

template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;

16 Throws: nothing.

shared_ptr(const shared_ptr& r) noexcept;
template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;

22 Throws: nothing.

shared_ptr(shared_ptr&& r) noexcept;
template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;

26 Throws: nothing.

20.9.11.2.2 shared_ptr destructor

~shared_ptr();

2 Throws: nothing.

20.9.11.2.4 shared_ptr modifiers

void swap(shared_ptr& r) noexcept;

2 Throws: nothing.

20.9.11.2.5 shared_ptr observers

T* get() const noexcept;

2 Throws: nothing.

T& operator*() const noexcept;

5 Throws: nothing.

T* operator->() const noexcept;

9 Throws: nothing.

long use_count() const noexcept;

11 Throws: nothing.

bool unique() const noexcept;

14 Throws: nothing.

explicit operator bool() const noexcept;

17 Throws: nothing.

20.9.11.2.7 shared_ptr comparison

template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;

2 Throws: nothing.

template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;

4 Throws: nothing.

20.9.11.2.9 shared_ptr specialized algorithms

template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;

2 Throws: nothing.

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;

4 Throws: nothing.

template<class T, class U> shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;

9 Throws: nothing.

template<class T, class U> shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;

14 Throws: nothing.

20.9.11.2.11 get_deleter

template<class D, class T> D* get_deleter(const shared_ptr<T>& p) noexcept;

2 Throws: nothing.

20.9.11.3 Class template weak_ptr

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

20.9.11.3.1 weak_ptr constructors

constexpr weak_ptr() noexcept;

3 Throws: nothing.

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.

20.9.11.3.2 weak_ptr destructor

~weak_ptr();

2 Throws: nothing.

20.9.11.3.3 weak_ptr assignment

weak_ptr& operator=(const weak_ptr& r) noexcept;
template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;

2 Throws: nothing.

20.9.11.3.4 weak_ptr modifiers

void swap(weak_ptr& r) noexcept;

2 Throws: nothing.

20.9.11.3.5 weak_ptr observers

long use_count() const noexcept;

2 Throws: nothing.

bool expired() const noexcept;

5 Throws: nothing.

shared_ptr<T> lock() const noexcept;

8 Throws: nothing.

20.9.11.3.6 weak_ptr specialized algorithms

template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

2 Throws: nothing.

20.9.11.4 Class template enable_shared_from_this

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

constexpr enable_shared_from_this() noexcept;
enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;

5 Throws: nothing.

enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;

7 Throws: nothing.

~enable_shared_from_this();

9 Throws: nothing.

20.9.11.5 shared_ptr atomic access

template<class T>
  bool atomic_is_lock_free(const shared_ptr<T>* p) noexcept;

5 Throws: nothing.

template<class T>
  shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo) noexcept;

11 Throws: nothing.

template<class T>
  void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo) noexcept;

17 Throws: nothing.

template<class T>
  shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r,
                                         memory_order mo) noexcept;

23 Throws: nothing.

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.

20.9.12 Pointer safety

template <class T> T *undeclare_reachable(T *p) noexcept;

7 Throws: nothing.

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 ]

void undeclare_no_pointers(char *p, size_t n) noexcept;

14 Throws: nothing.

pointer_safety get_pointer_safety() noexcept;

16 Throws: Nothing.

21.4 Class template basic_string

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;    
...
  };

21.4.2 basic_string constructors and assigment operators

basic_string<charT,traits,Allocator>&
  operator=(basic_string<charT,traits,Allocator>&& str) noexcept;

23 Throws: Nothing.

21.4.4 basic_string capacity

size_type size() const noexcept;

2 Throws: nothing.

21.4.5 basic_string element access

const_reference operator[](size_type pos) const noexcept;
reference operator[](size_type pos) noexcept;

3 Throws: nothing.

21.4.6.3 basic_string::assign

basic_string&
  assign(basic_string&& str) noexcept;

3 Throws: nothing.

21.4.6.8 basic_string::swap

void swap(basic_string<charT,traits,Allocator>& s) noexcept;

1 Throws: Nothing.

21.4.7.1 basic_string accessors

const charT* c_str() const noexcept;
const charT* data() const noexcept;

2 Throws: nothing.

23.3 Sequence containers

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;
}

23.3.1.8 Tuple interface to class template array

template <size_t I, class T, size_t N> T& get(array<T, N>& a) noexcept;

7 Throws: nothing.

template <size_t I, class T, size_t N> const T& get(const array<T, N>& a) noexcept;

10 Throws: nothing.

23.3.3 Class template forward_list

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;
  };
...
}

23.3.3.4 forward_list modifiers

iterator erase_after(const_iterator position) noexcept;

22 Throws: Nothing.

iterator erase_after(const_iterator position, iterator last) noexcept;

26 Throws: Nothing.

23.3.3.5 forward_list operations

void splice_after(const_iterator position, forward_list<T,Allocator>&& x) noexcept;

3 Throws: Nothing.

void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator i) noexcept;

7 Throws: Nothing.

void reverse() noexcept;

25 Throws: Nothing.

23.3.4 Class template list

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;
  };
...
}

23.3.4.3 list modifiers

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.

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;

5 Throws: Nothing

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

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

void reverse() noexcept;

27 Throws: Nothing

23.4.1 Class template vector

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;
...
  };
...
}

23.4.1.3 vector data

T* data() noexcept;
const T* data() const noexcept;

3 Throws: Nothing.

26.5.6 Class random_device

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;
};

double entropy() const noexcept;

26.6.2 Class template valarray

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;
...
  };
}

26.6.2.1 valarray constructors

valarray(valarray<T>&& v) noexcept;

8 Throws: Nothing.

26.6.2.2 valarray assignment

valarray<T>& operator=(valarray<T>&& v) noexcept;

5 Throws: Nothing.

26.6.2.7 valarray member functions

void swap(valarray& v) noexcept;

3 Throws: Nothing.

27.5.4 Class template basic_ios

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;

  };
}

27.5.4.2 Member functions

void swap(basic_ios& rhs) noexcept;

22 Throws: Nothing.

void set_rdbuf(basic_streambuf<charT, traits>* sb) noexcept;

25 Throws: Nothing.

27.7.2.4 Class basic_ostream::sentry

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;
  };
}

~sentry();

Throws: Nothing.

28.8 Class template basic_regex

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;
...
  };
}

28.8.2 basic_regex constructors

basic_regex(basic_regex&& e) noexcept;

14 Throws: nothing.

28.8.3 basic_regex assign

basic_regex& assign(basic_regex&& that) noexcept;

11 Throws: nothing.

28.10 Class template match_results

namespace std {
  template <class BidirectionalIterator,
               class Allocator = allocator<sub_match<BidirectionalIterator> >
  class match_results {
  public:
...
    match_results& operator=(match_results&& m) noexcept;
...
  };
}

28.10.1 match_results constructors

match_results& operator=(match_results&& m) noexcept;

9 Throws: Nothing.

30.3.1 Class thread

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;
  };
}

30.3.1.1 Class thread::id

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>;
}

id() noexcept;

5 Throws: Nothing

bool operator==(thread::id x, thread::id y) noexcept;.

8 Throws: Nothing

bool operator!=(thread::id x, thread::id y) noexcept;

10 Throws: Nothing

bool operator<(thread::id x, thread::id y) noexcept;

12 Throws: Nothing

bool operator<=(thread::id x, thread::id y) noexcept;

14 Throws: Nothing

bool operator>(thread::id x, thread::id y) noexcept;

16 Throws: Nothing

bool operator>=(thread::id x, thread::id y) noexcept;

18 Throws: Nothing

30.3.1.2 thread constructors

thread() noexcept;

3 Throws: Nothing.

thread(thread&& x) noexcept;

12 Throws: Nothing.

30.3.1.3 thread destructor

~thread();

1 Throws: Nothing.

30.3.1.4 thread assignment

thread& operator=(thread&& x) noexcept;

1 Throws: Nothing.

30.3.1.5 thread members

void swap(thread& x) noexcept;

2 Throws: Nothing.

bool joinable() const noexcept;

4 Throws: Nothing.

id get_id() const noexcept;

17 Throws: Nothing.

30.3.1.6 thread static members

unsigned hardware_concurrency() noexcept;

2 Throws: Nothing.

30.3.2 Namespace this_thread

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.

void this_thread::yield() noexcept;

5 Throws: Nothing.

template <class Clock, class Duration>
  void sleep_until(const chrono::time_point<Clock, Duration>& abs_time) noexcept;

8 Throws: Nothing.

template <class Rep, class Period>
  void sleep_for(const chrono::duration<Rep, Period>& rel_time) noexcept;

11 Throws: Nothing.

30.4 Mutual exclusion

namespace std {
...
  struct once_flag {
    constexpr once_flag() noexcept;
    once_flag(const once_flag&) = delete;
    once_flag& operator=(const once_flag&) = delete;
  };
...
}

30.4.1.1 Class mutex

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
  };
}

30.4.1.2 Class recursive_mutex

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
  };
}

30.4.2.1 Class timed_mutex

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
  };
}

30.4.2.2 Class recursive_timed_mutex

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
  };
}

30.4.3.1 Class template lock_guard

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
  };
}

lock_guard(mutex_type& m, adopt_lock_t) noexcept;

7 Throws: Nothing.

~lock_guard();

9 Throws: Nothing.

30.4.3.2 Class template unique_lock

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;
}

30.4.3.2.1 unique_lock constructors, destructor, and assignment

unique_lock() noexcept;

3 Throws: Nothing.

unique_lock(mutex_type& m, defer_lock_t) noexcept;

9 Throws: Nothing.

unique_lock(mutex_type& m, try_to_lock_t) noexcept;

13 Throws: Nothing.

unique_lock(mutex_type& m, adopt_lock_t) noexcept;

17 Throws: Nothing.

template <class Clock, class Duration>
  unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time) noexcept;

21 Throws: Nothing.

template <class Rep, class Period>
  unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time) noexcept;

25 Throws: Nothing.

unique_lock(unique_lock&& u) noexcept;

27 Throws: Nothing.

unique_lock& operator=(unique_lock&& u) noexcept;

30 Throws: Nothing.

~unique_lock();

33 Throws: Nothing.

30.4.3.2.3 unique_lock modifiers

void swap(unique_lock& u) noexcept;

2 Throws: Nothing.

mutex_type *release() noexcept;

5 Throws: Nothing.

template <class Mutex>
  void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;

7 Throws: Nothing.

30.4.3.2.4 unique_lock observers

bool owns_lock() const noexcept;

2 Throws: Nothing.

explicit operator bool() const noexcept;

4 Throws: Nothing.

mutex_type *mutex() const noexcept;

6 Throws: Nothing.

30.4.5.1 Struct once_flag

constexpr once_flag() noexcept;

4 Throws: nothing.

30.5.1 Class condition_variable

namespace std {
  class condition_variable {
  public:

    condition_variable();
    ~condition_variable();  
...
    void notify_one() noexcept;
    void notify_all() noexcept;
...
  };
}

~condition_variable();

7 Throws: nothing.

void notify_one() noexcept;

9 Throws: nothing.

void notify_all() noexcept;

11 Throws: nothing.

30.5.2 Class condition_variable_any

namespace std {
  class condition_variable_any {
  public:
    condition_variable_any();
    ~condition_variable_any();
...
    void notify_one() noexcept;
    void notify_all() noexcept;
...
  };
}

~condition_variable_any();

5 Throws: Nothing.

void notify_one() noexcept;

7 Throws: Nothing.

void notify_all() noexcept;

9 Throws: Nothing.

30.6.5 Class template promise

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;
...
  };
...
}

promise(promise&& rhs) noexcept;

6 Throws: Nothing.

promise& operator=(promise&& rhs) noexcept;

11 Throws: Nothing.

void swap(promise& other) noexcept;

14 Throws: Nothing.

30.6.6 Class template future

namespace std {
  template <class R>
  class future {
  public:
    future();
    future(future &&) noexcept;
...
  };
}

future(future&& rhs) noexcept;

9 Throws: nothing.

30.6.7 Class template shared_future

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;
...
};
}

shared_future() noexcept;

7 Throws: Nothing.

shared_future(future<R>&& rhs) noexcept;
shared_future(shared_future&& rhs) noexcept;

12 Throws: nothing.

30.6.10 Class template packaged_task

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>;
}

30.6.10.1 packaged_task member functions

packaged_task() noexcept;

2 Throws: nothing.

packaged_task(packaged_task&& other) noexcept;

8 Throws: nothing.

~packaged_task();

11 Throws: nothing.

void swap(packaged_task& other) noexcept;

14 Throws: nothing.

explicit operator bool() const noexcept;

16 Throws: nothing.

30.6.10.2 packaged_task globals

template <class R, class... ArgTypes>
void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;

2 Throws: Nothing.