使用std :: enable_if的带有模板重载的隐式转换运算符T（）无法编译

Question

I am writing a class in C++17 which I would like overload conversion operator for floating types as well as for some custom types. Here is the reproducible example. There are many more conversions that I need to add with templates, but if I can resolve these, the rest should be similar.

class A {
};

class B : public A {
};

class C: public A {
};

class Missing {
 public:
  Missing() {}
  Missing(Missing &) = default;

  template<typename T,typename=typename std::enable_if_t<std::is_floating_point_v<T>, T>>
  explicit constexpr operator T() const {
    return static_cast<T>(NAN);
  }

  template<typename T, class = typename std::enable_if_t<std::is_base_of_v<A, T>, T>>
  explicit operator T() const {
    return T();
  }


};

However on compilation with gcc 8.2 with std=c++17 flag, I get the following error:

<source>:25:12: error: 'template<class T, class> Missing::operator T() const' cannot be overloaded with 'template<class T, class> constexpr Missing::operator T() const'

   explicit operator T() const {

            ^~~~~~~~

<source>:20:22: note: previous declaration 'template<class T, class> constexpr Missing::operator T() const'

   explicit constexpr operator T() const {

                      ^~~~~~~~

Compiler returned: 1

I would think that using enable_if would prevent the operators from overloading for the same type, but looks like the compiler isn't looking at the enable_if on the first pass. I am not sure if I have the right syntax. Any help would be appreciated. Been at this for some time now.

---

Update :

Tried updating the operators to

  template<typename T>
  constexpr explicit operator std::enable_if_t<std::is_floating_point_v<T>, T>() const {
    return static_cast<T>(NAN);
  }

  template<typename T>
  explicit operator std::enable_if_t<std::is_base_of_v<A, T>, T>() const {
    return T();
  }

But now, on trying to cast the class to float:

int main() {
    Missing m;
    float a = static_cast<float>(m);
}

I get an error:

<source>:34:35: error: invalid static_cast from type 'Missing' to type 'float'

     float a = static_cast<float>(m);

Answer 1

The problem is that you are declaring the same member template twice, with different default arguments. The error happens before any instantiation so the default arguments are not even looked at.

The first impulse to solve this would be moving enable_if_t out of the arguments and making it the return type of the operator:

template<typename T>
explicit constexpr operator std::enable_if_t<std::is_floating_point_v<T>, T>>() const ...

But this doesn't work because T is undeduced context now.

So the other way to make the two templates different is to add a dummy parameter with a defalut value to one of them.

template<typename T,
         typename = std::enable_if_t<std::is_floating_point_v<T>, T>,
         bool = true>
explicit constexpr operator T() const ...

The other template should be left as is.

With the two templates having different number of template parameters, they are no longer considered identical.

Answer 2

Another way is to define the deduced template argument to be a defaulted pointer:

template
<
  typename T, 
  std::enable_if_t<std::is_floating_point_v<T>>* = nullptr
>
explicit constexpr operator T() const {
  return static_cast<T>(NAN);
}

I find this to be a concise and reliable way to optionally enable methods, operators and constructors.