<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Issue 2050: Unordered associative containers do not use allocator_traits to define member types</title>
<meta property="og:title" content="Issue 2050: Unordered associative containers do not use allocator_traits to define member types">
<meta property="og:description" content="C++ library issue. Status: C++14">
<meta property="og:url" content="https://cplusplus.github.io/LWG/issue2050.html">
<meta property="og:type" content="website">
<meta property="og:image" content="http://cplusplus.github.io/LWG/images/cpp_logo.png">
<meta property="og:image:alt" content="C++ logo">
<style>
  p {text-align:justify}
  li {text-align:justify}
  pre code.backtick::before { content: "`" }
  pre code.backtick::after { content: "`" }
  blockquote.note
  {
    background-color:#E0E0E0;
    padding-left: 15px;
    padding-right: 15px;
    padding-top: 1px;
    padding-bottom: 1px;
  }
  ins {background-color:#A0FFA0}
  del {background-color:#FFA0A0}
  table.issues-index { border: 1px solid; border-collapse: collapse; }
  table.issues-index th { text-align: center; padding: 4px; border: 1px solid; }
  table.issues-index td { padding: 4px; border: 1px solid; }
  table.issues-index td:nth-child(1) { text-align: right; }
  table.issues-index td:nth-child(2) { text-align: left; }
  table.issues-index td:nth-child(3) { text-align: left; }
  table.issues-index td:nth-child(4) { text-align: left; }
  table.issues-index td:nth-child(5) { text-align: center; }
  table.issues-index td:nth-child(6) { text-align: center; }
  table.issues-index td:nth-child(7) { text-align: left; }
  table.issues-index td:nth-child(5) span.no-pr { color: red; }
  @media (prefers-color-scheme: dark) {
     html {
        color: #ddd;
        background-color: black;
     }
     ins {
        background-color: #225522
     }
     del {
        background-color: #662222
     }
     a {
        color: #6af
     }
     a:visited {
        color: #6af
     }
     blockquote.note
     {
        background-color: rgba(255, 255, 255, .10)
     }
  }
</style>
</head>
<body>
<hr>
<p><em>This page is a snapshot from the LWG issues list, see the <a href="lwg-active.html">Library Active Issues List</a> for more information and the meaning of <a href="lwg-active.html#C++14">C++14</a> status.</em></p>
<h3 id="2050"><a href="lwg-defects.html#2050">2050</a>. Unordered associative containers do not use <code>allocator_traits</code> to define member types</h3>
<p><b>Section:</b> 23.5 <a href="https://wg21.link/unord">[unord]</a> <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
 <b>Submitter:</b> Tom Zieberman <b>Opened:</b> 2011-04-29 <b>Last modified:</b> 2016-01-28</p>
<p><b>Priority: </b>Not Prioritized
</p>
<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
<p><b>Discussion:</b></p>
<p>The unordered associative containers define their member types <code>reference</code>, 
<code>const_reference</code>, <code>pointer</code>, <code>const_pointer</code> in terms of 
their template parameter <code>Allocator</code> (via <code>allocator_type</code> typedef). As 
a consequence, only the allocator types, that provide sufficient typedefs, are usable 
as allocators for unordered associative containers, while other containers do not have 
this deficiency. In addition to that, the definitions of said typedefs are different 
from ones used in the other containers. This is counterintuitive and introduces a certain 
level of confusion. These issues can be fixed by defining <code>pointer</code> and 
<code>const_pointer</code> typedefs in terms of <code>allocator_traits&lt;Allocator&gt;</code> 
and by defining <code>reference</code> and <code>const_reference</code> in terms of 
<code>value_type</code> as is done in the other containers.
</p>

<p><i>[
2011 Bloomington.
]</i></p>


<p>
Move to Ready.
</p>



<p id="res-2050"><b>Proposed resolution:</b></p>

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

<ul>
<li><p>Change 23.5.3.1 <a href="https://wg21.link/unord.map.overview">[unord.map.overview]</a> paragraph 3 as indicated:</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:
    <i>// types</i>
    typedef Key key_type;
    typedef std::pair&lt;const Key, T&gt; value_type;
    typedef T mapped_type;
    typedef Hash hasher;
    typedef Pred key_equal;
    typedef Allocator allocator_type;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
    typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
    typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
    typedef <i>implementation-defined</i> size_type;
    typedef <i>implementation-defined</i> difference_type;

    [&hellip;]
  };
}
</pre></blockquote>
</li>

<li><p>Change 23.5.4.1 <a href="https://wg21.link/unord.multimap.overview">[unord.multimap.overview]</a> paragraph 3 as indicated:</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:
    <i>// types</i>
    typedef Key key_type;
    typedef std::pair&lt;const Key, T&gt; value_type;
    typedef T mapped_type;
    typedef Hash hasher;
    typedef Pred key_equal;
    typedef Allocator allocator_type;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
    typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
    typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
    typedef <i>implementation-defined</i> size_type;
    typedef <i>implementation-defined</i> difference_type;

    [&hellip;]
  };
}
</pre></blockquote>
</li>

<li><p>Change 23.5.6.1 <a href="https://wg21.link/unord.set.overview">[unord.set.overview]</a> paragraph 3 as indicated:</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:
    <i>// types</i>
    typedef Key key_type;
    typedef Key value_type;
    typedef Hash hasher;
    typedef Pred key_equal;
    typedef Allocator allocator_type;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
    typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
    typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
    typedef <i>implementation-defined</i> size_type;
    typedef <i>implementation-defined</i> difference_type;

    [&hellip;]
  };
}
</pre></blockquote>
</li>

<li><p>Change 23.5.7.1 <a href="https://wg21.link/unord.multiset.overview">[unord.multiset.overview]</a> paragraph 3 as indicated:</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:
    <i>// types</i>
    typedef Key key_type;
    typedef Key value_type;
    typedef Hash hasher;
    typedef Pred key_equal;
    typedef Allocator allocator_type;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
    typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
    typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
    typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
    typedef <i>implementation-defined</i> size_type;
    typedef <i>implementation-defined</i> difference_type;

    [&hellip;]
  };
}
</pre></blockquote>
</li>

</ul>






</body>
</html>
