How to check if type is explicitly/implicitly constructible?

Question

How can it be checked that some type is explicitly (or vice versa implicitly) constructible from other type? Is it any SFINAE trick in this situation?

I can write is_explicitly_constructible as a combination of std::is_constructible and std::is_convertible:

#include <type_traits>

template <typename Type, typename Argument>
struct is_explicitly_constructible
    : std::bool_constant
        <
            std::is_constructible<Type, Argument>::value &&
            !std::is_convertible<Argument, Type>::value
        >
{
};

But do I take into account all possible cases in such code?

It seems to me that combining `declval` with `static_cast` should determine whether one type is convertible from another type. Combine that with a typical SFINAE test, and that should do the trick. — Sam Varshavchik, Mar 14 '17 at 13:03
@SamVarshavchik But I want to check if one type _constructible_ from another type, not _convertible_. And `static_cast` supports convertion of types that are not classes themselves. — Constructor, Mar 14 '17 at 13:32
@Barry And no pitfalls here? Like competing constructors or something else... — Constructor, Mar 14 '17 at 13:34
@Constructor `std::is_constructible` does the right thing. It doesn't check if literally the constructor `X(Y )` exists - just checks if a hypothetical `X x(y);` would be well-formed. — Barry, Mar 14 '17 at 13:35

score 13 · Accepted Answer · answered Mar 14 '17 at 13:51

Yes, this is correct. A type T is explicitly constructible from an argument A if

It is constructible at all from A. That is, a hypothetical T x(a) is valid.
Implicit conversions are ill-formed. That is, the hypothetical function T test() { return a; } would be ill-formed.

std::is_constructible tests #1, and std::is_convertible tests the validity of #2. Hence, wanting #1 and not #2 would be is_explicitly_constructible just as #1 and #2 would be is_implicitly_constructible.

Such an is_explicitly_constructible/is_implicitly_constructible pair is how you would implement a constructor being conditionally explicit. For instance, in libstdc++, these two constructors for optional exist:

implicit:

 template <typename _Up = _Tp,
            enable_if_t<__and_<
              __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
              is_constructible<_Tp, _Up&&>,   // (*) 
              is_convertible<_Up&&, _Tp>      // (*)
              >::value, bool> = true>
  constexpr optional(_Up&& __t)

explicit:

  template <typename _Up = _Tp,
            enable_if_t<__and_<
              __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
              is_constructible<_Tp, _Up&&>,        // (*)
              __not_<is_convertible<_Up&&, _Tp>>   // (*)
              >::value, bool> = false>
  explicit constexpr optional(_Up&& __t);

You can see that libstdc++ uses the same expressions that you do.

Thank you for such detailed answer! What about `is_explicitly_convertible`/`is_implicitly_convertible`? — Constructor, Mar 14 '17 at 15:19
`is_implictly_convertible == is_convertible && !is_explicitly_convertible`, `is_explicitly_convertible == ?` — Constructor, Mar 14 '17 at 17:46
There is no implicitly vs explicitly convertible. There is convertible, which implies implicit. — Barry, Mar 14 '17 at 17:49
Conversions using `static_cast` are explicit, but they involve some conversions, that can not be implicit. — Constructor, Mar 14 '17 at 18:41
@Constructor I guess what you're looking for is that `is_explicitly_convertible` is `std::is_constructible` and `is_implicitly_convertible` is `std::is_convertible`. — Barry, Mar 14 '17 at 18:52

How to check if type is explicitly/implicitly constructible?

1 Answers1

Linked