Remove default parameters (P0935R0)

[zoecarver]

Summary

Implement changes specified in P0935R0.

There were a few constructors in the queue header which did not look right, so I updated them using my best judgment.

Edit: also, I used _LIBCPP_INLINE_VISIBILITY where it looked like other's were using it. What is the rule of thumb for _LIBCPP_INLINE_VISIBILITY?

Edit 2: I didn't write any tests for this patch because I thought it wasn't needed (and because that would take a lot of time :P), but if you think it would be a good idea I can test for constructors blocking copy-list-initialization (or other things if necessary).

[zoecarver]

Small fixes after running tests

[ldionne]

Also, I used _LIBCPP_INLINE_VISIBILITY where it looked like other's were using it. What is the rule of thumb for _LIBCPP_INLINE_VISIBILITY?

Use it for functions that you don't want to be part of the ABI. In this case, every default constructor that simply forwards to another constructor should be marked with _LIBCPP_INLINE_VISIBILITY.

include/queue

42

We normally don't show the definition of functions in the synopsis. Also notice that this default constructor already appears above.

[zoecarver]

include/queue

42

Your right, guess I didn't see that. I will get rid of the added constructor. For the below constructors, would it be helpful to keep them in the synopsis because they show what the default value is?

[zoecarver]

Use it for functions that you don't want to be part of the ABI. In this case, every default constructor that simply forwards to another constructor should be marked with _LIBCPP_INLINE_VISIBILITY.

Great, thanks for the explanation. I will update the rest of the (forwarding) constructors to use _LIBCPP_INLINE_VISIBILITY.

[ldionne]

include/queue

42

I think it's OK to keep the definition for the other constructors since they're one-liners, yes.

[zoecarver]

Fix synopsis and update www.

[EricWF]

Every line of this change should be covered by a test

include/queue

452

copy paste error? we are copy constructing the comparator

lib/CMakeLists.txt

202 ↗

(On Diff #194428)

bad diff?

[zoecarver]

Sounds good. I will work on tests for these on a plane ride I have Sunday.

include/queue

452

Yes, my bad. I should get rid of this and keep line 470-472.

lib/CMakeLists.txt

202 ↗

(On Diff #194428)

Yep, forgot to pull from master first. Sorry.

[EricWF]

Every line of this change should be covered by a test.

For each type, we need at least one new test that checks that the default constructor can be called implicitly.
( You can use test/support/test_convertible.hpp for this)

And if we don't have an existing test that the other constructors are explicit, we should add one.

The tests should be added alongside the existing tests for the constructors. Let me know if you need help finding them.

[zoecarver]

• "starter" test
• fix diff

[zoecarver]

include/queue

229

I didn't see this in the standard, but I can keep it.

test/std/containers/container.adaptors/queue/queue.defn/default_constructor.pass.cpp

1

Before I spend a lot of time writing tests for this, I want to check that I am writing the correct tests. I am going to use this test as a "template" for other tests. @EricWF how does this look?

[ldionne]

It's been a while, but I'll review this if you update it with my comments.

test/std/containers/container.adaptors/queue/queue.defn/default_constructor.pass.cpp

1

IIUC, you're just trying to test that the type is implicitly default constructible. You could add a support header that contains generic tests for that, like test_implicitly_default_constructible<T>(), and then you'd simply use test_implicitly_default_constructible<std::queue<T>>(), etc.

[zoecarver]

It's been a while, but I'll review this if you update it with my comments.

Sounds good to me. I might not have time to work on this patch until this weekend or next week, though.

test/std/containers/container.adaptors/queue/queue.defn/default_constructor.pass.cpp

1

I like that idea a lot. I'll do that.

[zoecarver]

Abandoning in favor of D91292.

include/algorithm

public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
-    explicit uniform_int_distribution(result_type __a = 0,
+    uniform_int_distribution() : uniform_int_distribution(0) {}
+
+    explicit uniform_int_distribution(result_type __a,
                                       result_type __b = numeric_limits<result_type>::max())
         : __p_(param_type(__a, __b)) {}
     explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
     void reset() {}
 
     // generating functions
     template<class _URNG> result_type operator()(_URNG& __g)
         {return (*this)(__g, __p_);}

include/locale

 class wstring_convert
 {
 public:
     typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
     typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
     typedef typename Codecvt::state_type                      state_type;
     typedef typename wide_string::traits_type::int_type       int_type;
 
-    explicit wstring_convert(Codecvt* pcvt = new Codecvt);          // explicit in C++14
+    wstring_convert() : wstring_convert(new Codecvt) {}
+    explicit wstring_convert(Codecvt* pcvt);          // explicit in C++14
     wstring_convert(Codecvt* pcvt, state_type state);
     explicit wstring_convert(const byte_string& byte_err,           // explicit in C++14
                     const wide_string& wide_err = wide_string());
     wstring_convert(const wstring_convert&) = delete;               // C++14
     wstring_convert & operator=(const wstring_convert &) = delete;  // C++14
     ~wstring_convert();
 
     wide_string from_bytes(char byte);

 
 template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
 class wbuffer_convert
     : public basic_streambuf<Elem, Tr>
 {
 public:
     typedef typename Tr::state_type state_type;
 
-    explicit wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
+    wbuffer_convert() : wbuffer_convert(nullptr) {}
+    explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt,
                     state_type state = state_type());       // explicit in C++14
     wbuffer_convert(const wbuffer_convert&) = delete;               // C++14
     wbuffer_convert & operator=(const wbuffer_convert &) = delete;  // C++14
     ~wbuffer_convert();                                             // C++14
-    
     streambuf* rdbuf() const;
     streambuf* rdbuf(streambuf* bytebuf);
 
     state_type state() const;
 };
 
 // 22.4.1 and 22.4.1.3, ctype:
 class ctype_base;
private:
     wide_string __wide_err_string_;
     _Codecvt* __cvtptr_;
     state_type __cvtstate_;
     size_t __cvtcount_;
 
     wstring_convert(const wstring_convert& __wc);
     wstring_convert& operator=(const wstring_convert& __wc);
 public:
+    _LIBCPP_INLINE_VISIBILITY wstring_convert() : wstring_convert(new _Codecvt) {}
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
+    _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt);
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert(_Codecvt* __pcvt, state_type __state);
     _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
                     const wide_string& __wide_err = wide_string());
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert(wstring_convert&& __wc);
 #endif
private:
     ios_base::openmode __cm_;
     bool __owns_eb_;
     bool __owns_ib_;
     bool __always_noconv_;
 
     wbuffer_convert(const wbuffer_convert&);
     wbuffer_convert& operator=(const wbuffer_convert&);
 public:
-    _LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf = 0, 
+    _LIBCPP_INLINE_VISIBILITY wbuffer_convert() : wbuffer_convert(nullptr) {}
+    _LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf,
             _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
     ~wbuffer_convert();
 
     _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf() const {return __bufptr_;}
     _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf(streambuf* __bytebuf)
     {
if (this->gptr() == this->egptr())
             {
                 __extbufend_ = __extbufnext_ + __nr;
                 char_type*  __inext;
                 __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
                                        this->eback() + __unget_sz,
                                        this->egptr(), __inext);
                 if (__r == codecvt_base::noconv)
                 {
-                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, 
+                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_,
                                (char_type*) const_cast<char *>(__extbufend_));
                     __c = *this->gptr();
                 }
                 else if (__inext != this->eback() + __unget_sz)
                 {
                     this->setg(this->eback(), this->eback() + __unget_sz, __inext);
                     __c = *this->gptr();
                 }

include/queue

public:
     ~queue() = default;
 
     queue(const queue& q) = default;
     queue(queue&& q) = default;
 
     queue& operator=(const queue& q) = default;
     queue& operator=(queue&& q) = default;
 
     explicit queue(const container_type& c);
     explicit queue(container_type&& c)
     template <class Alloc>
         explicit queue(const Alloc& a);
     template <class Alloc>
         queue(const container_type& c, const Alloc& a);
     template <class Alloc>
         queue(container_type&& c, const Alloc& a);
     template <class Alloc>
public:
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
     void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
 };
 
 template<class Container>
   queue(Container) -> queue<typename Container::value_type, Container>; // C++17
-  
-template<class Container, class Allocator> 
+template<class Container, class Allocator>
   queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
 
 template <class T, class Container>
   bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
 
 template <class T, class Container>
   bool operator< (const queue<T, Container>& x,const queue<T, Container>& y);
 

 protected:
     container_type c;
     Compare comp;
 
 public:
     priority_queue() = default;
     ~priority_queue() = default;
 
+    explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
+
     priority_queue(const priority_queue& q) = default;
     priority_queue(priority_queue&& q) = default;
 
     priority_queue& operator=(const priority_queue& q) = default;
     priority_queue& operator=(priority_queue&& q) = default;
 
     explicit priority_queue(const Compare& comp);
     priority_queue(const Compare& comp, const container_type& c);
public:
     void swap(priority_queue& q)
         noexcept(is_nothrow_swappable_v<Container> &&
                  is_nothrow_swappable_v<Comp>)
 };
 
 template <class Compare, class Container>
 priority_queue(Compare, Container)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
-  
-template<class InputIterator, 
+template<class InputIterator,
          class Compare = less<typename iterator_traits<InputIterator>::value_type>,
          class Container = vector<typename iterator_traits<InputIterator>::value_type>>
 priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
     -> priority_queue<typename iterator_traits<InputIterator>::value_type, Container, Compare>; // C++17
-  
 template<class Compare, class Container, class Allocator>
 priority_queue(Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
 
 template <class T, class Container, class Compare>
   void swap(priority_queue<T, Container, Compare>& x,
             priority_queue<T, Container, Compare>& y)
             noexcept(noexcept(x.swap(y)));
public:
     typedef typename container_type::size_type       size_type;
     static_assert((is_same<_Tp, value_type>::value), "" );
 
 protected:
     container_type c;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
+    queue() : queue(_Container()) {}
 
     _LIBCPP_INLINE_VISIBILITY
     queue(const queue& __q) : c(__q.c) {}
 
     _LIBCPP_INLINE_VISIBILITY
     queue& operator=(const queue& __q) {c = __q.c; return *this;}
 
 #ifndef _LIBCPP_CXX03_LANG

 };
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _Container,
          class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
 >
 queue(_Container)
     -> queue<typename _Container::value_type, _Container>;
-  
 template<class _Container,
          class _Alloc,
          class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,
          class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type
 >
 queue(_Container, _Alloc)
     -> queue<typename _Container::value_type, _Container>;
 #endif
protected:
     container_type c;
     value_compare comp;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     priority_queue()
         _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
                    is_nothrow_default_constructible<value_compare>::value)
-        : c(), comp() {}
+        : priority_queue(_Compare()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit priority_queue(const _Compare& __x)
+        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
+                   is_nothrow_default_constructible<value_compare>::value)
+        : priority_queue(__x, _Container()) {}
 
     _LIBCPP_INLINE_VISIBILITY
     priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}
 
     _LIBCPP_INLINE_VISIBILITY
     priority_queue& operator=(const priority_queue& __q)
         {c = __q.c; comp = __q.comp; return *this;}
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     priority_queue(priority_queue&& __q)
         _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
                    is_nothrow_move_constructible<value_compare>::value)
         : c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}
 
     _LIBCPP_INLINE_VISIBILITY
     priority_queue& operator=(priority_queue&& __q)
         _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
                    is_nothrow_move_assignable<value_compare>::value)
         {c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
 #endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit priority_queue(const value_compare& __comp)
-        : c(), comp(__comp) {}
-    _LIBCPP_INLINE_VISIBILITY
     priority_queue(const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit priority_queue(const value_compare& __comp, container_type&& __c);
+    priority_queue(const value_compare& __comp, container_type&& __c);
 #endif
     template <class _InputIter>
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp = value_compare());
     template <class _InputIter>
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,

 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template <class _Compare,
           class _Container,
           class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
           class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
 >
 priority_queue(_Compare, _Container)
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;
-  
-template<class _InputIterator, 
+template<class _InputIterator,
          class _Compare   = less<typename iterator_traits<_InputIterator>::value_type>,
          class _Container = vector<typename iterator_traits<_InputIterator>::value_type>,
          class = typename enable_if< __is_input_iterator<_InputIterator>::value, nullptr_t>::type,
          class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
          class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
 >
 priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(), _Container = _Container())
     -> priority_queue<typename iterator_traits<_InputIterator>::value_type, _Container, _Compare>;
-  
-template<class _Compare, 
+template<class _Compare,
          class _Container,
          class _Alloc,
          class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
          class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,
          class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type
 >
 priority_queue(_Compare, _Container, _Alloc)
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;

include/random

public:
     static constexpr result_type multiplier = a;
     static constexpr result_type increment = c;
     static constexpr result_type modulus = m;
     static constexpr result_type min() { return c == 0u ? 1u: 0u;}
     static constexpr result_type max() { return m - 1u;}
     static constexpr result_type default_seed = 1u;
 
     // constructors and seeding functions
-    explicit linear_congruential_engine(result_type s = default_seed);
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+    explicit linear_congruential_engine(result_type s);
     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     void seed(result_type s = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     static constexpr result_type tempering_c = c;
     static constexpr size_t tempering_l = l;
     static constexpr result_type initialization_multiplier = f;
     static constexpr result_type min () { return 0; }
     static constexpr result_type max() { return 2^w - 1; }
     static constexpr result_type default_seed = 5489u;
 
     // constructors and seeding functions
-    explicit mersenne_twister_engine(result_type value = default_seed);
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+    explicit mersenne_twister_engine(result_type value);
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     static constexpr size_t word_size = w;
     static constexpr size_t short_lag = s;
     static constexpr size_t long_lag = r;
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m-1; }
     static constexpr result_type default_seed = 19780503u;
 
     // constructors and seeding functions
-    explicit subtract_with_carry_engine(result_type value = default_seed);
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+    explicit subtract_with_carry_engine(result_type value);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     // types
     typedef unsigned int result_type;
 
     // generator characteristics
     static constexpr result_type min() { return numeric_limits<result_type>::min(); }
     static constexpr result_type max() { return numeric_limits<result_type>::max(); }
 
     // constructors
-    explicit random_device(const string& token = "/dev/urandom");
+    random_device() : random_device("/dev/urandom") {}
+    explicit random_device(const string& token);
 
     // generating functions
     result_type operator()();
 
     // property functions
     double entropy() const noexcept;
 
     // no copy functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit uniform_int_distribution(IntType a = 0,
+    uniform_int_distribution() : uniform_int_distribution(0) {}
+    explicit uniform_int_distribution(IntType a,
                                     IntType b = numeric_limits<IntType>::max());
     explicit uniform_int_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
+    uniform_real_distribution() : uniform_real_distribution(0.0) {}
+    explicit uniform_real_distribution(RealType a, RealType b = 1.0);
     explicit uniform_real_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit bernoulli_distribution(double p = 0.5);
+    bernoulli_distribution() : bernoulli_distribution(0.5) {}
+    explicit bernoulli_distribution(double p);
     explicit bernoulli_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         IntType t() const;
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit binomial_distribution(IntType t = 1, double p = 0.5);
+    binomial_distribution() : binomial_distribution(1) {}
+    explicit binomial_distribution(IntType t, double p = 0.5);
     explicit binomial_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit geometric_distribution(double p = 0.5);
+    geometric_distribution() : geometric_distribution(0.5) {}
+    explicit geometric_distribution(double p);
     explicit geometric_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type k() const;
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
+    negative_binomial_distribution() : negative_binomial_distribution(1) {}
+    explicit negative_binomial_distribution(result_type k, double p = 0.5);
     explicit negative_binomial_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         double mean() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit poisson_distribution(double mean = 1.0);
+    poisson_distribution() : poisson_distribution(1.0) {}
+    explicit poisson_distribution(double mean);
     explicit poisson_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         result_type lambda() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit exponential_distribution(result_type lambda = 1.0);
+    exponential_distribution() : exponential_distribution(1.0) {}
+    explicit exponential_distribution(result_type lambda);
     explicit exponential_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type alpha() const;
         result_type beta() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
+    gamma_distribution() : gamma_distribution(1.0) {}
+    explicit gamma_distribution(result_type alpha, result_type beta = 1);
     explicit gamma_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit weibull_distribution(result_type a = 1, result_type b = 1);
+    weibull_distribution() : weibull_distribution(1.0) {}
+    explicit weibull_distribution(result_type a, result_type b = 1);
     explicit weibull_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
+    extreme_value_distribution() : extreme_value_distribution(0.0) {}
+    explicit extreme_value_distribution(result_type a, result_type b = 1);
     explicit extreme_value_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type mean() const;
         result_type stddev() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
+    normal_distribution() : normal_distribution(0.0) {}
+    explicit normal_distribution(result_type mean, result_type stddev = 1);
     explicit normal_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type m() const;
         result_type s() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit lognormal_distribution(result_type m = 0, result_type s = 1);
+    lognormal_distribution() : lognormal_distribution(0.0) {}
+    explicit lognormal_distribution(result_type m, result_type s = 1);
     explicit lognormal_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         result_type n() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit chi_squared_distribution(result_type n = 1);
+    chi_squared_distribution() : chi_squared_distribution(1) {}
+    explicit chi_squared_distribution(result_type n);
     explicit chi_squared_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit cauchy_distribution(result_type a = 0, result_type b = 1);
+    cauchy_distribution() : cauchy_distribution(0.0) {}
+    explicit cauchy_distribution(result_type a, result_type b = 1);
     explicit cauchy_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type m() const;
         result_type n() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
+    fisher_f_distribution() : fisher_f_distribution(1) {}
+    explicit fisher_f_distribution(result_type m, result_type n = 1);
     explicit fisher_f_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         result_type n() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit student_t_distribution(result_type n = 1);
+    student_t_distribution() : student_t_distribution(1) {}
+    explicit student_t_distribution(result_type n);
     explicit student_t_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
     static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
 
     // constructors and seeding functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s = default_seed)
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit linear_congruential_engine(result_type __s)
         {seed(__s);}
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit linear_congruential_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __s = default_seed)
public:
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
     static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
 
     // constructors and seeding functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd = default_seed)
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit mersenne_twister_engine(result_type __sd)
         {seed(__sd);}
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit mersenne_twister_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
         {seed(__q);}
     void seed(result_type __sd = default_seed);
     template<class _Sseq>
template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t 
+    _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
 
public:
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
     static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
 
     // constructors and seeding functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd = default_seed)
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit subtract_with_carry_engine(result_type __sd)
         {seed(__sd);}
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit subtract_with_carry_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd = default_seed)
public:
     static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
 
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
 
     // constructors
-    explicit random_device(const string& __token = "/dev/urandom");
+    random_device() : random_device("/dev/urandom") {}
+
+    explicit random_device(const string& __token);
     ~random_device();
 
     // generating functions
     result_type operator()();
 
     // property functions
     double entropy() const _NOEXCEPT;
 
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
+    uniform_real_distribution() : uniform_real_distribution(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit uniform_real_distribution(result_type __a, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(double __p = 0.5)
+    bernoulli_distribution() : bernoulli_distribution(0.5) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit bernoulli_distribution(double __p)
         : __p_(param_type(__p)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
+    binomial_distribution() : binomial_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit binomial_distribution(result_type __t, double __p = 0.5)
         : __p_(param_type(__t, __p)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             bool operator!=(const param_type& __x, const param_type& __y)
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
+    _LIBCPP_INLINE_VISIBILITY
+    exponential_distribution() : exponential_distribution(1) {}
+
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(result_type __lambda = 1)
+    explicit exponential_distribution(result_type __lambda)
         : __p_(param_type(__lambda)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>

 private:
     param_type __p_;
     result_type _V_;
     bool _V_hot_;
 
 public:
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
+    normal_distribution() : normal_distribution(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit normal_distribution(result_type __mean, result_type __stddev = 1)
         : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit normal_distribution(const param_type& __p)
         : __p_(__p), _V_hot_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {_V_hot_ = false;}
 
     // generating functions
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(result_type __m = 0, result_type __s = 1)
+    lognormal_distribution() : lognormal_distribution(0.0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit lognormal_distribution(result_type __m, result_type __s = 1)
         : __p_(param_type(__m, __s)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit lognormal_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {__p_.__nd_.reset();}
 
     // generating functions
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
+    poisson_distribution() : poisson_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit poisson_distribution(double __mean) : __p_(__mean) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
+    weibull_distribution() : weibull_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit weibull_distribution(result_type __a, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit weibull_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
+    extreme_value_distribution() : extreme_value_distribution(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit extreme_value_distribution(result_type __a, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit extreme_value_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
public:
             bool operator!=(const param_type& __x, const param_type& __y)
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
+    _LIBCPP_INLINE_VISIBILITY
+    gamma_distribution() :gamma_distribution(1) {}
+
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
+    explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
         : __p_(param_type(__alpha, __beta)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit gamma_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
+    negative_binomial_distribution() : negative_binomial_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
         : __p_(__k, __p) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             bool operator!=(const param_type& __x, const param_type& __y)
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
+    _LIBCPP_INLINE_VISIBILITY
+    geometric_distribution() : geometric_distribution(0.5) {}
+
     // constructors and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
+    explicit geometric_distribution(double __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(result_type __n = 1)
+    chi_squared_distribution() : chi_squared_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit chi_squared_distribution(result_type __n)
         : __p_(param_type(__n)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit chi_squared_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
+    cauchy_distribution() : cauchy_distribution(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit cauchy_distribution(result_type __a, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit cauchy_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
public:
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
+    fisher_f_distribution() : fisher_f_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit fisher_f_distribution(result_type __m, result_type __n = 1)
         : __p_(param_type(__m, __n)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit fisher_f_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions

 
 private:
     param_type __p_;
     normal_distribution<result_type> __nd_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(result_type __n = 1)
+    student_t_distribution() : student_t_distribution(1) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit student_t_distribution(result_type __n)
         : __p_(param_type(__n)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit student_t_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {__nd_.reset();}
 
     // generating functions

 #ifndef _LIBCPP_CXX03_LANG
         template<class _UnaryOperation>
             param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
 #endif  // _LIBCPP_CXX03_LANG
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
         param_type & operator=(const param_type& __rhs);
-        
         _LIBCPP_INLINE_VISIBILITY
         vector<result_type> intervals() const {return __b_;}
         _LIBCPP_INLINE_VISIBILITY
         vector<result_type> densities() const {return __densities_;}
 
         friend _LIBCPP_INLINE_VISIBILITY
             bool operator==(const param_type& __x, const param_type& __y)
             {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}

include/regex

public:
     typedef const_iterator                                    iterator;
     typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
     typedef typename allocator_traits<Allocator>::size_type   size_type;
     typedef Allocator                                         allocator_type;
     typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
     typedef basic_string<char_type>                           string_type;
 
     // construct/copy/destroy:
-    explicit match_results(const Allocator& a = Allocator());
+    match_results() : match_results(Allocator()) {}
+    explicit match_results(const Allocator& a);
     match_results(const match_results& m);
     match_results(match_results&& m) noexcept;
     match_results& operator=(const match_results& m);
     match_results& operator=(match_results&& m);
     ~match_results();
 
     bool ready() const;
 
public:
     typedef forward_iterator_tag                 iterator_category;
 
     regex_iterator();
     regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                    const regex_type& re,
                    regex_constants::match_flag_type m = regex_constants::match_default);
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type&& __re,
-                   regex_constants::match_flag_type __m 
+                   regex_constants::match_flag_type __m
                                      = regex_constants::match_default) = delete; // C++14
     regex_iterator(const regex_iterator&);
     regex_iterator& operator=(const regex_iterator&);
 
     bool operator==(const regex_iterator&) const;
     bool operator!=(const regex_iterator&) const;
 
     const value_type& operator*() const;
basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
                                               _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
-            { 
+            {
                 int __val = __traits_.value(*__temp, 10);
                 if (__val >= 1 && __val <= 9)
                 {
                     __push_back_ref(__val);
                     __first = ++__temp;
                 }
             }
         }
basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
                                                 int& __c)
 {
     if (__first != __last )
     {
         int __val = __traits_.value(*__first, 10);
         if ( __val != -1 )
         {
             __c = __val;
-            for (++__first; 
+            for (++__first;
                  __first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
                  ++__first)
             {
                 if (__c >= std::numeric_limits<int>::max() / 10)
                     __throw_regex_error<regex_constants::error_badbrace>();
                 __c *= 10;
                 __c += __val;
             }
if (__first != __last)
                 *__str = _CharT(0xB);
             else
                 __push_char(_CharT(0xB));
             ++__first;
             break;
         case 'c':
             if ((__t = _VSTD::next(__first)) != __last)
             {
-                if (('A' <= *__t && *__t <= 'Z') || 
+                if (('A' <= *__t && *__t <= 'Z') ||
                     ('a' <= *__t && *__t <= 'z'))
                 {
                     if (__str)
                         *__str = _CharT(*__t % 32);
                     else
                         __push_char(_CharT(*__t % 32));
                     __first = ++__t;
                 }
-                else 
+                else
                     __throw_regex_error<regex_constants::error_escape>();
             }
             else
                 __throw_regex_error<regex_constants::error_escape>();
             break;
         case 'u':
             ++__first;
             if (__first == __last)
public:
     typedef typename __container_type::const_iterator         const_iterator;
     typedef const_iterator                                    iterator;
     typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
     typedef typename allocator_traits<allocator_type>::size_type size_type;
     typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
     typedef basic_string<char_type>                           string_type;
 
     // construct/copy/destroy:
-    explicit match_results(const allocator_type& __a = allocator_type());
+    match_results() : match_results(allocator_type()) {}
+    explicit match_results(const allocator_type& __a);
 //    match_results(const match_results&) = default;
 //    match_results& operator=(const match_results&) = default;
 //    match_results(match_results&& __m) = default;
 //    match_results& operator=(match_results&& __m) = default;
 //    ~match_results() = default;
 
     _LIBCPP_INLINE_VISIBILITY
     bool ready() const {return __ready_;}

 bool
 basic_regex<_CharT, _Traits>::__search(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags) const
 {
     __m.__init(1 + mark_count(), __first, __last,
                                     __flags & regex_constants::__no_update_pos);
-    if (__match_at_start(__first, __last, __m, __flags, 
+    if (__match_at_start(__first, __last, __m, __flags,
                                     !(__flags & regex_constants::__no_update_pos)))
     {
         __m.__prefix_.second = __m[0].first;
         __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
         __m.__suffix_.first = __m[0].second;
         __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
         return true;
     }

 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
 bool
 regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
              match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
              const basic_regex<_Cp, _Tp>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; 
+             regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
 #endif
 
 // regex_match
 
 template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
 bool
 regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
             match_results<_BidirectionalIterator, _Allocator>& __m,

 
 #if _LIBCPP_STD_VER > 11
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
             match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; 
+            regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
 #endif
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
public:
     regex_iterator();
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type& __re,
                    regex_constants::match_flag_type __m
                                               = regex_constants::match_default);
 #if _LIBCPP_STD_VER > 11
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type&& __re,
-                   regex_constants::match_flag_type __m 
+                   regex_constants::match_flag_type __m
                                      = regex_constants::match_default) = delete;
 #endif
 
     bool operator==(const regex_iterator& __x) const;
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
 
     _LIBCPP_INLINE_VISIBILITY

 
 private:
     void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
     void __establish_result () {
         if (__subs_[__n_] == -1)
             __result_ = &__position_->prefix();
         else
             __result_ = &(*__position_)[__subs_[__n_]];
-        }       
+        }
 };
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator()
     : __result_(nullptr),
       __suffix_(),
       __n_(0)

include/sstream

public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // 27.8.1.1 Constructors:
-    explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out);
+    basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
+    explicit basic_stringbuf(ios_base::openmode which);
     explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& str,
                              ios_base::openmode which = ios_base::in | ios_base::out);
     basic_stringbuf(basic_stringbuf&& rhs);
 
     // 27.8.1.2 Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
     void swap(basic_stringbuf& rhs);
 
public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // 27.8.2.1 Constructors:
-    explicit basic_istringstream(ios_base::openmode which = ios_base::in);
+    basic_istringstream() : basic_istringstream(ios_base::in) {}
+    explicit basic_istringstream(ios_base::openmode which);
     explicit basic_istringstream(const basic_string<char_type, traits_type,allocator_type>& str,
                                  ios_base::openmode which = ios_base::in);
     basic_istringstream(basic_istringstream&& rhs);
 
     // 27.8.2.2 Assign and swap:
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
 
public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // 27.8.3.1 Constructors/destructor:
-    explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
+    basic_ostringstream() : basic_ostringstream(ios_base::out) {}
+    explicit basic_ostringstream(ios_base::openmode which);
     explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& str,
                                  ios_base::openmode which = ios_base::out);
     basic_ostringstream(basic_ostringstream&& rhs);
 
     // 27.8.3.2 Assign/swap:
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
 
public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // constructors/destructor
-    explicit basic_stringstream(ios_base::openmode which = ios_base::out|ios_base::in);
+    basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}
+    explicit basic_stringstream(ios_base::openmode which);
     explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& str,
                                 ios_base::openmode which = ios_base::out|ios_base::in);
     basic_stringstream(basic_stringstream&& rhs);
 
     // 27.8.5.1 Assign/swap:
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
 

 private:
 
     string_type __str_;
     mutable char_type* __hm_;
     ios_base::openmode __mode_;
 
 public:
     // 27.8.1.1 Constructors:
+    _LIBCPP_INLINE_VISIBILITY
+    basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
     inline _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in | ios_base::out);
+    explicit basic_stringbuf(ios_base::openmode __wch);
     inline _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringbuf(const string_type& __s,
                              ios_base::openmode __wch = ios_base::in | ios_base::out);
 #ifndef _LIBCPP_CXX03_LANG
     basic_stringbuf(basic_stringbuf&& __rhs);
 
     // 27.8.1.2 Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& __rhs);
public:
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
     // 27.8.2.1 Constructors:
+    inline _LIBCPP_INLINE_VISIBILITY basic_istringstream() : basic_istringstream(ios_base::in) {}
     inline _LIBCPP_INLINE_VISIBILITY
-    explicit basic_istringstream(ios_base::openmode __wch = ios_base::in);
+    explicit basic_istringstream(ios_base::openmode __wch);
     inline _LIBCPP_INLINE_VISIBILITY
     explicit basic_istringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::in);
 #ifndef _LIBCPP_CXX03_LANG
     inline _LIBCPP_INLINE_VISIBILITY
     basic_istringstream(basic_istringstream&& __rhs);
 
     // 27.8.2.2 Assign and swap:
public:
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
     // 27.8.2.1 Constructors:
     inline _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ostringstream(ios_base::openmode __wch = ios_base::out);
+    basic_ostringstream() : basic_ostringstream(ios_base::out) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    explicit basic_ostringstream(ios_base::openmode __wch);
     inline _LIBCPP_INLINE_VISIBILITY
     explicit basic_ostringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::out);
 #ifndef _LIBCPP_CXX03_LANG
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostringstream(basic_ostringstream&& __rhs);
 
     // 27.8.2.2 Assign and swap:
public:
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
     // 27.8.2.1 Constructors:
     inline _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringstream(ios_base::openmode __wch = ios_base::in | ios_base::out);
+    basic_stringstream() : basic_stringstream(ios_base::in | ios_base::out) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    explicit basic_stringstream(ios_base::openmode __wch);
     inline _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringstream(const string_type& __s,
                                 ios_base::openmode __wch = ios_base::in | ios_base::out);
 #ifndef _LIBCPP_CXX03_LANG
     inline _LIBCPP_INLINE_VISIBILITY
     basic_stringstream(basic_stringstream&& __rhs);
 
     // 27.8.2.2 Assign and swap:

include/stack

public:
     ~stack() = default;
 
     stack(const stack& q) = default;
     stack(stack&& q) = default;
 
     stack& operator=(const stack& q) = default;
     stack& operator=(stack&& q) = default;
 
+    stack() : stack(Container()) {}
     explicit stack(const container_type& c);
     explicit stack(container_type&& c);
     template <class Alloc> explicit stack(const Alloc& a);
     template <class Alloc> stack(const container_type& c, const Alloc& a);
     template <class Alloc> stack(container_type&& c, const Alloc& a);
     template <class Alloc> stack(const stack& c, const Alloc& a);
     template <class Alloc> stack(stack&& c, const Alloc& a);
 
     bool empty() const;
     size_type size() const;
     reference top();
     const_reference top() const;
 
     void push(const value_type& x);
     void push(value_type&& x);
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
     void swap(stack& c) noexcept(is_nothrow_swappable_v<Container>)
 };
 
 template<class Container>
   stack(Container) -> stack<typename Container::value_type, Container>;  // C++17
-  
-template<class Container, class Allocator> 
+template<class Container, class Allocator>
   stack(Container, Allocator) -> stack<typename Container::value_type, Container>; // C++17
 
 template <class T, class Container>
   bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);

 {
 public:
     typedef _Container                               container_type;
     typedef typename container_type::value_type      value_type;
     typedef typename container_type::reference       reference;
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
     static_assert((is_same<_Tp, value_type>::value), "" );
-    
 protected:
     container_type c;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     stack()
         _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
+        : stack(_Container()) {}
 
     _LIBCPP_INLINE_VISIBILITY
     stack(const stack& __q) : c(__q.c) {}
 
     _LIBCPP_INLINE_VISIBILITY
     stack& operator=(const stack& __q) {c = __q.c; return *this;}
 
 

 };
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _Container,
          class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
 >
 stack(_Container)
     -> stack<typename _Container::value_type, _Container>;
-  
 template<class _Container,
          class _Alloc,
          class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,
          class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type
-         > 
+         >
 stack(_Container, _Alloc)
     -> stack<typename _Container::value_type, _Container>;
 #endif
 
 template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)

include/string

 template <class _Iter>
 struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {};
 #elif defined(_LIBCPP_HAS_NO_NOEXCEPT)
 template <class _Iter>
 struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {};
 #else
 template <class _Iter, bool = __is_forward_iterator<_Iter>::value>
 struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT((
-    noexcept(++(declval<_Iter&>())) && 
-    is_nothrow_assignable<_Iter&, _Iter>::value && 
-    noexcept(declval<_Iter>() == declval<_Iter>()) && 
+    noexcept(++(declval<_Iter&>())) &&
+    is_nothrow_assignable<_Iter&, _Iter>::value &&
+    noexcept(declval<_Iter>() == declval<_Iter>()) &&
     noexcept(*declval<_Iter>())
 )) {};
 
-template <class _Iter> 
+template <class _Iter>
 struct __libcpp_string_gets_noexcept_iterator_impl<_Iter, false> : public false_type {};
 #endif
 
 
 template <class _Iter>
 struct __libcpp_string_gets_noexcept_iterator
     : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value || __libcpp_string_gets_noexcept_iterator_impl<_Iter>::value) {};
 
#if _LIBCPP_STD_VER > 17
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool ends_with(const value_type* __s) const _NOEXCEPT
     { return ends_with(__self_view(__s)); }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
-    
     _LIBCPP_INLINE_VISIBILITY
     bool __is_long() const _NOEXCEPT
         {return bool(__r_.first().__s.__size_ & __short_mask);}
 
 #if _LIBCPP_DEBUG_LEVEL >= 2
 
     bool __dereferenceable(const const_iterator* __i) const;
     bool __decrementable(const const_iterator* __i) const;
template<class _CharT,
          class _Allocator = allocator<_CharT>,
          class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,
          class _Sz = typename allocator_traits<_Allocator>::size_type
          >
 basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
   -> basic_string<_CharT, _Traits, _Allocator>;
 #endif
 
-                  
 template <class _CharT, class _Traits, class _Allocator>
 inline
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__invalidate_all(this);
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(
     {
         typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
         _CharRef __tmp_ref = *__first;
         if (__ptr_in_range(_VSTD::addressof(__tmp_ref), data(), data() + size()))
         {
             const basic_string __temp (__first, __last, __alloc());
             append(__temp.data(), __temp.size());
         }
-        else 
+        else
         {
             if (__cap - __sz < __n)
                 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
             pointer __p = __get_pointer() + __sz;
             for (; __first != __last; ++__p, ++__first)
                 traits_type::assign(*__p, *__first);
             traits_type::assign(*__p, value_type());
             __set_size(__sz + __n);
if (data()[size()] != value_type(0))
         return false;
     return true;
 }
 
 // __clear_and_shrink
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
-void 
+void
 basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
 {
     clear();
     if(__is_long())
     {
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
         __set_long_cap(0);
         __set_short_size(0);
     }
-} 
+}
 
 // operator==
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
     return this->data() <= __p && __p < this->data() + this->size();
 }
 
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<char>)
 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<wchar_t>)
 
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
 // Literal suffixes for basic_string [basic.string.literals]
 inline namespace literals
 {
   inline namespace string_literals
   {
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char> operator "" s( const char *__str, size_t __len )
     {

include/strstream

 
 /*
     strstream synopsis
 
 class strstreambuf
     : public basic_streambuf<char>
 {
 public:
-    explicit strstreambuf(streamsize alsize_arg = 0);
+    strstreambuf() : strstreambuf(0) {}
+    explicit strstreambuf(streamsize alsize_arg);
     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
     strstreambuf(const char* gnext_arg, streamsize n);
 
     strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
     strstreambuf(const signed char* gnext_arg, streamsize n);
     strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
     strstreambuf(const unsigned char* gnext_arg, streamsize n);

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS strstreambuf
     : public streambuf
 {
 public:
-    explicit strstreambuf(streamsize __alsize = 0);
+    strstreambuf() : strstreambuf(0) {}
+    explicit strstreambuf(streamsize __alsize);
     strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
     strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
     strstreambuf(const char* __gnext, streamsize __n);
 
     strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
     strstreambuf(const signed char* __gnext, streamsize __n);
     strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
     strstreambuf(const unsigned char* __gnext, streamsize __n);

test/std/containers/container.adaptors/queue/queue.defn/default_constructor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// queue() : queue(Container())
+
+#include <queue>
+#include <string>
+
+#include "test_convertible.hpp"
+#include "MoveOnly.h"
+
+template<class T>
+struct queue_id
+{
+    int i;
+    std::queue<T> q { };
+};
+
+template<class T>
+void test_queue()
+{
+    std::queue<T> q;
+    queue_id<T> q1 { 42 };
+    assert(q1.q == q);
+
+    static_assert(test_convertible<std::queue<T>>());
+    static_assert(test_convertible<queue_id<T>, int>());
+}
+
+int main(int, char**)
+{
+    test_queue<int>();
+    test_queue<MoveOnly>();
+    test_queue<std::string>();
+
+    return 0;
+}
 No newline at end of file

www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P0758R1">P0758R1</a></td><td>LWG</td><td>Implicit conversion traits and utility functions</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0759R1">P0759R1</a></td><td>LWG</td><td>fpos Requirements</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0769R2">P0769R2</a></td><td>LWG</td><td>Add shift to &lt;algorithm&gt;</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0788R3">P0788R3</a></td><td>LWG</td><td>Standard Library Specification in a Concepts and Contracts World</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0879R0">P0879R0</a></td><td>LWG</td><td>Constexpr for swap and swap related functions Also resolves LWG issue 2800.</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0887R1">P0887R1</a></td><td>LWG</td><td>The identity metafunction</td><td>Rapperswil</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0892R2">P0892R2</a></td><td>CWG</td><td>explicit(bool)</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0898R3">P0898R3</a></td><td>LWG</td><td>Standard Library Concepts</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0935R0">P0935R0</a></td><td>LWG</td><td>Eradicating unnecessarily explicit default constructors from the standard library</td><td>Rapperswil</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0935R0">P0935R0</a></td><td>LWG</td><td>Eradicating unnecessarily explicit default constructors from the standard library</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0941R2">P0941R2</a></td><td>CWG</td><td>Integrating feature-test macros into the C++ WD</td><td>Rapperswil</td><td><i>In progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1023R0">P1023R0</a></td><td>LWG</td><td>constexpr comparison operators for std::array</td><td>Rapperswil</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1025R1">P1025R1</a></td><td>CWG</td><td>Update The Reference To The Unicode Standard</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1120R0">P1120R0</a></td><td>CWG</td><td>Consistency improvements for &lt;=&gt; and other comparison operators</td><td>Rapperswil</td><td></td><td></td></tr>
 
    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0318R1">P0318R1</a></td><td>LWG</td><td>unwrap_ref_decay and unwrap_reference</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0356R5">P0356R5</a></td><td>LWG</td><td>Simplified partial function application</td><td>San Diego</td><td><i> </i></td><td></td></tr>