2

Little-known feature of CTAD (class template argument deduction) in C++17: you can mark user-defined deduction guides as explicit. (Godbolt.)

template<class T> struct A { A(int); };           A(int) -> A<int>;
template<class T> struct B { B(int); };  explicit B(int) -> B<int>;

A<int> a = 1;  // OK, constructor of A<int> is implicit
B<int> b = 1;  // OK, constructor of B<int> is implicit

auto a = A(1);  // OK, deduction guide of A exists
auto b = B(1);  // OK, deduction guide of B exists

A a = 1;  // OK, deduction guide of A is non-explicit
B b = 1;  // ERROR!! deduction guide of B is explicit

So, class templates A and B have observably different behavior. I'd like to write a unit test that static_asserts that one of my templates behaves like B, not like A.

static_assert(!has_properly_explicit_deduction_guide_v<A>);
static_assert(has_properly_explicit_deduction_guide_v<B>);

Is this possible in C++17 and/or C++20 and/or "C++future"?

Quuxplusone
  • 23,928
  • 8
  • 94
  • 159
  • Well, I was exploring the potential for `new` (to save you time: it won't work) and found some more bugs: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101988 and https://bugs.llvm.org/show_bug.cgi?id=51547 . Fun! – ecatmur Aug 19 '21 at 21:43

2 Answers2

3

No.

You can't check declarations, so you can't check the validity of A a = 1; or B b = 1;

And class template argument deduction isn't valid in any other copy-initialization contexts. So while you can check "implicitly convertible" by seeing if the expression [](To){}(from) is valid, you cannot check "implicitly class-template-argument-deducible" by seeing if the expression [](A){}(1) is valid, since you cannot just write A there.

The only thing that you can check is whether A(1) is valid or not, but that is direct initialization, and so would not be able to validate explicitness.

Barry
  • 286,269
  • 29
  • 621
  • 977
  • 1
    Any additional thoughts on https://godbolt.org/z/P3bdvYh17 ? NTTPs are another context where CTAD is valid; but (1) this would work only for NTTP-friendly types, which obviously doesn't help in _general_, and (2) there seems to be implementation divergence here. – Quuxplusone Aug 12 '21 at 15:01
  • @Quuxplusone You can do that [much simpler](https://godbolt.org/z/G1Y9eMdT9). gcc allows explicit deduction guides in this context though. And yes, this isn't a general solution. – Barry Aug 12 '21 at 15:21
  • 2
    .. which is now [#101833](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101883). – Barry Aug 12 '21 at 15:29
0

Currently, per [dcl.type.class.deduct], a placeholder for a deduced class type can appear in:

  • the initializing declaration of a variable;
  • a new-expression;
  • explicit type conversion (functional notation); or
  • a non-type template parameter [NTTP].

The first of these is not SFINAE-able (either classically or in a requires clause), since it is a declaration and not an expression; the next two invoke direct-initialization, not copy-initialization; and the last only works for structural types with constexpr constructors (although this isn't particularly clear from the Standard).

wrt. future direction, back in 2018 Mike Spertus was angling for CTAD on function template arguments: Improving function templates with Class Template Argument Deduction, How to make Terse Notation soar with Class Template Argument Deduction. There hasn't been much movement on this since then, but perhaps it could be resurrected.

ecatmur
  • 152,476
  • 27
  • 293
  • 366