﻿<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  <title>N3263 - More on noexcept for the Containers Library (revision)</title>

  <style type="text/css">
    p {text-align:justify}
    li {text-align:justify}
    ins {background-color:#A0FFA0}
    del {background-color:#FF6666}
    
    tr.TITLE_ROW {text-align: center; font-weight: bold}
    tr.DELETED {background: #FF6666; text-decoration: line-through}
    tr.INSERTED {background: #FFFF99}
  </style>

  </head>

  <body>
<address>Document number: N3263=11-0033<br/>
  Date: 2011-03-25<br/>
  J. Daniel Garcia<br/>
  Project: Programming Language C++, Library Working Group<br />
  Reply To: <a href="mailto:josedaniel.garcia@uc3m.es">josedaniel.garcia@uc3m.es</a>
</address>
 
<hr/>

<h1>N3263 - More on noexcept for the Containers Library (revision)</h1>

<p>This paper studies possible changes to the Containers Library to make broad use of noexcept. The paper 
addresses National Body comments CH 16 and GB 60.</p>

<p>
Changes in this paper are <b>restricted to chapter 23</b> (containers library).
</p>

<p>
All changes in this paper are relative to N3242.
</p>

<h2>Discussion</h2>

<p>After discussion in Library Working Group of guidelines for applying noexcept to the standard library (N3248), this paper has been revised to apply noexcept accordingly to those guidelines</p>

<h2>Acknowledgments</h2>

A previous version (N3187) was revised by Daniel Kr&uuml;gler.
The following people made very useful suggestions: Francisco Palomo, Martin Sebor, and Daniel Kr&uuml;gler.

<h1>Proposed Wording</h1>

<h3>23.3 Sequence containers [sequences]</h3>

After p. 1
<pre>
namespace std {
  #include &lt;initializer_list&gt;

...
  template &lt;class T, size_t N &gt;
    void swap(array&lt;T,N&gt;&amp; x, array&lt;T,N&gt;&amp; y)<ins>noexcept(noexcept(x.swap(y)))</ins>;
...
}
</pre>

<h3>23.3.2 Class template array [array]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class T, size_t N &gt;
  struct array {
...

    // No explicit construct/copy/destroy for aggregate type
...
    void swap(array<T, N>&amp;)<ins> noexcept(noexcept(swap(declval&lt;T&amp;&gt;(), declval&lt;T&amp;&gt;())))</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // capacity:
    constexpr size_type size()<ins> noexcept</ins>;
    constexpr size_type max_size()<ins> noexcept</ins>;
    constexpr bool empty()<ins> noexcept</ins>;

    // element access:
    reference operator[](size_type n);
    const_reference operator[](size_type n) const;
    const_reference at(size_type n) const;
    reference at(size_type n);
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;
    T * data()<ins> noexcept</ins>;
    const T * data() const<ins> noexcept</ins>;
  };
}
</pre>

<h3>23.3.2.3 array specialized algorithms [array.special]</h3>

Before p. 1
<pre>
template &lt;class T, size_t N&gt; void swap(array&lt;T,N&gt;&amp; x, array&lt;T,N&gt;&amp; y)<ins>
  noexcept(noexcept(x.swap(y)))</ins>;
</pre>

<h3>23.3.2.4 array::size [array.size]</h3>

Before p. 1
<pre>template &lt;class T, size_t N&gt; constexpr size_type array&lt;T,N&gt;::size()<ins> noexcept</ins>;</pre>

<h3>23.3.2.5 array::data [array.data]</h3>

Before p. 1
<pre>
T *data()<ins> noexcept</ins>;
const T *data() const<ins> noexcept</ins>;
</pre>

<h3>23.3.2.7 array::swap [array.swap]</h3>

Before p. 1
<pre>void swap(array&amp; y)<ins> noexcept(noexcept(swap(declval&lt;T&amp;&gt;(), declval&lt;T&amp;&gt;())))</ins>;</pre>

<h3>23.3.2.8 Zero sized arrays [array.zero]</h3>

After p.3
<p><ins>? Member function <tt>swap()</tt> shall have a <em>noexcept-specification</em> which is equivalent to <tt>noexcept(true)</tt>.</ins></p>

<h3>23.3.3 Class template deque [deque]</h3>

After p. 2
<pre>
namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class deque {
    public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;
    
    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;
    
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;
    
    // 23.3.2.2 capacity:
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;
    void resize(size_type sz);
    void resize(size_type sz, const T&amp; c);
    void shrink_to_fit();
    bool empty() const<ins> noexcept</ins>;
    
...
    
    void swap(deque&lt;T,Allocator&gt;&amp;);
    void clear()<ins> noexcept</ins>;
  };

...
}
</pre>

<h3>23.3.4 Class template forward_list [forwardlist]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class forward_list {
    ...
    allocator_type get_allocator() const<ins> noexcept</ins>;
    ...
    // 23.3.3.2 iterators:
    iterator before_begin()<ins> noexcept</ins>;
    const_iterator before_begin() const<ins> noexcept</ins>;
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cbefore_begin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;

    // capacity:
    bool empty() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    ...
    void swap(forward_list&lt;T,Allocator&gt;&amp;);

    void resize(size_type sz);
    void resize(size_type sz, value_type c);
    void clear()<ins> noexcept</ins>;
    ...
  };

...
}
</pre>

<h3>23.3.4.3 forward_list iterators [forwardlist.iter]</h3>

Before p. 1
<pre>
iterator before_begin()<ins> noexcept</ins>;
const_iterator before_begin() const<ins> noexcept</ins>;
const_iterator cbefore_begin() const<ins> noexcept</ins>;
</pre>

<h3>23.3.4.5 forward_list modifiers [forwardlist.modifiers]</h3>

After p. 27
<pre>void clear()<ins> noexcept</ins>;</pre>

<h3>23.3.5 Class template list [list]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class list {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // 23.3.4.2 capacity:
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;
    void resize(size_type sz);
    void resize(size_type sz, const T&amp; c);
...
    // 23.3.4.3 modifiers:
...
    void swap(list&lt;T,Allocator&gt;&amp;);
    void clear()<ins> noexcept</ins>;
...
  };
...

}
</pre>

<h3>23.3.6 Class template vector [vector]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class vector {
    public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // 23.4.1.2 capacity:
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;
    void resize(size_type sz);
    void resize(size_type sz, const T&amp; c);
    size_type capacity() const<ins> noexcept</ins>;
    bool empty() const<ins> noexcept</ins>;
    void reserve(size_type n);
    void shrink_to_fit();

...
    void swap(vector&lt;T,Allocator&gt;&amp;);
    void clear()<ins> noexcept</ins>;
  };
...
  // specialized algorithms:
  template &lt;class T, class Allocator&gt;
    void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);

}
</pre>

<h3>23.3.6.3 vector capacity [vector.capacity]</h3>

Before p. 1
<pre>size_type capacity() const<ins> noexcept</ins>;</pre>

<h3>23.3.8 Class vector&lt;bool&gt; overview [vector.bool]</h3>

After p. 1
<pre>
namespace std {
  template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {
  public:
...
    // bit reference:
    class reference {
      friend class vector;
      reference()<ins> noexcept</ins>;
    public:
      ~reference();
      operator bool() const<ins> noexcept</ins>;
      reference&amp; operator=(const bool x)<ins> noexcept</ins>;
      reference&amp; operator=(const reference&amp; x)<ins> noexcept</ins>;
      void flip()<ins> noexcept</ins>; // flips the bit
    };

...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // capacity:
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;
    void resize(size_type sz, bool c = false);
    size_type capacity() const<ins> noexcept</ins>;
    bool empty() const<ins> noexcept</ins>;
    void reserve(size_type n);
    void shrink_to_fit();
...
    // modifiers:
...
    void swap(vector&lt;bool,Allocator&gt;&amp;);
    static void swap(reference x, reference y)<ins> noexcept</ins>;
    void flip()<ins> noexcept</ins>; // flips all bits
    void clear()<ins> noexcept</ins>;
  };
</pre>

After p. 4
<pre>void flip()<ins> noexcept</ins>;</pre>

After p. 5
<pre>static void swap(reference x, reference y)<ins> noexcept</ins>;</pre>

<h3>23.4.5 Class template map [map]</h3>

After p. 2
<pre>
namespace std {
  template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
            class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
  class map {
  public:
...
    // 23.6.1.1 construct/copy/destroy:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;

    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // capacity:
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;
...
// modifiers:
...
    void clear()<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h3>23.4.5 Class template multimap [multimap]</h3>

After p. 2
<pre>
namespace std {
  template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
            class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
  class multimap {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;

    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // capacity:
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;
...
    // modifiers:
...
    void clear()<ins> noexcept</ins>;
...
  };

...
}
</pre>

<h3>23.4.6 Class template set [set]</h3>

After p. 2
<pre>
namespace std {
  template &lt;class Key, class Compare = less&lt;Key&gt;,
            class Allocator = allocator&lt;Key&gt; &gt;
  class set {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;

    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // capacity:
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    // modifiers:
...
    void clear()<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h3>23.4.7 Class template multiset [multiset]</h3>

After p. 2
<pre>
namespace std {
  template &lt;class Key, class Compare = less&lt;Key&gt;,
            class Allocator = allocator&lt;Key&gt; &gt;
  class multiset {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // iterators:
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;

    reverse_iterator rbegin()<ins> noexcept</ins>;
    const_reverse_iterator rbegin() const<ins> noexcept</ins>;
    reverse_iterator rend()<ins> noexcept</ins>;
    const_reverse_iterator rend() const<ins> noexcept</ins>;

    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;
    const_reverse_iterator crbegin() const<ins> noexcept</ins>;
    const_reverse_iterator crend() const<ins> noexcept</ins>;

    // capacity:
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    // modifiers:
...
    void clear()<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h3>23.5.4 Class template unordered_map [unord.map]</h3>

After p. 3
<pre>
namespace std {
template &lt;class Key,
          class T,
          class Hash = hash&lt;Key&gt;,
          class Pred = std::equal_to&lt;Key&gt;,
          class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
  class unordered_map
  {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // size and capacity
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    // iterators
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;

    // modifiers
...
    void clear()<ins> noexcept</ins>;
...
    // bucket interface
    size_type bucket_count() const<ins> noexcept</ins>;
    size_type max_bucket_count() const<ins> noexcept</ins>;
...
    // hash policy
    float load_factor() const<ins> noexcept</ins>;
    float max_load_factor() const<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h3>23.5.5 Class template unordered_multimap [unord.multimap]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class Key,
            class T,
            class Hash = hash&lt;Key&gt;,
            class Pred = std::equal_to&lt;Key&gt;,
            class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
  class unordered_multimap
  {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // size and capacity
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    // iterators
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;

    // modifiers
...
    void clear()<ins> noexcept</ins>;
...
    // bucket interface
    size_type bucket_count() const<ins> noexcept</ins>;
    size_type max_bucket_count() const<ins> noexcept</ins>;
...
    // hash policy
    float load_factor() const<ins> noexcept</ins>;
    float max_load_factor() const<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h3>23.5.6 Class template unordered_set [unord.set]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class Key,
            class Hash = hash&lt;Key&gt;,
            class Pred = std::equal_to&lt;Key&gt;,
            class Alloc = std::allocator&lt;Key&gt; &gt;
   class unordered_set
  {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // size and capacity
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    // iterators
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;

    // modifiers
...
    void clear()<ins> noexcept</ins>;
...
    // bucket interface
    size_type bucket_count() const<ins> noexcept</ins>;
    size_type max_bucket_count() const<ins> noexcept</ins>;
...
    // hash policy
    float load_factor() const<ins> noexcept</ins>;
    float max_load_factor() const<ins> noexcept</ins>;
...
  };

}
</pre>

<h3>23.5.7 Class template unordered_multiset [unord.multiset]</h3>

After p. 3
<pre>
namespace std {
  template &lt;class Key,
            class Hash = hash&lt;Key&gt;,
            class Pred = std::equal_to&lt;Key&gt;,
            class Alloc = std::allocator&lt;Key&gt; &gt;
  class unordered_multiset
  {
  public:
...
    allocator_type get_allocator() const<ins> noexcept</ins>;

    // size and capacity
    bool empty() const<ins> noexcept</ins>;
    size_type size() const<ins> noexcept</ins>;
    size_type max_size() const<ins> noexcept</ins>;

    // iterators
    iterator begin()<ins> noexcept</ins>;
    const_iterator begin() const<ins> noexcept</ins>;
    iterator end()<ins> noexcept</ins>;
    const_iterator end() const<ins> noexcept</ins>;
    const_iterator cbegin() const<ins> noexcept</ins>;
    const_iterator cend() const<ins> noexcept</ins>;

    // modifiers
...
    void clear()<ins> noexcept</ins>;
...
    // bucket interface
    size_type bucket_count() const<ins> noexcept</ins>;
    size_type max_bucket_count() const<ins> noexcept</ins>;
...
    // hash policy
    float load_factor() const<ins> noexcept</ins>;
    float max_load_factor() const<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h2>23.6.2 Header <queue> synopsis [queue.syn]</h2>

<pre>
...
template &lt;class T, class <del>Allocator</del><ins>Container</ins>&gt;
void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y)<ins> noexcept(noexcept(x.swap(y)))</ins>;
template &lt;class T, class Container, class Compare&gt;
void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y)<ins> noexcept(noexcept(x.swap(y)))</ins>;
...
</pre>

<h2>23.6.3.1 queue definition [queue.defn]</h2>

<pre>
namespace std {
  template &lt;class T, class Container = deque&lt;T&gt; &gt;
  class queue {
  public:
...
    queue(queue&amp;&amp; q)<ins> noexcept(<em>see below</em>)</ins>;
...
    queue&amp; operator=(queue&amp;&amp; q)<ins> noexcept(<em>see below</em>)</ins>;
...    
    void swap(queue&amp; q) <ins>noexcept(noexcept(swap(c,q.c)))</ins>
      { using std::swap; swap(c, q.c); }
  };
...
  template &lt;class T, class Container&gt;
    void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y)
      <ins>noexcept(noexcept(x.swap(y)))</ins>;
...
}
</pre>

<h3>23.6.3.2 queue constructors [queue.cons]</h3>

After p. 2
<pre>queue(queue&amp;&amp; q)<ins> noexcept(</em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;Container&gt;::value</ins>
</pre>

After p. 3
<pre>queue&amp; operator=(queue&amp;&amp; q)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_move_assignable&lt;Container&gt;::value</ins>
</pre>

<h3>23.6.3.5 queue specialized algorithms [queue.special]</h3>

Before p. 1
<pre>
template &lt;class T, class Container&gt;
  void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y)<ins>noexcept(noexcept(x.swap(y)))</ins>;
</pre>

<h3>23.6.4 Class template priority_queue [priority.queue]</h3>

After p. 1
<pre>
namespace std {
  template &lt;class T, class Container = vector&lt;T&gt;,
    class Compare = less&lt;typename Container::value_type&gt; &gt;
  class priority_queue {
  public:
...
    priority_queue(priority_queue&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
...
    priority_queue&amp; operator=(priority_queue&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
...
    void swap(priority_queue&amp;<ins> q</ins>)<ins> noexcept(
        noexcept(swap(c, q.c)) &amp;&amp; 
        noexcept(swap(comp, q.comp)))</ins>
      { using std::swap; swap(c, q.c); swap(comp, q.comp); }
  };
  // no equality is provided
  template &lt;class T, class Container, class Compare&gt;
    void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y)<ins>
      noexcept(noexcept(x.swap(y)))</ins>;
...
}
</pre>

<h3>23.6.4.1 priority_queue constructors [priqueue.cons]</h3>

After p. 4
<pre>
priority_queue(priority_queue&amp;&amp; q)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_move_constructible&lt;Compare&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_move_constructible&lt;Container&gt;::value</ins>
</pre>

After p. 5
<pre>priority_queue&amp; operator=(priority_queue&amp;&amp; q)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_move_assignable&lt;Compare&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_move_assignable&lt;Container&gt;::value</ins>
</pre>

<h3>23.6.4.4 priority_queue specialized algorithms [priqueue.special]</h3>

Before p. 1
<pre>
template &lt;class T, class Container, Compare&gt;
  void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y)
    <ins>noexcept(noexcept(x.swap(y)))</ins>;
</pre>

<h3>23.6.5.1 Header <stack> synopsis [stack.syn]</h3>

<pre>
...
  template &lt;class T, class Container&gt;
    void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y)<ins> noexcept(noexcept(x.swap(y)))</ins>;
}
</pre>

<h3>23.6.5.2 stack definition [stack.defn]</h3>

<pre>
namespace std {
  template &lt;class T, class Container = deque&lt;T&gt; &gt;
  class stack {
  public:
...
    explicit stack(Container&amp;&amp; = Container());
    stack(stack&amp;&amp;s)<ins> noexcept(<em>see below</em>)</ins>;
...
    stack&amp; operator=(stack&amp;&amp; s)<ins> noexcept(<em>see below</em>)</ins>;
...
    void swap(stack&amp; s)<ins> noexcept(noexcept(swap(c, s.c)))</ins> { using std::swap; swap(c, s.c); }
  };
...
  template &lt;class T, class Container, class Alloc&gt;
    struct uses_allocator&lt;stack&lt;T, Container&gt;, Alloc&gt;
      : uses_allocator&lt;Container, Alloc&gt;::type { };
}
</pre>

<h3>23.6.5.3 stack constructors [stack.cons]</h3>

Before p. 1
<pre>stack(stack&amp;&amp; s)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_move_constructible&lt;Container&gt;::value</ins>
</pre>

After p. 1
<pre>stack&amp; operator=(stack&amp;&amp; s)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_move_assignable&lt;Container&gt;::value</ins>
</pre>

<h3>23.6.5.6 stack specialized algorithms [stack.special]</h3>

Before p. 1
<pre>
template &lt;class T, class Container&gt;
  void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y)<ins>noexcept(noexcept(x.swap(y)))</ins>;
</pre>



</body>
</html>
