Make no argument constructor implicit

doc/changes.qbk

@@ -294,5 +294,6 @@ C++11 support has resulted in some breaking changes:
   wrong bucket and equivalent elements would be incorrectly handled.
 * Various reference documentation improvements.
 * Better allocator support ([ticket 12459]).
+* Make the no argument constructors implicit.
 
 [endsect]

doc/ref.php

@@ -189,10 +189,22 @@ EOL;
               <para>A const_local_iterator object can be used to iterate through a single bucket.</para>
             </description>
           </typedef>
+          <constructor>
+            <postconditions>
+              <code><methodname>size</methodname>() == 0</code>
+            </postconditions>
+            <description>
+              <para>Constructs an empty container using hasher() as the hash function, key_equal() as the key equality predicate, allocator_type() as the allocator and a maximum load factor of 1.0.</para>
+            </description>
+            <requires>
+              <para>If the defaults are used, <code>hasher</code>, <code>key_equal</code> and
+                <code>allocator_type</code> need to be <code>DefaultConstructible</code>.
+              </para>
+            </requires>
+          </constructor>
           <constructor specifiers="explicit">
             <parameter name="n">
               <paramtype>size_type</paramtype>
-              <default><emphasis>implementation-defined</emphasis></default>
             </parameter>
             <parameter name="hf">
               <paramtype>hasher const&amp;</paramtype>

doc/ref.xml

@@ -130,10 +130,22 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <para>A const_local_iterator object can be used to iterate through a single bucket.</para>
             </description>
           </typedef>
+          <constructor>
+            <postconditions>
+              <code><methodname>size</methodname>() == 0</code>
+            </postconditions>
+            <description>
+              <para>Constructs an empty container using hasher() as the hash function, key_equal() as the key equality predicate, allocator_type() as the allocator and a maximum load factor of 1.0.</para>
+            </description>
+            <requires>
+              <para>If the defaults are used, <code>hasher</code>, <code>key_equal</code> and
+                <code>allocator_type</code> need to be <code>DefaultConstructible</code>.
+              </para>
+            </requires>
+          </constructor>
           <constructor specifiers="explicit">
             <parameter name="n">
               <paramtype>size_type</paramtype>
-              <default><emphasis>implementation-defined</emphasis></default>
             </parameter>
             <parameter name="hf">
               <paramtype>hasher const&amp;</paramtype>
@@ -1204,10 +1216,22 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <para>A const_local_iterator object can be used to iterate through a single bucket.</para>
             </description>
           </typedef>
+          <constructor>
+            <postconditions>
+              <code><methodname>size</methodname>() == 0</code>
+            </postconditions>
+            <description>
+              <para>Constructs an empty container using hasher() as the hash function, key_equal() as the key equality predicate, allocator_type() as the allocator and a maximum load factor of 1.0.</para>
+            </description>
+            <requires>
+              <para>If the defaults are used, <code>hasher</code>, <code>key_equal</code> and
+                <code>allocator_type</code> need to be <code>DefaultConstructible</code>.
+              </para>
+            </requires>
+          </constructor>
           <constructor specifiers="explicit">
             <parameter name="n">
               <paramtype>size_type</paramtype>
-              <default><emphasis>implementation-defined</emphasis></default>
             </parameter>
             <parameter name="hf">
               <paramtype>hasher const&amp;</paramtype>
@@ -2287,10 +2311,22 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <para>A const_local_iterator object can be used to iterate through a single bucket.</para>
             </description>
           </typedef>
+          <constructor>
+            <postconditions>
+              <code><methodname>size</methodname>() == 0</code>
+            </postconditions>
+            <description>
+              <para>Constructs an empty container using hasher() as the hash function, key_equal() as the key equality predicate, allocator_type() as the allocator and a maximum load factor of 1.0.</para>
+            </description>
+            <requires>
+              <para>If the defaults are used, <code>hasher</code>, <code>key_equal</code> and
+                <code>allocator_type</code> need to be <code>DefaultConstructible</code>.
+              </para>
+            </requires>
+          </constructor>
           <constructor specifiers="explicit">
             <parameter name="n">
               <paramtype>size_type</paramtype>
-              <default><emphasis>implementation-defined</emphasis></default>
             </parameter>
             <parameter name="hf">
               <paramtype>hasher const&amp;</paramtype>
@@ -3408,10 +3444,22 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <para>A const_local_iterator object can be used to iterate through a single bucket.</para>
             </description>
           </typedef>
+          <constructor>
+            <postconditions>
+              <code><methodname>size</methodname>() == 0</code>
+            </postconditions>
+            <description>
+              <para>Constructs an empty container using hasher() as the hash function, key_equal() as the key equality predicate, allocator_type() as the allocator and a maximum load factor of 1.0.</para>
+            </description>
+            <requires>
+              <para>If the defaults are used, <code>hasher</code>, <code>key_equal</code> and
+                <code>allocator_type</code> need to be <code>DefaultConstructible</code>.
+              </para>
+            </requires>
+          </constructor>
           <constructor specifiers="explicit">
             <parameter name="n">
               <paramtype>size_type</paramtype>
-              <default><emphasis>implementation-defined</emphasis></default>
             </parameter>
             <parameter name="hf">
               <paramtype>hasher const&amp;</paramtype>

include/boost/unordered/unordered_map.hpp

@@ -82,8 +82,10 @@ namespace unordered
 
         // constructors
 
+        unordered_map();
+
         explicit unordered_map(
-                size_type = boost::unordered::detail::default_bucket_count,
+                size_type,
                 const hasher& = hasher(),
                 const key_equal& = key_equal(),
                 const allocator_type& = allocator_type());
@@ -565,8 +567,9 @@ namespace unordered
 
         // constructors
 
+        unordered_multimap();
         explicit unordered_multimap(
-                size_type = boost::unordered::detail::default_bucket_count,
+                size_type,
                 const hasher& = hasher(),
                 const key_equal& = key_equal(),
                 const allocator_type& = allocator_type());
@@ -1002,6 +1005,13 @@ namespace unordered
 
 ////////////////////////////////////////////////////////////////////////////////
 
+    template <class K, class T, class H, class P, class A>
+    unordered_map<K,T,H,P,A>::unordered_map()
+      : table_(boost::unordered::detail::default_bucket_count, hasher(),
+            key_equal(), allocator_type())
+    {
+    }
+
     template <class K, class T, class H, class P, class A>
     unordered_map<K,T,H,P,A>::unordered_map(
             size_type n, const hasher &hf, const key_equal &eql,
@@ -1335,6 +1345,13 @@ namespace unordered
 
 ////////////////////////////////////////////////////////////////////////////////
 
+    template <class K, class T, class H, class P, class A>
+    unordered_multimap<K,T,H,P,A>::unordered_multimap()
+      : table_(boost::unordered::detail::default_bucket_count, hasher(),
+            key_equal(), allocator_type())
+    {
+    }
+
     template <class K, class T, class H, class P, class A>
     unordered_multimap<K,T,H,P,A>::unordered_multimap(
             size_type n, const hasher &hf, const key_equal &eql,

include/boost/unordered/unordered_set.hpp

@@ -79,8 +79,9 @@ namespace unordered
 
         // constructors
 
+        unordered_set();
         explicit unordered_set(
-                size_type = boost::unordered::detail::default_bucket_count,
+                size_type,
                 const hasher& = hasher(),
                 const key_equal& = key_equal(),
                 const allocator_type& = allocator_type());
@@ -548,8 +549,9 @@ namespace unordered
 
         // constructors
 
+        unordered_multiset();
         explicit unordered_multiset(
-                size_type = boost::unordered::detail::default_bucket_count,
+                size_type,
                 const hasher& = hasher(),
                 const key_equal& = key_equal(),
                 const allocator_type& = allocator_type());
@@ -976,6 +978,13 @@ namespace unordered
 
 ////////////////////////////////////////////////////////////////////////////////
 
+    template <class T, class H, class P, class A>
+    unordered_set<T,H,P,A>::unordered_set()
+      : table_(boost::unordered::detail::default_bucket_count, hasher(),
+            key_equal(), allocator_type())
+    {
+    }
+
     template <class T, class H, class P, class A>
     unordered_set<T,H,P,A>::unordered_set(
             size_type n, const hasher &hf, const key_equal &eql,
@@ -1260,6 +1269,13 @@ namespace unordered
 
 ////////////////////////////////////////////////////////////////////////////////
 
+    template <class T, class H, class P, class A>
+    unordered_multiset<T,H,P,A>::unordered_multiset()
+      : table_(boost::unordered::detail::default_bucket_count, hasher(),
+            key_equal(), allocator_type())
+    {
+    }
+
     template <class T, class H, class P, class A>
     unordered_multiset<T,H,P,A>::unordered_multiset(
             size_type n, const hasher &hf, const key_equal &eql,

test/unordered/compile_tests.hpp

@@ -101,7 +101,18 @@ void container_test(X& r, T const&)
         static_cast<comparison_type>(
             (std::numeric_limits<difference_type>::max)()));
 
+    // Constructors
+
     // I don't test the runtime post-conditions here.
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+    // It isn't specified in the container requirements that the no argument
+    // constructor is implicit, but it is defined that way in the concrete
+    // container specification.
+    X u_implicit = {};
+    sink(u_implicit);
+#endif
+
     X u;
     BOOST_TEST(u.size() == 0);
     BOOST_TEST(X().size() == 0);