[libc++] [P0935] [C++20] Eradicating unnecessarily explicit default constructors from the standard library.

[curdeius]

Summary

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0935r0.html

[curdeius]

libcxx/include/random

101–103

Please disregard modifications to stuff other than linear_congruential_engine.

[curdeius]

• Clean up. Test default seed.

[ldionne]

This is the same as D60422, which hasn't been updated in a while. I left some comments regarding how I suggest we create shared code to check for implicit default constructibility in that review. But I like the make_implicit<E>() trick.

@zoecarver I think you two should coordinate.

[curdeius]

• Implement: [rand.device] [rand.eng] [rand.dist.uni.int] [rand.dist.uni.real]

[curdeius]

@ldionne, 've discussed it with @zoecarver, and we decided that I'll take it over. It might take some time as there are many things to change (and test), but I'll appreciate your feedback.

My doubts:

• is using make_implicit really necessary or just test_convertible is enough? Using make_implicit tests as well that the default parameter is the correct one. It's not always possible (as in random_device for instance).
• name and location of make_implicit?
• I added as well test for ctors being explicit, and that was not tested before.

[curdeius]

One more question, lots of stuff in <random> tests are also run in c++03. Is it expected? Should I add guards to my additions (#if TEST_STD_VER >= 11)?

[curdeius]

• Use typedef for C++03 compatibility.
• [rand.dist.bern]
• [rand.dist.pois]
• [rand.dist.norm]
• [stringbuf]
• [istringstream]
• [stringbuf]
• [ostringstream]
• [stringstream]
• [re.results]
• [depr.strstreambuf]
• [depr.conversions.string]
• [depr.conversions.buffer]
• [queue] [priority.queue]
• [stack]

[curdeius]

• Fix [rand] in C++03 mode.

[ldionne]

In D91292#2424853, @curdeius wrote:

@ldionne, 've discussed it with @zoecarver, and we decided that I'll take it over. It might take some time as there are many things to change (and test), but I'll appreciate your feedback.

My doubts:

• is using make_implicit really necessary or just test_convertible is enough? Using make_implicit tests as well that the default parameter is the correct one. It's not always possible (as in random_device for instance).

I think we should test the value of the default argument when we can, as you did.

• name and location of make_implicit?

What you have looks OK to me.

• I added as well test for ctors being explicit, and that was not tested before.

Thank you!

In D91292#2425285, @curdeius wrote:

One more question, lots of stuff in <random> tests are also run in c++03. Is it expected? Should I add guards to my additions (#if TEST_STD_VER >= 11)?

We support <random> in C++03. It's one of those great things :-).

libcxx/test/support/make_implicit.h

25 ↗

(On Diff #308646)

C++11 is required only because you're using a brace initializer, right? Clang supports variadics and rvalue references even in C++03 mode, so I'm just checking.

[curdeius]

libcxx/test/support/make_implicit.h

25 ↗

(On Diff #308646)

Brace initializer, rvalue references and variadics, also std::forward but that could be just a static_cast. I can make it work for C++03 then.

[curdeius]

• Update status page.
• Generalize tests. Clean up.
• Remove requirement for > C++11 in make_implicit.h.

[curdeius]

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

[curdeius]

• Fix status page.

[ldionne]

In D91292#2427945, @curdeius wrote:

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

It was adopted as a paper, and it does *not* appear to have been voted as a DR. I found on the Rapperswill (2018) wiki motion page:

Motion 25
Move to apply to the C++ working paper the proposed wording in P0935R0 (Eradicating unnecessarily explicit default constructors from the standard library).

It doesn't appear to be applied as a DR, however the author himself was the one to change cppreference (looking at the history). @tcanens Do you have more context?

[tcanens]

In D91292#2440215, @ldionne wrote:

In D91292#2427945, @curdeius wrote:

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

It was adopted as a paper, and it does *not* appear to have been voted as a DR. I found on the Rapperswill (2018) wiki motion page:

Motion 25
Move to apply to the C++ working paper the proposed wording in P0935R0 (Eradicating unnecessarily explicit default constructors from the standard library).

It doesn't appear to be applied as a DR, however the author himself was the one to change cppreference (looking at the history). @tcanens Do you have more context?

LWG doesn't do official DRs like ever, so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

Both libstdc++ and MSVC implement P0935 unconditionally, so I suspect that I guessed correctly for this case.

[ldionne]

In D91292#2440252, @tcanens wrote:

LWG doesn't do official DRs like ever,

I'm not sure I follow. Aren't all LWG issues considered DRs and "back applied" to earlier standards, hence what we do in the libraries wrt LWG issues?

so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

I think it's misleading to call it a DR if it isn't one. I believe it would be more correct (and equally useful) to say that most implementations support it back in C++11, without using the word DR. It's a bit pedantic, but I think nothing is lost by being more precise.

Both libstdc++ and MSVC implement P0935 unconditionally, so I suspect that I guessed correctly for this case.

@curdeius In that case, I believe we should support it unconditionally as well. At worst, it's a very very small extension in older standards. That'll also simplify the implementation and the tests a bit.

[tcanens]

In D91292#2440351, @ldionne wrote:

In D91292#2440252, @tcanens wrote:

LWG doesn't do official DRs like ever,

I'm not sure I follow. Aren't all LWG issues considered DRs and "back applied" to earlier standards, hence what we do in the libraries wrt LWG issues?

LWG doesn't move issue resolutions as formal DRs the way CWG does. And not all issues are DRs - see, e.g., LWG2911 aka is_aggregate. I think the "file an issue if you want a paper back applied" process (as in LWG3494) is a fairly new invention.

so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

I think it's misleading to call it a DR if it isn't one. I believe it would be more correct (and equally useful) to say that most implementations support it back in C++11, without using the word DR. It's a bit pedantic, but I think nothing is lost by being more precise.

I think that adds unnecessary confusion and complexity, not to mention that ISO rules say that DRs only apply to the immediately previous standard so we still have similar problems with stuff that goes back farther than that. But I don't think this is the right place to discuss cppreference policy.

[ldionne]

In D91292#2440443, @tcanens wrote:

I think that adds unnecessary confusion and complexity, not to mention that ISO rules say that DRs only apply to the immediately previous standard so we still have similar problems with stuff that goes back farther than that. But I don't think this is the right place to discuss cppreference policy.

Indeed, I was just giving my opinion :-). cppreference is a great tool nonetheless.

@curdeius Let's implement this back to C++11 if that's OK by you. That way, we'll remove implementation divergence and simplify our life, and we'll also make cppreference tell the truth. 😁

[curdeius]

OK. No problem. That will be a nice cleanup indeed.

[curdeius]

• Apply to pre-C++20. That requires tho that the compiler supports delegated constructors in C++03 (it seems that clang does).

[curdeius]

• Revert for C++03 (no delegating constructors).

[curdeius]

• Fix C++03.

[curdeius]

Friendly ping.

[ldionne]

I didn't look again in detail, but I remember I was OK with the patch except for the question of whether to implement it as a DR. This has been settled now, so this LGTM. Thanks!

[curdeius]

Rebase to trigger CI to reverify.

libcxx/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);
+    explicit linear_congruential_engine(result_type s = default_seed);         // before C++20
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
+    explicit linear_congruential_engine(result_type s);                        // C++20
     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();
+    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();
+    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();
+    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();
+    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();
+    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();
+    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) {}
+    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);
+    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) {}
+    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) {}
+    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) {}
+    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) {}
+    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:
     static _LIBCPP_CONSTEXPR const result_type modulus = __m;
     _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
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit linear_congruential_engine(result_type __s)
+        {seed(__s);}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit linear_congruential_engine(result_type __s = default_seed)
         {seed(__s);}
+#endif
+
     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)
         {seed(integral_constant<bool, __m == 0>(),

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
-// explicit linear_congruential_engine(result_type s = default_seed);
+// explicit linear_congruential_engine(result_type s = default_seed);         // before C++20
+// linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
+// explicit linear_congruential_engine(result_type s);                        // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
+
 #include "test_macros.h"
 
 template <class T>
+std::string
+to_string(T const &e)
+{
+    std::ostringstream os;
+    os << e;
+    return os.str();
+}
+
+template <class T>
 void
 test1()
 {
     // c % m != 0 && s % m != 0
     {
         typedef std::linear_congruential_engine<T, 2, 3, 7> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 0> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 4> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
 }
 
 template <class T>
 void
 test2()
 {
     // c % m != 0 && s % m == 0
     {
         typedef std::linear_congruential_engine<T, 2, 3, 7> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 0> E;
         E e(0);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 4> E;
         E e(4);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
 }
 
 template <class T>
 void
 test3()
 {
     // c % m == 0 && s % m != 0
     {
         typedef std::linear_congruential_engine<T, 2, 0, 7> E;
         E e(3);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "3");
+        assert(to_string(e) == "3");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 0> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 4> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "3");
+        assert(to_string(e) == "3");
     }
 }
 
 template <class T>
 void
 test4()
 {
     // c % m == 0 && s % m == 0
     {
         typedef std::linear_congruential_engine<T, 2, 0, 7> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 0> E;
         E e(0);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 4> E;
         E e(8);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
 }
 
+#if TEST_STD_VER > 17
+template <class T, class... Args>
+T
+make_implicit(Args &&... args)
+{
+    return {forward<Args>(args)...};
+}
+
+template <class T>
+void
+test5()
+{
+    typedef std::linear_congruential_engine<T, 2, 0, 7> E;
+    auto e_default = make_implicit<E>();
+    auto e_1 = E(1);
+    assert(to_string(e_default) == to_string(e_1));
+    assert(to_string(e_default) == "1");
+}
+#endif
+
 int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
     test1<unsigned long>();
     test1<unsigned long long>();
 
     test2<unsigned short>();
     test2<unsigned int>();
     test2<unsigned long>();
     test2<unsigned long long>();
 
     test3<unsigned short>();
     test3<unsigned int>();
     test3<unsigned long>();
     test3<unsigned long long>();
 
     test4<unsigned short>();
     test4<unsigned int>();
     test4<unsigned long>();
     test4<unsigned long long>();
 
+#if TEST_STD_VER > 17
+    test5<unsigned short>();
+    test5<unsigned int>();
+    test5<unsigned long>();
+    test5<unsigned long long>();
+#endif
+
   return 0;
 }