<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html><head>

<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

<title>C++ Library Working Group Ready Issues Bristol 2013</title>

<style type="text/css">
  p {text-align:justify}
  ins {background-color:#A0FFA0}
  del {background-color:#FFA0A0}
  blockquote.note
  {
   background-color:#E0E0E0;
   padding-left: 15px;
   padding-right: 15px;
   padding-top: 1px;
   padding-bottom: 1px;
  }
</style>
</head><body>
<address style="text-align: left;">
Document number: N3673<br>
Date: 2013-04-19<br>
Author: Daniel Kr&uuml;gler<br>
Project: Programming Language C++, Library Working Group<br>
Reply-to: <a href="mailto:daniel.kruegler@gmail.com">Daniel Kr&uuml;gler</a><br>
</address>
<hr>
<h1 style="text-align: center;">C++ Library Working Group Ready Issues Bristol 2013</h1>

<h2><a name="Proposed_resolution"></a>Proposed resolution</h2>

<h3><p>2094. <tt>duration</tt> conversion overflow shouldn't participate in overload resolution</p></h3>

<p>This wording is relative to the FDIS.</p>

<p>Change the following paragraphs of 20.11.5.1 [time.duration.cons] p4 indicated:</p>

<blockquote><pre>template &lt;class Rep2, class Period2&gt;
  constexpr duration(const duration&lt;Rep2, Period2&gt;&amp; d);
</pre><blockquote>
<p>
<i>Remarks</i>: This constructor shall not participate in overload resolution unless <ins>no 
overflow is induced in the conversion and</ins> <tt>treat_as_floating_point&lt;rep&gt;::value</tt> 
is <tt>true</tt> or both <tt>ratio_divide&lt;Period2, period&gt;::den</tt> is <tt>1</tt> and 
<tt>treat_as_floating_point&lt;Rep2&gt;::value</tt> is <tt>false</tt>. [ <i>Note</i>: This 
requirement prevents implicit truncation error when converting between integral-based duration 
types. Such a construction could easily lead to confusion about the value of the 
duration. - <i>end note</i> ]
</p></blockquote></blockquote>

<h3><p>2122. <tt>merge()</tt> stability for lists versus forward lists</p></h3>

<p>This wording is relative to the N3485.</p>

<ol>
<li><p>Change 17.6.5.7 [algorithm.stable]/1 as indicated:</p>
<blockquote><p>
When the requirements for an algorithm state that it is "stable" without further elaboration, it means:
</p><p>
[.]
</p>
<ul>
<li>For the <em>merge</em> algorithms, for equivalent elements in the original two ranges, the elements from the
first range <ins>(preserving their original order)</ins> precede the elements from the second range <ins>(preserving 
their original order)</ins>.</li>
</ul>
</blockquote>
</li>

<li><p>Change 23.3.4.6 [forwardlist.ops] as indicated:</p>
<blockquote>
<pre>void remove(const T&amp; value);
template &lt;class Predicate&gt; void remove_if(Predicate pred);
</pre>
<blockquote>
<p>
-12- <i>Effects</i>: Erases all the elements in the list referred by a list iterator <tt>i</tt> for which the following conditions
hold: <tt>*i == value</tt> (for <tt>remove()</tt>), <tt>pred(*i)</tt> is true (for <tt>remove_if()</tt>). <del>This operation shall be 
stable: the relative order of the elements that are not removed is the same as their relative order in the original
list.</del> Invalidates only the iterators and references to the erased elements.
</p><p>
-13- <i>Throws</i>: Nothing unless an exception is thrown by the equality comparison or the predicate.
</p><p>
<ins>-??- <i>Remarks</i>: Stable (17.6.5.7 [algorithm.stable]).</ins>
</p><p>
[.]
</p>
</blockquote>

<pre>void merge(forward_list&amp; x);
void merge(forward_list&amp;&amp; x);
template &lt;class Compare&gt; void merge(forward_list&amp; x, Compare comp)
template &lt;class Compare&gt; void merge(forward_list&amp;&amp; x, Compare comp)
</pre>
<blockquote>
<p>
[.]
</p><p>
-19- <i>Effects</i>: Merges <del><tt>x</tt> into <tt>*this</tt></del><ins>the two sorted ranges <tt>[begin(), end())</tt> 
and <tt>[x.begin(), x.end())</tt></ins>. <del>This operation shall be stable: for equivalent 
elements in the two lists, the elements from <tt>*this</tt> shall always precede the elements from <tt>x</tt>.</del> 
<tt>x</tt> is empty after the merge. If an exception is thrown other than by a comparison there are no effects. Pointers and 
references to the moved elements of <tt>x</tt> now refer to those same elements but as members of <tt>*this</tt>. 
Iterators referring to the moved elements will continue to refer to their elements, but they now behave as iterators into
<tt>*this</tt>, not into <tt>x</tt>.
</p><p>
-20- <i>Remarks</i>: <ins>Stable (17.6.5.7 [algorithm.stable]).</ins> The behavior is undefined if 
<tt>this-&gt;get_allocator() != x.get_allocator()</tt>.
</p><p>
[.]
</p>
</blockquote>
<pre>void sort();
template &lt;class Compare&gt; void sort(Compare comp);
</pre><blockquote>
<p>
[.]
</p><p>
-23- <i>Effects</i>: Sorts the list according to the <tt>operator&lt;</tt> or the <tt>comp</tt> function object. <del>This 
operation shall be stable: the relative order of the equivalent elements is preserved.</del> If an exception is thrown the order
of the elements in <tt>*this</tt> is unspecified. Does not affect the validity of iterators and references.
</p><p>
<ins>-??- <i>Remarks</i>: Stable (17.6.5.7 [algorithm.stable]).</ins>
</p><p>
[.]
</p>
</blockquote>
</blockquote>
</li>

<li><p>Change 23.3.5.5 [list.ops] as indicated:</p>
<blockquote>
<pre>void remove(const T&amp; value);
template &lt;class Predicate&gt; void remove_if(Predicate pred);
</pre>
<blockquote>
<p>
[.]</p><p>
-17- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p><p>
[.]</p>
</blockquote>

<pre>void merge(list&amp; x);
void merge(list&amp;&amp; x);
template &lt;class Compare&gt; void merge(list&amp; x, Compare comp)
template &lt;class Compare&gt; void merge(list&amp;&amp; x, Compare comp)
</pre>
<blockquote>
<p>
[.]
</p><p>
-24- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>. [.]
</p><p>
[.]
</p>
</blockquote>
<pre>void sort();
template &lt;class Compare&gt; void sort(Compare comp);
</pre><blockquote>
<p>
[.]
</p><p>
-30- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p><p>
[.]
</p>
</blockquote>
</blockquote>
</li>

<li><p>Change 25.3.1 [alg.copy]/12 as indicated:</p>
<blockquote>
<pre>template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
OutputIterator 
copy_if(InputIterator first, InputIterator last,
        OutputIterator result, Predicate pred);
</pre>
<blockquote>
<p>
[.]
</p><p>
-12- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Change 25.3.8 [alg.remove] as indicated:</p>
<blockquote>
<pre>template&lt;class ForwardIterator, class T&gt;
ForwardIterator 
remove(ForwardIterator first, ForwardIterator last, const T&amp; value);
template&lt;class ForwardIterator, class Predicate&gt;
ForwardIterator 
remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
</pre>
<blockquote>
<p>
[.]
</p><p>
-4- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p><p>
[.]
</p>
</blockquote>

<pre>template&lt;class InputIterator, class OutputIterator, class T&gt;
OutputIterator
remove_copy(InputIterator first, InputIterator last,
            OutputIterator result, const T&amp; value);
template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
OutputIterator
remove_copy_if(InputIterator first, InputIterator last,
               OutputIterator result, Predicate pred);
</pre>
<blockquote>
<p>
[.]
</p><p>
-11- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Change 25.4.1.2 [stable.sort]/4 as indicated:</p>
<blockquote>
<pre>template&lt;class RandomAccessIterator&gt;
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
template&lt;class RandomAccessIterator, class Compare&gt;
void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
Compare comp);
</pre>
<blockquote>
<p>
[.]
</p><p>
-4- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Change 25.4.4 [alg.merge] as indicated:</p>
<blockquote>
<pre>template&lt;class InputIterator1, class InputIterator2,
         class OutputIterator&gt;
OutputIterator
merge(InputIterator1 first1, InputIterator1 last1,
      InputIterator2 first2, InputIterator2 last2,
      OutputIterator result);
template&lt;class InputIterator1, class InputIterator2,
         class OutputIterator, class Compare&gt;
OutputIterator
merge(InputIterator1 first1, InputIterator1 last1,
      InputIterator2 first2, InputIterator2 last2,
      OutputIterator result, Compare comp);
</pre>
<blockquote>
<p>
[.]
</p><p>
-5- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p><p>
[.]
</p>
</blockquote>

<pre>template&lt;class BidirectionalIterator&gt;
void inplace_merge(BidirectionalIterator first,
                   BidirectionalIterator middle,
                   BidirectionalIterator last);
template&lt;class BidirectionalIterator, class Compare&gt;
void inplace_merge(BidirectionalIterator first,
                   BidirectionalIterator middle,
                   BidirectionalIterator last, Compare comp);
</pre>
<blockquote>
<p>
[.]
</p><p>
-9- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
</p>
</blockquote>
</blockquote>
</li>

</ol>


<h3><p>2128. Absence of global functions <tt>cbegin/cend</tt></p></h3>

<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf">N3485</a>.</p>

<ol>
<li><p>In 24.3 [iterator.synopsis], header iterator synopsis, add the following declarations:</p>

<blockquote><pre>namespace std {
  [.]
  <i>// 24.6.5, range access:</i>
  template &lt;class C&gt; auto begin(C&amp; c) -&gt; decltype(c.begin());
  template &lt;class C&gt; auto begin(const C&amp; c) -&gt; decltype(c.begin());
  template &lt;class C&gt; auto end(C&amp; c) -&gt; decltype(c.end());
  template &lt;class C&gt; auto end(const C&amp; c) -&gt; decltype(c.end());
  template &lt;class T, size_t N&gt; T* begin(T (&amp;array)[N]);
  template &lt;class T, size_t N&gt; T* end(T (&amp;array)[N]);
  <ins>template &lt;class C&gt; auto cbegin(const C&amp; c) -&gt; decltype(std::begin(c));</ins>
  <ins>template &lt;class C&gt; auto cend(const C&amp; c) -&gt; decltype(std::end(c));</ins>
  <ins>template &lt;class C&gt; auto rbegin(C&amp; c) -&gt; decltype(c.rbegin());</ins>
  <ins>template &lt;class C&gt; auto rbegin(const C&amp; c) -&gt; decltype(c.rbegin());</ins>
  <ins>template &lt;class C&gt; auto rend(C&amp; c) -&gt; decltype(c.rend());</ins>
  <ins>template &lt;class C&gt; auto rend(const C&amp; c) -&gt; decltype(c.rend());</ins>
  <ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rbegin(T (&amp;array)[N]);</ins>
  <ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rend(T (&amp;array)[N]);</ins>
  <ins>template &lt;class E&gt; reverse_iterator&lt;const E*&gt; rbegin(initializer_list&lt;E&gt; il);</ins>
  <ins>template &lt;class E&gt; reverse_iterator&lt;const E*&gt; rend(initializer_list&lt;E&gt; il);</ins>
  <ins>template &lt;class C&gt; auto crbegin(const C&amp; c) -&gt; decltype(std::rbegin(c));</ins>
  <ins>template &lt;class C&gt; auto crend(const C&amp; c) -&gt; decltype(std::rend(c));</ins>
}
</pre></blockquote>
</li>

<li><p>At the end of 24.7 [iterator.range], add:</p>

<blockquote>
<pre><ins>template &lt;class C&gt; auto cbegin(const C&amp; c) -&gt; decltype(std::begin(c));</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>std::begin(c)</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class C&gt; auto cend(const C&amp; c) -&gt; decltype(std::end(c));</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>std::end(c)</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class C&gt; auto rbegin(C&amp; c) -&gt; decltype(c.rbegin());</ins>
<ins>template &lt;class C&gt; auto rbegin(const C&amp; c) -&gt; decltype(c.rbegin());</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>c.rbegin()</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class C&gt; auto rend(C&amp; c) -&gt; decltype(c.rend());</ins>
<ins>template &lt;class C&gt; auto rend(const C&amp; c) -&gt; decltype(c.rend());</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>c.rend()</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rbegin(T (&amp;array)[N]);</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;T*&gt;(array + N)</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rend(T (&amp;array)[N]);</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;T*&gt;(array)</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class E&gt; reverse_iterator&lt;const E*&gt; rbegin(initializer_list&lt;E&gt; il);</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;const E*&gt;(il.end())</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class E&gt; reverse_iterator&lt;const E*&gt; rend(initializer_list&lt;E&gt; il);</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;const E*&gt;(il.begin())</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class C&gt; auto crbegin(const C&amp; c) -&gt; decltype(std::rbegin(c));</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>std::rbegin(c)</tt>.</ins>
</p>
</blockquote>

<pre><ins>template &lt;class C&gt; auto crend(const C&amp; c) -&gt; decltype(std::rend(c));</ins>
</pre>
<blockquote>
<p>
<ins>-?- <i>Returns</i>: <tt>std::rend(c)</tt>.</ins>
</p>
</blockquote>
</blockquote>
</li>
</ol>

<h3><p>2148. Hashing enums should be supported directly by <tt>std::hash</tt></p></h3>

<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf">N3485</a>.</p>

<ol>
<li><p>In 20.8 [function.objects], header functional synopsis, edit as indicated:</p>

<blockquote><pre>namespace std {
  [.]
  <i>// 20.8.12, hash function <del>base</del><ins>primary</ins> template:</i>
  template &lt;class T&gt; struct hash;
  [.]
}
</pre></blockquote>
</li>

<li><p>In 20.8.12 [unord.hash]/1 edit as indicated:</p>

<blockquote><p>
-1- The unordered associative containers defined in 23.5 [unord] use specializations of the class template 
<tt>hash</tt> as the default <tt>hash</tt> function. For all object types <tt>Key</tt> for which there exists a 
specialization <tt>hash&lt;Key&gt;</tt><ins>, and for all enumeration types (7.2 [dcl.enum]) Key</ins>, 
the instantiation <tt>hash&lt;Key&gt;</tt> shall: [.]
</p></blockquote>
</li>
</ol>


<h3><p>2149. Concerns about 20.8/5</p></h3>

<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf">N3485</a>.</p>

<p>Edit 20.8 [function.objects] p5:</p>

<blockquote><p>
<ins>[<i>Note:</i></ins>To enable adaptors and other components to manipulate function objects that take one or two arguments
<del>it is required that the function objects</del><ins>many of the function objects in this clause</ins> correspondingly provide 
typedefs <tt>argument_type</tt> and <tt>result_type</tt> for function objects that take one argument and <tt>first_argument_type</tt>, 
<tt>second_argument_type</tt>, and <tt>result_type</tt> for function objects that take two arguments.<ins>- <i>end note</i>]</ins>
</p></blockquote>


<h3><a name="2162"></a>2162. <tt>allocator_traits::max_size</tt> missing <tt>noexcept</tt></h3>

<p>
In 20.6.8 [allocator.traits] and 20.6.8.2 [allocator.traits.members]/7, change the function signature to
</p>
<blockquote><pre>static size_type max_size(Alloc&amp; a) <ins>noexcept</ins>;
</pre></blockquote>


<h3><a name="2176"></a>2176. Special members for <tt>wstring_convert</tt> and <tt>wbuffer_convert</tt></h3>

<p>This wording is relative to N3376.</p>

<ol>
<li><p>Edit the class template <tt>wstring_convert</tt> synopsis in 22.3.3.2.2 [conversions.string] p2:</p>

<blockquote><pre><ins>explicit</ins> wstring_convert(Codecvt *pcvt = new Codecvt);
wstring_convert(Codecvt *pcvt, state_type state);
<ins>explicit</ins> wstring_convert(const byte_string&amp; byte_err,
                         const wide_string&amp; wide_err = wide_string());
~wstring_convert();
<ins>
wstring_convert(const wstring_convert&amp;) = delete;
wstring_convert&amp; operator=(const wstring_convert&amp;) = delete;
</ins>				 
</pre></blockquote>
</li>

<li><p>Edit the signatures before 22.3.3.2.2 [conversions.string] p16:</p>

<blockquote><pre><ins>explicit</ins> wstring_convert(Codecvt *pcvt = new Codecvt);
wstring_convert(Codecvt *pcvt, state_type state);
<ins>explicit</ins> wstring_convert(const byte_string&amp; byte_err,
    const wide_string&amp; wide_err = wide_string());
</pre></blockquote>
</li>

<li><p>Edit the class template <tt>wbuffer_convert</tt> synopsis in 22.3.3.2.3 [conversions.buffer] p2:</p>

<blockquote><pre><ins>explicit</ins> wbuffer_convert(std::streambuf *bytebuf = 0,
                         Codecvt *pcvt = new Codecvt,
                         state_type state = state_type());
<ins>
~wbuffer_convert();

wbuffer_convert(const wbuffer_convert&amp;) = delete;
wbuffer_convert&amp; operator=(const wbuffer_convert&amp;) = delete;
</ins>						 
</pre></blockquote>
</li>

<li><p>Edit the signature before 22.3.3.2.3 [conversions.buffer] p10:</p>

<blockquote><pre><ins>explicit</ins> wbuffer_convert(std::streambuf *bytebuf = 0,
    Codecvt *pcvt = new Codecvt, state_type state = state_type());
</pre></blockquote>
</li>

</ol>

<h3><a name="2196"></a>2196. Specification of <tt>is_*[copy/move]_[constructible/assignable]</tt> unclear for non-referencable types</h3>

<p>This wording is relative to N3376.</p>

<ol>
<li><p>Add the following new definition to 17.3 [definitions] as indicated:</p>
<p><b>referenceable type</b> [defns.referenceable]</p>
<blockquote><p>
An object type, a function type that does not have <em>cv</em>-qualifiers or a <em>ref</em>-qualifier, or a reference type.
[<i>Note</i>: The term describes a type to which a reference can be created, including reference types. - <i>end note</i>]
</p></blockquote>
</li>

<li><p>Change Table 49 as indicated:</p>

<table border="1">
<caption>Table 49 - Type property predicates</caption>
<tbody><tr>
<th>Template</th>
<th>Condition</th>
<th>Preconditions</th>
</tr> 

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_copy_constructible;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_constructible&lt;T,</tt><br>
<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_move_constructible;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_constructible&lt;T,</tt><br>
<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td colspan="3" align="center">
<tt>.</tt>
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_copy_assignable;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_assignable&lt;T&amp;,</tt><br>
<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_move_assignable;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_assignable&lt;T&amp;,</tt><br>
<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td colspan="3" align="center">
<tt>.</tt>
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_trivially_copy_constructible;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_trivially_constructible&lt;T,</tt><br>
<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_trivially_move_constructible;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_trivially_constructible&lt;T,</tt><br>
<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td colspan="3" align="center">
<tt>.</tt>
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_trivially_copy_assignable;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_trivially_assignable&lt;T&amp;,</tt><br>
<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_trivially_move_assignable;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_trivially_assignable&lt;T&amp;,</tt><br>
<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td colspan="3" align="center">
<tt>.</tt>
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_nothrow_copy_constructible;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_nothrow_constructible&lt;T,</tt><br>
<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_nothrow_move_constructible;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_nothrow_constructible&lt;T,</tt><br>
<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td colspan="3" align="center">
<tt>.</tt>
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_nothrow_copy_assignable;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_nothrow_assignable&lt;T&amp;,</tt><br>
<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

<tr>
<td>
<tt>template &lt;class T&gt;</tt><br>
<tt>struct is_nothrow_move_assignable;</tt>
</td>
<td>
<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br>
<tt>is_nothrow_assignable&lt;T&amp;,</tt><br>
<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
</td>
<td>
<tt>T</tt> shall be a complete type,<br>
(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br> 
array of unknown bound.
</td>
</tr>

</tbody></table>

</li>
</ol>

<h3><a name="2203"></a>2203. <tt>scoped_allocator_adaptor</tt> uses wrong argument types for piecewise construction</h3>

<p>This wording is relative to N3376.</p>

<ol>
<li><p>Change 20.12.4 [allocator.adaptor.members] paragraph 11 as indicated:</p>

<blockquote>
<p>
-11- <i>Effects</i>: Constructs a <tt>tuple</tt> object <tt>xprime</tt> from <tt>x</tt> by the following rules:
</p>
<ul>
<li><p>
If <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and 
<tt>is_constructible&lt;T1, Args1...&gt;::value</tt> is <tt>true</tt>, then <tt>xprime</tt> is <tt>x</tt>.
</p></li>

<li><p>
Otherwise, if <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
<tt>is_constructible&lt;T1, allocator_arg_t, inner_allocator_type, Args1...&gt;::value</tt> is <tt>true</tt>, 
then <tt>xprime</tt> is <tt>tuple_cat(tuple&lt;allocator_arg_t, inner_allocator_type&amp;&gt;( allocator_arg, 
inner_allocator<del>_type</del>()), <ins>std::move(</ins>x<ins>)</ins>)</tt>.
</p></li>

<li><p>
Otherwise, if <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
<tt>is_constructible&lt;T1, Args1..., inner_allocator_type&gt;::value</tt> is <tt>true</tt>, then <tt>xprime</tt> 
is <tt>tuple_cat(<ins>std::move(</ins>x<ins>)</ins>, 
tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator<del>_type</del>()))</tt>.
</p></li>

<li><p>
Otherwise, the program is ill-formed.
</p></li>
</ul>
<p>
and constructs a <tt>tuple</tt> object <tt>yprime</tt> from <tt>y</tt> by the following rules:
</p>
<ul>
<li><p>
If <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and 
<tt>is_constructible&lt;T2, Args2...&gt;::value</tt> is <tt>true</tt>, then <tt>yprime</tt> is <tt>y</tt>.
</p></li>

<li><p>
Otherwise, if <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
<tt>is_constructible&lt;T2, allocator_arg_t, inner_allocator_type, Args2...&gt;::value</tt> is <tt>true</tt>, 
then <tt>yprime</tt> is <tt>tuple_cat(tuple&lt;allocator_arg_t, inner_allocator_type&amp;&gt;( allocator_arg, 
inner_allocator<del>_type</del>()), <ins>std::move(</ins>y<ins>)</ins>)</tt>.
</p></li>

<li><p>
Otherwise, if <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
<tt>is_constructible&lt;T2, Args2..., inner_allocator_type&gt;::value</tt> is <tt>true</tt>, then <tt>yprime</tt> 
is <tt>tuple_cat(<ins>std::move(</ins>y<ins>)</ins>, 
tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator<del>_type</del>()))</tt>.
</p></li>

<li><p>
Otherwise, the program is ill-formed.
</p></li>
</ul>
<p>
then calls <tt><i>OUTERMOST_ALLOC_TRAITS</i>(*this)::construct(<i>OUTERMOST</i>(*this), p,
piecewise_construct, <ins>std::move(</ins>xprime<ins>)</ins>, <ins>std::move(</ins>yprime<ins>)</ins>)</tt>.
</p>
</blockquote>
</li>
</ol>


<h3><a name="2207"></a>2207. <tt>basic_string::at</tt> should not have a Requires clause</h3>

<p>This wording is relative to N3376.</p>

<ol>
<li><p>Remove 21.4.5 [string.access] p5:</p>

<blockquote><pre>const_reference at(size_type pos) const;
reference at(size_type pos);
</pre><blockquote>
<p>
<del>-5- <i>Requires</i>: <tt>pos &lt; size()</tt></del>
</p><p>
-6- <i>Throws</i>: <tt>out_of_range</tt> if <tt>pos &gt;= size()</tt>.
</p><p>
-7- <i>Returns</i>: <tt>operator[](pos)</tt>.
</p>
</blockquote></blockquote>

</li>
</ol>


<h3><a name="2210"></a>2210. Missing allocator-extended constructor for allocator-aware containers</h3>

<p>This wording is relative to N3485.</p>

<ol>
<li><p>Edit the synopsis in 23.3.3.1 [deque.overview]/2:</p>

<blockquote>
<pre>namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class deque {
  public:
    [.]
    explicit deque(const Allocator&amp; = Allocator());
    explicit deque(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Edit 23.3.3.2 [deque.cons]/2:</p>

<blockquote>
<pre>explicit deque(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
</pre>
<blockquote>
<p>
-3- <i>Effects</i>: Constructs a <tt>deque</tt> with <tt>n</tt> default-inserted elements
<ins>using the specified allocator</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Edit the synopsis in 23.3.4.1 [forwardlist.overview]/3:</p>

<blockquote>
<pre>namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class forward_list {
  public:
    [.]
    explicit forward_list(const Allocator&amp; = Allocator());
    explicit forward_list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Edit 23.3.4.2 [forwardlist.cons]/3:</p>

<blockquote>
<pre>explicit forward_list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
</pre>
<blockquote>
<p>
-3- <i>Effects</i>: Constructs a <tt>forward_list</tt> object with <tt>n</tt> default-inserted elements
<ins>using the specified allocator</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Edit the synopsis in 23.3.5.1 [list.overview]/2:</p>

<blockquote>
<pre>namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class list {
  public:
    [.]
    explicit list(const Allocator&amp; = Allocator());
    explicit list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Edit 23.3.5.2 [list.cons]/3:</p>

<blockquote>
<pre>explicit list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
</pre>
<blockquote>
<p>
-3- <i>Effects</i>: Constructs a <tt>list</tt> with <tt>n</tt> default-inserted elements
<ins>using the specified allocator</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Edit the synopsis in 23.3.6.1 [vector.overview]/2:</p>

<blockquote>
<pre>namespace std {
  template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
  class vector {
  public:
    [.]
    explicit vector(const Allocator&amp; = Allocator());
    explicit vector(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Edit 23.3.6.2 [vector.cons]/3:</p>

<blockquote>
<pre>explicit vector(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
</pre>
<blockquote>
<p>
-3- <i>Effects</i>: Constructs a <tt>vector</tt> with <tt>n</tt> default-inserted elements
<ins>using the specified allocator</ins>.
</p>
</blockquote>
</blockquote>
</li>

<li><p>Edit the synopsis in 23.3.7 [vector.bool]/1:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {
  class vector {
  public:
    [.]
    explicit vector(const Allocator&amp; = Allocator());
    <ins>explicit vector(size_type n, const Allocator&amp; = Allocator());</ins>
    <del>explicit</del> vector(size_type n, const bool&amp; value<del> = bool()</del>,
                    const Allocator&amp; = Allocator());
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.4.4.1 [map.overview] p2:</p>

<blockquote>
<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:
    [.]
    map(initializer_list&lt;value_type&gt;,
      const Compare&amp; = Compare(),
      const Allocator&amp; = Allocator());
    <ins>template &lt;class InputIterator&gt;
    map(InputIterator first, InputIterator last, const Allocator&amp; a)
      : map(first, last, Compare(), a) { }
    map(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
      : map(il, Compare(), a) { }</ins>
    ~map();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.4.5.1 [multimap.overview] p2:</p>

<blockquote>
<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:
    [.]
    multimap(initializer_list&lt;value_type&gt;,
      const Compare&amp; = Compare(),
      const Allocator&amp; = Allocator());
    <ins>template &lt;class InputIterator&gt;
    multimap(InputIterator first, InputIterator last, const Allocator&amp; a)
      : multimap(first, last, Compare(), a) { }
    multimap(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
      : multimap(il, Compare(), a) { }</ins>
    ~multimap();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.4.6.1 [set.overview] p2:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Key, class Compare = less&lt;Key&gt;,
    class Allocator = allocator&lt;Key&gt; &gt; {
  class set {
  public:
    [.]
    set(initializer_list&lt;value_type&gt;,
      const Compare&amp; = Compare(),
      const Allocator&amp; = Allocator());
    <ins>template &lt;class InputIterator&gt;
    set(InputIterator first, InputIterator last, const Allocator&amp; a)
      : set(first, last, Compare(), a) { }
    set(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
      : set(il, Compare(), a) { }</ins>
    ~set();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.4.7.1 [multiset.overview] p2:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Key, class Compare = less&lt;Key&gt;,
    class Allocator = allocator&lt;Key&gt; &gt; {
  class multiset {
  public:
    [.]
    multiset(initializer_list&lt;value_type&gt;,
      const Compare&amp; = Compare(),
      const Allocator&amp; = Allocator());
    <ins>template &lt;class InputIterator&gt;
    multiset(InputIterator first, InputIterator last, const Allocator&amp; a)
      : multiset(first, last, Compare(), a) { }
    multiset(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
      : multiset(il, Compare(), a) { }</ins>
    ~multiset();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.5.4.1 [unord.map.overview] p3:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Key, class T,
    class Hash = hash&lt;Key&gt;,
    class Pred = std::equal_to&lt;Key&gt;,
    class Allocator = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt; {
  class unordered_map {
  public:
    [.]
    unordered_map(initializer_list&lt;value_type&gt;,
      size_type = <em>see below</em>,
      const hasher&amp; hf = hasher(),
      const key_equal&amp; eql = key_equal(),
      const allocator_type&amp; a = allocator_type());
    <ins>unordered_map(size_type n, const allocator_type&amp; a)
      : unordered_map(n, hasher(), key_equal(), a) { }
    unordered_map(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
      : unordered_map(n, hf, key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
      : unordered_map(f, l, n, hasher(), key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_map(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf, 
	    const allocator_type&amp; a)
      : unordered_map(f, l, n, hf, key_equal(), a) { }
    unordered_map(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
      : unordered_map(il, n, hasher(), key_equal(), a) { }
    unordered_map(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf, 
	  const allocator_type&amp; a)
      : unordered_map(il, n, hf, key_equal(), a) { }</ins>
    ~unordered_map();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.5.5.1 [unord.multimap.overview] p3:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Key, class T,
    class Hash = hash&lt;Key&gt;,
    class Pred = std::equal_to&lt;Key&gt;,
    class Allocator = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt; {
  class unordered_multimap {
  public:
    [.]
    unordered_multimap(initializer_list&lt;value_type&gt;,
      size_type = <em>see below</em>,
      const hasher&amp; hf = hasher(),
      const key_equal&amp; eql = key_equal(),
      const allocator_type&amp; a = allocator_type());
    <ins>unordered_multimap(size_type n, const allocator_type&amp; a)
      : unordered_multimap(n, hasher(), key_equal(), a) { }
    unordered_multimap(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
      : unordered_multimap(n, hf, key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
      : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf, 
	    const allocator_type&amp; a)
      : unordered_multimap(f, l, n, hf, key_equal(), a) { }
    unordered_multimap(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
      : unordered_multimap(il, n, hasher(), key_equal(), a) { }
    unordered_multimap(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf, 
	  const allocator_type&amp; a)
      : unordered_multimap(il, n, hf, key_equal(), a) { }</ins>
    ~unordered_multimap();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.5.6.1 [unord.set.overview] p3:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Key,
    class Hash = hash&lt;Key&gt;,
    class Pred = std::equal_to&lt;Key&gt;,
    class Allocator = std::allocator&lt;Key&gt; &gt; {
  class unordered_set {
  public:
    [.]
    unordered_set(initializer_list&lt;value_type&gt;,
      size_type = <em>see below</em>,
      const hasher&amp; hf = hasher(),
      const key_equal&amp; eql = key_equal(),
      const allocator_type&amp; a = allocator_type());
    <ins>unordered_set(size_type n, const allocator_type&amp; a)
      : unordered_set(n, hasher(), key_equal(), a) { }
    unordered_set(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
      : unordered_set(n, hf, key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
      : unordered_set(f, l, n, hasher(), key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_set(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf, 
	    const allocator_type&amp; a)
      : unordered_set(f, l, n, hf, key_equal(), a) { }
    unordered_set(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
      : unordered_set(il, n, hasher(), key_equal(), a) { }
    unordered_set(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf, 
	  const allocator_type&amp; a)
      : unordered_set(il, n, hf, key_equal(), a) { }</ins>
    ~unordered_set();
    [.]
  };
}
</pre>
</blockquote>
</li>

<li><p>Add to the synopsis in 23.5.7.1 [unord.multiset.overview] p3:</p>

<blockquote>
<pre>namespace std {
  template &lt;class Key,
    class Hash = hash&lt;Key&gt;,
    class Pred = std::equal_to&lt;Key&gt;,
    class Allocator = std::allocator&lt;Key&gt; &gt; {
  class unordered_multiset {
  public:
    [.]
    unordered_multiset(initializer_list&lt;value_type&gt;,
      size_type = <em>see below</em>,
      const hasher&amp; hf = hasher(),
      const key_equal&amp; eql = key_equal(),
      const allocator_type&amp; a = allocator_type());
    <ins>unordered_multiset(size_type n, const allocator_type&amp; a)
      : unordered_multiset(n, hasher(), key_equal(), a) { }
    unordered_multiset(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
      : unordered_multiset(n, hf, key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
      : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
    template &lt;class InputIterator&gt;
      unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf, 
	    const allocator_type&amp; a)
      : unordered_multiset(f, l, n, hf, key_equal(), a) { }
    unordered_multiset(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
      : unordered_multiset(il, n, hasher(), key_equal(), a) { }
    unordered_multiset(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf, 
	  const allocator_type&amp; a)
      : unordered_multiset(il, n, hf, key_equal(), a) { }</ins>
    ~unordered_multiset();
    [.]
  };
}
</pre>
</blockquote>
</li>
</ol>

<h3><a name="2229"></a>2229. Standard code conversion facets underspecified</h3>

<p><i>In [locale.stdcvt] paragraph 2, Header codecvt synopsis:</i></p>
<blockquote>
  <pre>template&lt;class Elem, unsigned long Maxcode = 0x10ffff,
  codecvt_mode Mode = (codecvt_mode)0&gt;
class codecvt_utf8
  : public codecvt&lt;Elem, char, mbstate_t&gt; {
  <del><i>// unspecified</i></del>
<ins>public:</ins>
  <ins>explicit codecvt_utf8(size_t refs = 0);</ins>
  <ins>~codecvt_utf8();</ins>
  };

template&lt;class Elem, unsigned long Maxcode = 0x10ffff,
  codecvt_mode Mode = (codecvt_mode)0&gt;
class codecvt_utf16
  : public codecvt&lt;Elem, char, mbstate_t&gt; {
  <del><i>// unspecified</i></del>
<ins>public:</ins>
  <ins>explicit codecvt_utf16(size_t refs = 0);</ins>
  <ins>~codecvt_utf16();</ins>
  };

template&lt;class Elem, unsigned long Maxcode = 0x10ffff,
  codecvt_mode Mode = (codecvt_mode)0&gt;
class codecvt_utf8_utf16
  : public codecvt&lt;Elem, char, mbstate_t&gt; {
  <del><i>// unspecified</i></del>
<ins>public:</ins>
  <ins>explicit codecvt_utf8_utf16(size_t refs = 0);</ins>
  <ins>~codecvt_utf8_utf16();</ins>
  };</pre>
</blockquote>


<h3><a name="2235"></a>2235. Undefined behavior without proper requirements on <tt>basic_string</tt> constructors</h3>

<p>This wording is relative to N3485.</p>

<ol>
<li><p>Change 21.4.2 [string.cons]/6 as indicated:</p>

<blockquote><pre>basic_string(const charT* s, size_type n, const Allocator&amp; a = Allocator());
</pre><blockquote>
<p>
-6- <i>Requires</i>: <tt>s</tt> <del>shall not be a null pointer and <tt>n &lt; npos</tt></del><ins>points to an array 
of at least <tt>n</tt> elements of <tt>charT</tt></ins>.
</p>
</blockquote></blockquote>

</li>

<li><p>Change 21.4.2 [string.cons]/8 as indicated:</p>

<blockquote><pre>basic_string(const charT* s, const Allocator&amp; a = Allocator());
</pre><blockquote>
<p>
-8- <i>Requires</i>: <tt>s</tt> <del>shall not be a null pointer</del><ins>points to an array 
of at least <tt>traits::length(s) + 1</tt> elements of <tt>charT</tt></ins>.
</p>
</blockquote></blockquote>

</li>
</ol>


</body></html>
