The resolution of LWG 2210 missed constructors accepting a range or initializer list and allocator.

Previous resolution [SUPERSEDED]:

This wording is relative to N4582.

1. Add to the synopsis in [unord.map.overview] p3:

   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:
       […]
       unordered_map(size_type n, const hasher& hf, const allocator_type& a)
         : unordered_map(n, hf, key_equal(), a) { }
       template <class InputIterator>
         unordered_map(InputIterator f, InputIterator l, const allocator_type& a)
         : unordered_map(f, l, see below, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_map(f, l, n, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
               const allocator_type& a)
         : unordered_map(f, l, n, hf, key_equal(), a) { }
       unordered_map(initializer_list<value_type> il, const allocator_type& a)
         : unordered_map(il, see below, hasher(), key_equal(), a) { }
       unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
         : unordered_map(il, n, hasher(), key_equal(), a) { }
       […]
     };
   }
   

2. Add to the synopsis in [unord.multimap.overview] p3:

   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:
       […]
       unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
         : unordered_multimap(n, hf, key_equal(), a) { }
       template <class InputIterator>
         unordered_multimap(InputIterator f, InputIterator l, const allocator_type& a)
         : unordered_multimap(f, l, see below, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
               const allocator_type& a)
         : unordered_multimap(f, l, n, hf, key_equal(), a) { }
       unordered_multimap(initializer_list<value_type> il, const allocator_type& a)
         : unordered_multimap(il, see below, hasher(), key_equal(), a) { }
       unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
         : unordered_multimap(il, n, hasher(), key_equal(), a) { }
       […]
     };
   }
   

3. Add to the synopsis in [unord.set.overview] p3:

   namespace std {
     template <class Key,
       class Hash = hash<Key>,
       class Pred = std::equal_to<Key>,
       class Allocator = std::allocator<Key> > {
     class unordered_set {
     public:
       […]
       unordered_set(size_type n, const hasher& hf, const allocator_type& a)
         : unordered_set(n, hf, key_equal(), a) { }
       template <class InputIterator>
         unordered_set(InputIterator f, InputIterator l, const allocator_type& a)
         : unordered_set(f, l, see below, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_set(f, l, n, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
               const allocator_type& a)
         : unordered_set(f, l, n, hf, key_equal(), a) { }
       unordered_set(initializer_list<value_type> il, const allocator_type& a)
         : unordered_set(il, see below, hasher(), key_equal(), a) { }
       unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a)
         : unordered_set(il, n, hasher(), key_equal(), a) { }
       […]
     };
   }
   

4. Add to the synopsis in [unord.multiset.overview] p3:

   namespace std {
     template <class Key,
       class Hash = hash<Key>,
       class Pred = std::equal_to<Key>,
       class Allocator = std::allocator<Key> > {
     class unordered_multiset {
     public:
       […]
       unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
         : unordered_multiset(n, hf, key_equal(), a) { }
       template <class InputIterator>
         unordered_multiset(InputIterator f, InputIterator l, const allocator_type& a)
         : unordered_multiset(f, l, see below, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
       template <class InputIterator>
         unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
               const allocator_type& a)
         : unordered_multiset(f, l, n, hf, key_equal(), a) { }
       unordered_multiset(initializer_list<value_type> il, const allocator_type& a)
         : unordered_multiset(il, see below, hasher(), key_equal(), a) { }
       unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
         : unordered_multiset(il, n, hasher(), key_equal(), a) { }
       […]
     };
   }