diff mbox

libstdc++/66055 add missing constructors to unordered containers

Message ID 55571056.2090807@gmail.com
State New
Headers show

Commit Message

François Dumont May 16, 2015, 9:39 a.m. UTC 
On 14/05/2015 15:47, Jonathan Wakely wrote:
> Reported by Nathan and fixed by his patch. I added the tests.
>
> Tested powerpc64le-linux, committed to trunk. This should be
> backported too.

While backporting to debug and profile mode I noticed that those 
constructors were not the only missing ones. So here is a patch to 
complete them with debug and profile modes.

Moreover this patch:
- Remove explicit keyword on one of the unordered_map constructor, 
surely the result of a copy/paste
- Use constructor delegation as proposed by the Standard
- Move code to follow Standard description order, it is easier this way 
to check that nothing is missing.

     * include/bits/unordered_map.h (unordered_map, unordered_multimap): Add
     missing constructors.
     * include/bits/unordered_set.h (unordered_set, unordered_multiset):
     Likewise.
     * include/debug/unordered_map (unordered_map, unordered_multimap): Add
     missing constructors.
     * include/debug/unordered_set (unordered_set, unordered_multiset):
     Likewise.
     * include/profile/unordered_map (unordered_map, 
unordered_multimap): Add
     missing constructors.
     * include/profile/unordered_set (unordered_set, unordered_multiset):
     Likewise.
     * testsuite/23_containers/unordered_map/cons/66055.cc: Add constructor
     invocations.
     * testsuite/23_containers/unordered_multimap/cons/66055.cc: Likewise.
     * testsuite/23_containers/unordered_multiset/cons/66055.cc: Likewise.
     * testsuite/23_containers/unordered_set/cons/66055.cc: Likewise.

Ok to commit ?

François

Comments

Jonathan Wakely May 16, 2015, 7:32 p.m. UTC | #1 
On 16/05/15 11:39 +0200, François Dumont wrote:
>On 14/05/2015 15:47, Jonathan Wakely wrote:
>>Reported by Nathan and fixed by his patch. I added the tests.
>>
>>Tested powerpc64le-linux, committed to trunk. This should be
>>backported too.
>
>While backporting to debug and profile mode I noticed that those 
>constructors were not the only missing ones. So here is a patch to 
>complete them with debug and profile modes.

Great, thanks.

>@@ -233,6 +222,41 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
> 	: _M_h(__l, __n, __hf, __eql, __a)
>       { }
> 
>+      unordered_map(size_type __n, const allocator_type& __a)
>+      : unordered_map(__n, hasher(), key_equal(), __a)
>+      { }
>+
>+      unordered_map(size_type __n, const hasher& __hf,
>+		    const allocator_type& __a)
>+      : unordered_map(__n, __hf, key_equal(), __a)
>+      { }
>+
>+      template<typename _InputIterator>
>+	unordered_map(_InputIterator __first, _InputIterator __last,
>+		      size_type __n,
>+		      const allocator_type& __a)
>+	  : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)

The indentation is inconsistent here, the ctor-initializer-list is
indented further than necessary

>@@ -891,7 +941,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
>        *  in the initializer list @a __l.
>        *
>        *  Note that the assignment completely changes the %unordered_multiset
>-       *  and that the resulting %unordered_set's size is the same as the number
>+       *  and that the resulting %unordered_multiset's size is the same as the number
>        *  of elements assigned.  Old data may be lost.

Please reformat this to stay below 80 columns.

OK with those two tiny adjustments, thanks!
François Dumont May 17, 2015, 8:21 p.m. UTC | #2 
Ok, I just commit fixing some other lines length except those having a 
long hyperlink, I didn't want to break those.

François


On 16/05/2015 21:32, Jonathan Wakely wrote:
> On 16/05/15 11:39 +0200, François Dumont wrote:
>> On 14/05/2015 15:47, Jonathan Wakely wrote:
>>> Reported by Nathan and fixed by his patch. I added the tests.
>>>
>>> Tested powerpc64le-linux, committed to trunk. This should be
>>> backported too.
>>
>> While backporting to debug and profile mode I noticed that those 
>> constructors were not the only missing ones. So here is a patch to 
>> complete them with debug and profile modes.
>
> Great, thanks.
>
>> @@ -233,6 +222,41 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
>>     : _M_h(__l, __n, __hf, __eql, __a)
>>       { }
>>
>> +      unordered_map(size_type __n, const allocator_type& __a)
>> +      : unordered_map(__n, hasher(), key_equal(), __a)
>> +      { }
>> +
>> +      unordered_map(size_type __n, const hasher& __hf,
>> +            const allocator_type& __a)
>> +      : unordered_map(__n, __hf, key_equal(), __a)
>> +      { }
>> +
>> +      template<typename _InputIterator>
>> +    unordered_map(_InputIterator __first, _InputIterator __last,
>> +              size_type __n,
>> +              const allocator_type& __a)
>> +      : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
>
> The indentation is inconsistent here, the ctor-initializer-list is
> indented further than necessary
>
>> @@ -891,7 +941,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
>>        *  in the initializer list @a __l.
>>        *
>>        *  Note that the assignment completely changes the 
>> %unordered_multiset
>> -       *  and that the resulting %unordered_set's size is the same 
>> as the number
>> +       *  and that the resulting %unordered_multiset's size is the 
>> same as the number
>>        *  of elements assigned.  Old data may be lost.
>
> Please reformat this to stay below 80 columns.
>
> OK with those two tiny adjustments, thanks!
>
>
Jonathan Wakely May 19, 2015, 2:09 p.m. UTC | #3 
On 17/05/15 22:21 +0200, François Dumont wrote:
>Ok, I just commit fixing some other lines length except those having a 
>long hyperlink, I didn't want to break those.

Yep, thanks. I think we should backport Nathan's patch and your one to
the gcc-5-branch too.

I'll make a note to do that before the 5.2 release.
diff mbox

Patch

diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h
index 069b859..6ace59d 100644
--- a/libstdc++-v3/include/bits/unordered_map.h
+++ b/libstdc++-v3/include/bits/unordered_map.h
@@ -146,17 +146,6 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : _M_h(__n, __hf, __eql, __a)
       { }
 
-      unordered_map(size_type __n, const allocator_type& __a)
-      : _M_h(__n, hasher(), key_equal(), __a)
-      { }
-
-      explicit
-      unordered_map(size_type __n,
-		    const hasher& __hf,
-		    const allocator_type& __a)
-      : _M_h(__n, __hf, key_equal(), __a)
-      { }
-
       /**
        *  @brief  Builds an %unordered_map from a range.
        *  @param  __first  An input iterator.
@@ -233,6 +222,41 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 	: _M_h(__l, __n, __hf, __eql, __a)
       { }
 
+      unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const allocator_type& __a)
+	  : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last,
+		      size_type __n, const hasher& __hf,
+		      const allocator_type& __a)
+	  : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n,
+		    const allocator_type& __a)
+	: unordered_map(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_map(__l, __n, __hf, key_equal(), __a)
+      { }
+
       /// Copy assignment operator.
       unordered_map&
       operator=(const unordered_map&) = default;
@@ -872,16 +896,6 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : _M_h(__n, __hf, __eql, __a)
       { }
 
-      unordered_multimap(size_type __n, const allocator_type& __a)
-      : _M_h(__n, hasher(), key_equal(), __a)
-      { }
-
-      unordered_multimap(size_type __n,
-			 const hasher& __hf,
-			 const allocator_type& __a)
-      : _M_h(__n, __hf, key_equal(), __a)
-      { }
-
       /**
        *  @brief  Builds an %unordered_multimap from a range.
        *  @param  __first An input iterator.
@@ -958,6 +972,41 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 	: _M_h(__l, __n, __hf, __eql, __a)
       { }
 
+      unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last,
+			   size_type __n,
+			   const allocator_type& __a)
+	  : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last,
+			   size_type __n, const hasher& __hf,
+			   const allocator_type& __a)
+	  : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n,
+			 const allocator_type& __a)
+	: unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multimap(__l, __n, __hf, key_equal(), __a)
+      { }
+
       /// Copy assignment operator.
       unordered_multimap&
       operator=(const unordered_multimap&) = default;
diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h
index c91eab8..8f9f12b 100644
--- a/libstdc++-v3/include/bits/unordered_set.h
+++ b/libstdc++-v3/include/bits/unordered_set.h
@@ -140,16 +140,6 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : _M_h(__n, __hf, __eql, __a)
       { }
 
-      unordered_set(size_type __n, const allocator_type& __a)
-      : _M_h(__n, hasher(), key_equal(), __a)
-      { }
-
-      unordered_set(size_type __n,
-                    const hasher& __hf,
-                    const allocator_type& __a)
-      : unordered_set(__n, __hf, key_equal(), __a)
-      { }
-
       /**
        *  @brief  Builds an %unordered_set from a range.
        *  @param  __first  An input iterator.
@@ -226,6 +216,41 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 	: _M_h(__l, __n, __hf, __eql, __a)
       { }
 
+      unordered_set(size_type __n, const allocator_type& __a)
+	: unordered_set(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_set(size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_set(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const allocator_type& __a)
+	  : unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __first, _InputIterator __last,
+		      size_type __n, const hasher& __hf,
+		      const allocator_type& __a)
+	  : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n,
+		    const allocator_type& __a)
+	: unordered_set(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_set(__l, __n, __hf, key_equal(), __a)
+      { }
+
       /// Copy assignment operator.
       unordered_set&
       operator=(const unordered_set&) = default;
@@ -789,16 +814,6 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : _M_h(__n, __hf, __eql, __a)
       { }
 
-      unordered_multiset(size_type __n, const allocator_type& __a)
-      : _M_h(__n, hasher(), key_equal(), __a)
-      { }
-
-      unordered_multiset(size_type __n,
-			 const hasher& __hf,
-			 const allocator_type& __a)
-      : _M_h(__n, __hf, key_equal(), __a)
-      { }
-
       /**
        *  @brief  Builds an %unordered_multiset from a range.
        *  @param  __first  An input iterator.
@@ -883,6 +898,41 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 	: _M_h(std::move(__umset._M_h), __a)
       { }
 
+      unordered_multiset(size_type __n, const allocator_type& __a)
+	: unordered_multiset(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multiset(size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multiset(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __first, _InputIterator __last,
+			   size_type __n,
+			   const allocator_type& __a)
+	  : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __first, _InputIterator __last,
+			   size_type __n, const hasher& __hf,
+			   const allocator_type& __a)
+	  : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n,
+			 const allocator_type& __a)
+	: unordered_multiset(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multiset(__l, __n, __hf, key_equal(), __a)
+      { }
+
       /**
        *  @brief  %Unordered_multiset list assignment operator.
        *  @param  __l  An initializer_list.
@@ -891,7 +941,7 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *  in the initializer list @a __l.
        *
        *  Note that the assignment completely changes the %unordered_multiset
-       *  and that the resulting %unordered_set's size is the same as the number
+       *  and that the resulting %unordered_multiset's size is the same as the number
        *  of elements assigned.  Old data may be lost.
        */
       unordered_multiset&
diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map
index 0525367..41e20d7 100644
--- a/libstdc++-v3/include/debug/unordered_map
+++ b/libstdc++-v3/include/debug/unordered_map
@@ -129,6 +129,44 @@  namespace __debug
 		    const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a) { }
 
+      unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(size_type __n,
+		    const hasher& __hf,
+		    const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const allocator_type& __a)
+	  : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const hasher& __hf,
+		      const allocator_type& __a)
+	  : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n,
+		    const allocator_type& __a)
+	: unordered_map(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n,
+		    const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_map(__l, __n, __hf, key_equal(), __a)
+      { }
+
       ~unordered_map() = default;
 
       unordered_map&
@@ -550,6 +588,41 @@  namespace __debug
 			 const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a) { }
 
+      unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last,
+			   size_type __n,
+			   const allocator_type& __a)
+	  : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last,
+			   size_type __n, const hasher& __hf,
+			   const allocator_type& __a)
+	  : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n,
+			 const allocator_type& __a)
+	: unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multimap(__l, __n, __hf, key_equal(), __a)
+      { }
+
       ~unordered_multimap() = default;
 
       unordered_multimap&
diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set
index b52268b..1e68461 100644
--- a/libstdc++-v3/include/debug/unordered_set
+++ b/libstdc++-v3/include/debug/unordered_set
@@ -129,6 +129,41 @@  namespace __debug
 		    const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a) { }
 
+      unordered_set(size_type __n, const allocator_type& __a)
+	: unordered_set(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_set(size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_set(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const allocator_type& __a)
+	  : unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __first, _InputIterator __last,
+		      size_type __n, const hasher& __hf,
+		      const allocator_type& __a)
+	  : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n,
+		    const allocator_type& __a)
+	: unordered_set(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_set(__l, __n, __hf, key_equal(), __a)
+      { }
+
       ~unordered_set() = default;
 
       unordered_set&
@@ -546,6 +581,41 @@  namespace __debug
 			 const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a) { }
 
+      unordered_multiset(size_type __n, const allocator_type& __a)
+	: unordered_multiset(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multiset(size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multiset(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __first, _InputIterator __last,
+			   size_type __n,
+			   const allocator_type& __a)
+	  : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __first, _InputIterator __last,
+			   size_type __n, const hasher& __hf,
+			   const allocator_type& __a)
+	  : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n,
+			 const allocator_type& __a)
+	: unordered_multiset(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multiset(__l, __n, __hf, key_equal(), __a)
+      { }
+
       ~unordered_multiset() = default;
 
       unordered_multiset&
diff --git a/libstdc++-v3/include/profile/unordered_map b/libstdc++-v3/include/profile/unordered_map
index fdb4550..480faba 100644
--- a/libstdc++-v3/include/profile/unordered_map
+++ b/libstdc++-v3/include/profile/unordered_map
@@ -119,6 +119,41 @@  namespace __profile
 		    const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a) { }
 
+      unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const allocator_type& __a)
+	  : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_map(_InputIterator __first, _InputIterator __last,
+		      size_type __n, const hasher& __hf,
+		      const allocator_type& __a)
+	  : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n,
+		    const allocator_type& __a)
+	: unordered_map(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+		    size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_map(__l, __n, __hf, key_equal(), __a)
+      { }
+
       unordered_map&
       operator=(const unordered_map&) = default;
 
@@ -361,6 +396,41 @@  namespace __profile
 			 const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a) { }
 
+      unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last,
+			   size_type __n,
+			   const allocator_type& __a)
+	  : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_multimap(_InputIterator __first, _InputIterator __last,
+			   size_type __n, const hasher& __hf,
+			   const allocator_type& __a)
+	  : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n,
+			 const allocator_type& __a)
+	: unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+			 size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multimap(__l, __n, __hf, key_equal(), __a)
+      { }
+
       unordered_multimap&
       operator=(const unordered_multimap&) = default;
 
diff --git a/libstdc++-v3/include/profile/unordered_set b/libstdc++-v3/include/profile/unordered_set
index e1eb1a1..15950b9 100644
--- a/libstdc++-v3/include/profile/unordered_set
+++ b/libstdc++-v3/include/profile/unordered_set
@@ -125,6 +125,41 @@  namespace __profile
       : _Base(__l, __n, __hf, __eql, __a)
       { }
 
+      unordered_set(size_type __n, const allocator_type& __a)
+	: unordered_set(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_set(size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_set(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __first, _InputIterator __last,
+		      size_type __n,
+		      const allocator_type& __a)
+	  : unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_set(_InputIterator __first, _InputIterator __last,
+		      size_type __n, const hasher& __hf,
+		      const allocator_type& __a)
+	  : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n,
+		    const allocator_type& __a)
+	: unordered_set(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_set(initializer_list<value_type> __l,
+		    size_type __n, const hasher& __hf,
+		    const allocator_type& __a)
+	: unordered_set(__l, __n, __hf, key_equal(), __a)
+      { }
+
       unordered_set&
       operator=(const unordered_set&) = default;
 
@@ -346,6 +381,41 @@  namespace __profile
 	: _Base(__l, __n, __hf, __eql, __a)
       { }
 
+      unordered_multiset(size_type __n, const allocator_type& __a)
+	: unordered_multiset(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multiset(size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multiset(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __first, _InputIterator __last,
+			   size_type __n,
+			   const allocator_type& __a)
+	  : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
+	{ }
+
+      template<typename _InputIterator>
+	unordered_multiset(_InputIterator __first, _InputIterator __last,
+			   size_type __n, const hasher& __hf,
+			   const allocator_type& __a)
+	  : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
+	{ }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n,
+			 const allocator_type& __a)
+	: unordered_multiset(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multiset(initializer_list<value_type> __l,
+			 size_type __n, const hasher& __hf,
+			 const allocator_type& __a)
+	: unordered_multiset(__l, __n, __hf, key_equal(), __a)
+      { }
+
       unordered_multiset&
       operator=(const unordered_multiset&) = default;
 
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc
index 0d3e384..17efac55 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc
@@ -28,3 +28,7 @@  using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), 10, alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h5({ { 1, 1 } }, 10, alloc_type());
+test_type h6({ { 1, 1 } }, 10, hasher_type(), alloc_type());
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc
index c4d68ec..d99d352 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc
@@ -28,3 +28,7 @@  using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), 10, alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h5({ { 1, 1 } }, 10, alloc_type());
+test_type h6({ { 1, 1 } }, 10, hasher_type(), alloc_type());
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc
index 0680951..7ae17b7 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc
@@ -28,3 +28,7 @@  using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), 10, alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h5({ 1, 1 }, 10, alloc_type());
+test_type h6({ 1, 1 }, 10, hasher_type(), alloc_type());
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc
index 2ead0b1..73e223d 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc
@@ -28,3 +28,7 @@  using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), 10, alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h5({ 1, 1 }, 10, alloc_type());
+test_type h6({ 1, 1 }, 10, hasher_type(), alloc_type());