Title
More missing allocator-extended constructors for unordered containers
Status
new
Section
[unord]
Submitter
Billy Robert O'Neal III

Created on 2016-05-20.00:00:00 last changed 1 month ago

Messages

Date: 2020-11-29.13:56:45

Proposed resolution:

This resolution is relative to N4687.

  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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_map(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  2. Insert the following new prototype specification just after [unord.map.cnstr] p2

    template <class InputIterator>
      unordered_map(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_map(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_map(initializer_list<value_type> il, const allocator_type& a)
      : unordered_map(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The initial number of buckets supplied by the size_type argument is implementation-defined.

  3. 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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_multimap(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  4. Insert the following new prototype specification just after [unord.multimap.cnstr] p2

    template <class InputIterator>
      unordered_multimap(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_multimap(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_multimap(initializer_list<value_type> il, const allocator_type& a)
      : unordered_multimap(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The initial number of buckets supplied by the size_type argument is implementation-defined.

  5. 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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_set(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  6. Insert the following new prototype specification just after [unord.set.cnstr] p2

    template <class InputIterator>
      unordered_set(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_set(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_set(initializer_list<value_type> il, const allocator_type& a)
      : unordered_set(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The initial number of buckets supplied by the size_type argument is implementation-defined.

  7. 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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_multiset(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  8. Insert the following new prototype specification just after [unord.multiset.cnstr] p2

    template <class InputIterator>
      unordered_multiset(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_multiset(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_multiset(initializer_list<value_type> il, const allocator_type& a)
      : unordered_multiset(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The initial number of buckets supplied by the size_type argument is implementation-defined.

Date: 2020-11-15.00:00:00

[ 2020-11-29; Reflector discussions ]

It has been pointed out that this issue is related to LWG 1199, LWG 2210, and LWG 3506.

Date: 2017-08-15.00:00:00

[ 2017-08-04, Daniel and Alisdair finetune wording ]

We decided to improve the added Remarks: elements by changing from the previous form:

Remarks: The number of buckets is implementation-defined.

to the more elaborate form:

Remarks: The initial number of buckets supplied by the size_type argument is implementation-defined.

Date: 2017-08-04.19:19:38

[ Oulu, 2016-06 ]

Alisdair to review wording.

Previous resolution [SUPERSEDED]:

This wording is relative to N4594.

  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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_map(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  2. Insert the following new prototype specification just after [unord.map.cnstr] p2

    template <class InputIterator>
      unordered_map(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_map(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_map(initializer_list<value_type> il, const allocator_type& a)
      : unordered_map(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The number of buckets is implementation-defined.

  3. 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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_multimap(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  4. Insert the following new prototype specification just after [unord.multimap.cnstr] p2

    template <class InputIterator>
      unordered_multimap(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_multimap(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_multimap(initializer_list<value_type> il, const allocator_type& a)
      : unordered_multimap(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The number of buckets is implementation-defined.

  5. 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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_set(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  6. Insert the following new prototype specification just after [unord.set.cnstr] p2

    template <class InputIterator>
      unordered_set(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_set(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_set(initializer_list<value_type> il, const allocator_type& a)
      : unordered_set(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The number of buckets is implementation-defined.

  7. 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);
        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(initializer_list<value_type> il, size_type n, const allocator_type& a)
          : unordered_multiset(il, n, hasher(), key_equal(), a) { }
        […]
      };
    }
    
  8. Insert the following new prototype specification just after [unord.multiset.cnstr] p2

    template <class InputIterator>
      unordered_multiset(InputIterator f, InputIterator l, const allocator_type& a)
        : unordered_multiset(f, l, size_type(see below), hasher(), key_equal(), a) { }
    
    unordered_multiset(initializer_list<value_type> il, const allocator_type& a)
      : unordered_multiset(il, size_type(see below), hasher(), key_equal(), a) { }
    

    -?- Remarks: The number of buckets is implementation-defined.

Date: 2016-06-20.22:02:35

[ 2016-06, Oulu — Daniel comments and provides new wording ]

During the LWG discussion of this issue it has been observed, that the interpretation of the embedded see below is not really clear and that we should split declaration and definition of the new overloads, so that we have a place that allows us to specify what "see below" stands for. In addition, the new wording wraps the "see below" as "size_type(see below)" to clarify the provided expression type, similar as we did for the default constructor of unordered_map.

Date: 2016-06-20.22:02:35

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) { }
        […]
      };
    }
    
History
Date User Action Args
2020-11-29 13:56:45adminsetmessages: + msg11633
2017-08-04 19:19:38adminsetmessages: + msg9437
2016-06-28 13:53:39adminsetmessages: + msg8217
2016-06-20 22:02:35adminsetmessages: + msg8187
2016-05-21 14:05:26adminsetmessages: + msg8128
2016-05-20 00:00:00admincreate