This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of C++14 status.

2050. Unordered associative containers do not use allocator_traits to define member types

Section: 24.5 [unord] Status: C++14 Submitter: Tom Zieberman Opened: 2011-04-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [unord].

View all issues with C++14 status.

Discussion:

The unordered associative containers define their member types reference, const_reference, pointer, const_pointer in terms of their template parameter Allocator (via allocator_type 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 pointer and const_pointer typedefs in terms of allocator_traits<Allocator> and by defining reference and const_reference in terms of value_type as is done in the other containers.

[ 2011 Bloomington. ]

Move to Ready.

Proposed resolution:

This wording is relative to the FDIS.

• Change 24.5.4.1 [unord.map.overview] paragraph 3 as indicated:

  namespace std {
    template <class Key,
              class T,
              class Hash = hash<Key>,
              class Pred = std::equal_to<Key>,
              class Allocator = std::allocator<std::pair<const Key, T> > >
    class unordered_map
    {
    public:
      // types
      typedef Key key_type;
      typedef std::pair<const Key, T> value_type;
      typedef T mapped_type;
      typedef Hash hasher;
      typedef Pred key_equal;
      typedef Allocator allocator_type;
      typedef typename allocator_typeallocator_traits<Allocator>::pointer pointer;
      typedef typename allocator_typeallocator_traits<Allocator>::const_pointer const_pointer;
      typedef typename allocator_type::referencevalue_type& reference;
      typedef typename allocator_type::const_referenceconst value_type& const_reference;
      typedef implementation-defined size_type;
      typedef implementation-defined difference_type;
  
      […]
    };
  }
  

• Change 24.5.5.1 [unord.multimap.overview] paragraph 3 as indicated:

  namespace std {
    template <class Key,
              class T,
              class Hash = hash<Key>,
              class Pred = std::equal_to<Key>,
              class Allocator = std::allocator<std::pair<const Key, T> > >
    class unordered_multimap
    {
    public:
      // types
      typedef Key key_type;
      typedef std::pair<const Key, T> value_type;
      typedef T mapped_type;
      typedef Hash hasher;
      typedef Pred key_equal;
      typedef Allocator allocator_type;
      typedef typename allocator_typeallocator_traits<Allocator>::pointer pointer;
      typedef typename allocator_typeallocator_traits<Allocator>::const_pointer const_pointer;
      typedef typename allocator_type::referencevalue_type& reference;
      typedef typename allocator_type::const_referenceconst value_type& const_reference;
      typedef implementation-defined size_type;
      typedef implementation-defined difference_type;
  
      […]
    };
  }
  

• Change 24.5.6.1 [unord.set.overview] paragraph 3 as indicated:

  namespace std {
    template <class Key,
              class Hash = hash<Key>,
              class Pred = std::equal_to<Key>,
              class Allocator = std::allocator<Key> >
    class unordered_set
    {
    public:
      // types
      typedef Key key_type;
      typedef Key value_type;
      typedef Hash hasher;
      typedef Pred key_equal;
      typedef Allocator allocator_type;
      typedef typename allocator_typeallocator_traits<Allocator>::pointer pointer;
      typedef typename allocator_typeallocator_traits<Allocator>::const_pointer const_pointer;
      typedef typename allocator_type::referencevalue_type& reference;
      typedef typename allocator_type::const_referenceconst value_type& const_reference;
      typedef implementation-defined size_type;
      typedef implementation-defined difference_type;
  
      […]
    };
  }
  

• Change 24.5.7.1 [unord.multiset.overview] paragraph 3 as indicated:

  namespace std {
    template <class Key,
              class Hash = hash<Key>,
              class Pred = std::equal_to<Key>,
              class Allocator = std::allocator<Key> >
    class unordered_multiset
    {
    public:
      // types
      typedef Key key_type;
      typedef Key value_type;
      typedef Hash hasher;
      typedef Pred key_equal;
      typedef Allocator allocator_type;
      typedef typename allocator_typeallocator_traits<Allocator>::pointer pointer;
      typedef typename allocator_typeallocator_traits<Allocator>::const_pointer const_pointer;
      typedef typename allocator_type::referencevalue_type& reference;
      typedef typename allocator_type::const_referenceconst value_type& const_reference;
      typedef implementation-defined size_type;
      typedef implementation-defined difference_type;
  
      […]
    };
  }