Document number: N3195=10-0185
Date: 2010-11-11
Author:J. Daniel Garcia
Project: Programming Language C++, Library Working Group
Reply to: josedaniel.garcia@uc3m.es

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

Since N3149, and after review by the LWG, the following changes have been made:

Acknowledgments

I would like to thank Daniel Krügler for reviewing the original version of this paper.

Proposed Wording

18.8 Exception handling

typedef unspecified exception_ptr;
exception_ptr current_exception()noexcept;

18.8.6 Exception Propagation

After p. 6
exception_ptr current_exception() noexcept;

8 Throws: nothing.

18.9 Initializer list

After p. 1

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

Before p. 1
initializer_list() noexcept;

3. Throws: nothing.

18.9.2 Initializer list access

Before p. 1
const E* begin() const noexcept;

2. Throws: nothing.

After p. 2
const E* end() const noexcept;

4. Throws: nothing.

After p.4
size_t size() const noexcept;

6. Throws: nothing.

19.5 System error support

After p. 2
...
// 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

After p.1
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

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.

19.5.1.3 Class error_category non-virtual members

After p.2
bool operator<(const error_category& rhs) const noexcept;

4. Throws: nothing.

19.5.1.4 Program defined classes derived from error_category

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.

19.5.2.1 Class error_code overview

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

19.5.2.2 Class error_code constructors

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.

Class error_code modifiers

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.

19.5.2.4 Class error_code observers

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.

19.5.2.5 Class error_code non-member functions

Before p. 1
bool operator<(const error_code& lhs, const error_code& rhs) noexcept;

2. Throws: Nothing.

Class error_condition overview

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

19.5.3.2 Class error_condition constructors

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.

19.5.3.3 Class error_condition modifiers

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.

19.5.3.4 Class error_condition observers

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.

19.5.3.5 Class error_condition non-member functions

Before p. 1
bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;

2 Throws: Nothing.

19.5.4 Comparison operators

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.

20.3 Utility components

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

20.3.5.4 Tuple-like access to pair

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.

20.4.1 In general

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

20.4.2.6 Element access

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.

20.5 Class template bitset

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

20.5.2 bitset members

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.

20.8 Function objects

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

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

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.

20.8.4.2 reference_wrapper assignment

Before p. 1
reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;

2 Throws: nothing.

20.8.4.3 reference_wrapper access

Before p. 1
operator T& () const noexcept;

2 Throws: nothing.

After p. 2
T& get() const noexcept;

4 Throws: nothing.

20.8.4.5 reference_wrapper helper functions

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.

20.8.13 Function template mem_fn

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.

20.8.14.2 Class template function

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

20.8.14.2.1 function construct/copy/destroy

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.

20.8.14.2.2 function modifiers

Before p. 1
void swap(function& other) noexcept;

2 Throws: nothing.

20.8.14.2.3 function capacity

Before p. 1
explicit operator bool() const noexcept;

2 Throws: nothing.

20.8.14.2.5 function target access

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.

20.8.14.2.6 null pointer comparison operators

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.

20.9 Memory

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

20.9.9.1 addressof

Before p. 1
template <class T> T* addressof(T& r) noexcept;
At the end of p. 1

Throws: nothing.

20.9.10.2 unique_ptr for single objects

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

20.9.10.2.1 unique_ptr constructors

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.

20.9.10.2.2 unique_ptr destructor

Before p. 1
~unique_ptr();

3 Throws: nothing.

20.9.10.2.3 unique_ptr assignment

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.

20.9.10.2.4 unique_ptr observers

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.

20.9.10.2.5 unique_ptr modifiers

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.

20.9.10.3 unique_ptr for array objects with a runtime length

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

20.9.10.3.1 unique_ptr constructors

Before p. 1
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

Before p. 1
void reset(pointer p = pointer()) noexcept;
void reset(nullptr_t p) noexcept;

3 Throws: nothing.

20.9.11.1 Class bad_weak_ptr

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.

20.9.11.2 Class template shared_ptr

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

20.9.11.2.1 shared_ptr constructors

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.

20.9.11.2.2 shared_ptr destructor

Before p. 1
~shared_ptr();

2 Throws: nothing.

20.9.11.2.4 shared_ptr modifiers

Before p. 1
void swap(shared_ptr& r) noexcept;

2 Throws: nothing.

20.9.11.2.5 shared_ptr observers

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.

20.9.11.2.7 shared_ptr comparison

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.

20.9.11.2.9 shared_ptr specialized algorithms

Before p. 1
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

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.

20.9.11.2.11 get_deleter

Before p. 1
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

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

20.9.11.3.1 weak_ptr constructors

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.

20.9.11.3.2 weak_ptr destructor

Before p. 1
~weak_ptr();

2 Throws: nothing.

20.9.11.3.3 weak_ptr assignment

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.

20.9.11.3.4 weak_ptr modifiers

Before p. 1
void swap(weak_ptr& r) noexcept;

2 Throws: nothing.

20.9.11.3.5 weak_ptr observers

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.

20.9.11.3.6 weak_ptr specialized algorithms

Before p. 1
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

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.

20.9.11.5 shared_ptr atomic access

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.

20.9.12 Pointer safety

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.

21.4 Class template basic_string

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

21.4.2 basic_string constructors and assigment operators

After p. 20
basic_string<charT,traits,Allocator>&
  operator=(basic_string<charT,traits,Allocator>&& str) noexcept;

23 Throws: Nothing.

21.4.4 basic_string capacity

Before p. 1
size_type size() const noexcept;

2 Throws: nothing.

21.4.5 basic_string element access

Before p. 1
const_reference operator[](size_type pos) const noexcept;
reference operator[](size_type pos) noexcept;

3 Throws: nothing.

21.4.6.3 basic_string::assign

After p. 2
basic_string&
  assign(basic_string&& str) noexcept;

3 Throws: nothing.

21.4.6.8 basic_string::swap

Before p. 1
void swap(basic_string<charT,traits,Allocator>& s) noexcept;

1 Throws: Nothing.

21.4.7.1 basic_string accessors

Before p. 1
const charT* c_str() const noexcept;
const charT* data() const noexcept;

2 Throws: nothing.

23.3 Sequence containers

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

23.3.1.8 Tuple interface to class template array

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.

23.3.3 Class template forward_list

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

23.3.3.4 forward_list modifiers

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.

23.3.3.5 forward_list operations

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.

23.3.4 Class template list

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

23.3.4.3 list modifiers

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.

23.3.4.4 list operations

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

23.4.1 Class template vector

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

23.4.1.3 vector data

Before p. 1
T* data() noexcept;
const T* data() const noexcept;

3 Throws: Nothing.

26.5.6 Class random_device

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;

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

After p. 5
valarray(valarray<T>&& v) noexcept;

8 Throws: Nothing.

26.6.2.2 valarray assignment

After p. 2
valarray<T>& operator=(valarray<T>&& v) noexcept;

5 Throws: Nothing.

26.6.2.7 valarray member functions

Before p. 1
void swap(valarray& v) noexcept;

3 Throws: Nothing.

27.5.4 Class template basic_ios

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;

  };
}

27.5.4.2 Member functions

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.

27.7.2.4 Class basic_ostream::sentry

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.

28.8 Class template basic_regex

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

28.8.2 basic_regex constructors

After p. 11
basic_regex(basic_regex&& e) noexcept;

14 Throws: nothing.

28.8.3 basic_regex assign

After p. 8
basic_regex& assign(basic_regex&& that) noexcept;

11 Throws: nothing.

28.10 Class template match_results

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

28.10.1 match_results constructors

After p. 7
match_results& operator=(match_results&& m) noexcept;

9 Throws: Nothing.

30.3.1 Class thread

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

30.3.1.1 Class thread::id

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

30.3.1.2 thread constructors

Before p. 1
thread() noexcept;

3 Throws: Nothing.

After p. 9
thread(thread&& x) noexcept;

12 Throws: Nothing.

30.3.1.3 thread destructor

Before p. 1
~thread();

1 Throws: Nothing.

30.3.1.4 thread assignment

Before p. 1
thread& operator=(thread&& x) noexcept;

1 Throws: Nothing.

30.3.1.5 thread members

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.

30.3.1.6 thread static members

Before p. 1
unsigned hardware_concurrency() noexcept;

2 Throws: Nothing.

30.3.2 Namespace this_thread

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.

30.4 Mutual exclusion

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

30.4.1.1 Class mutex

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

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

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

30.4.2.2 Class recursive_timed_mutex

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

30.4.3.1 Class template lock_guard

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.

30.4.3.2 Class template unique_lock

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

30.4.3.2.1 unique_lock constructors, destructor, and assignment

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.

30.4.3.2.3 unique_lock modifiers

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.

30.4.3.2.4 unique_lock observers

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.

30.4.5.1 Struct once_flag

Before p. 1
constexpr once_flag() noexcept;

4 Throws: nothing.

30.5.1 Class condition_variable

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.

30.5.2 Class condition_variable_any

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.

30.6.5 Class template promise

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.

30.6.6 Class template future

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.

30.6.7 Class template shared_future

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.

30.6.10 Class template packaged_task

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

30.6.10.1 packaged_task member functions

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.

30.6.10.2 packaged_task globals

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

2 Throws: Nothing.