Why Does `enable_if_t` Fail in Function Definitions?

Clash of Template Arguments: Why enable_if_t Fails in Definitions

In template programming, it's not uncommon to encounter situations where we need to conditionally enable or disable template functions based on a specific condition. In such cases, the std::enable_if template is often used to achieve this. However, a recent attempt to employ the newer syntax of std::enable_if_t has led to unexpected errors.

In the code snippet below, we define two template functions f() using std::enable_if:

template<typename T,
         typename std::enable_if<std::is_same<int, T>::value>::type* = nullptr>
void f() { }

template<typename T,
         typename std::enable_if<std::is_same<double, T>::value>::type* = nullptr>
void f() { }

When porting this code to use the new std::enable_if_t syntax, we encounter an issue:

template<typename T,
         typename = std::enable_if_t<std::is_same<int, T>::value>>
void g() { }

template<typename T,
         typename = std::enable_if_t<std::is_same<double, T>::value>>
void g() { }

GCC complains with the following error:

error: redefinition of 'template<class T, class> void g()'
       void g() { }

To understand why this error occurs, we need to examine the syntax of template arguments. Removing unnecessary code, we have the following simplified representation of our functions:

template<
  class T,
  class U/* = std::enable_if_t<std::is_same<int, T>::value>*/
>
void g() { }

template<
  class T,
  class U/* = std::enable_if_t<std::is_same<double, T>::value>*/
>
void g() { }

It becomes clear that both templates are of the same type templatevoid(), regardless of their different default values for the second type argument. This conflicts with the C requirement that two template functions of the same template type need to have different signatures.

To solve this issue, we can change the second argument to a pointer type with a dependent type:

template<
  class T,
  std::enable_if_t<std::is_same<int, T>::value, int>* = nullptr
>
void f() { }

template<
  class T,
  std::enable_if_t<std::is_same<double, T>::value, int>* = nullptr
>
void f() { }

In this modified code, the signature of the template functions is now unique, eliminating the conflict and allowing the correct template matching.

The above is the detailed content of Why Does `enable_if_t` Fail in Function Definitions?. For more information, please follow other related articles on the PHP Chinese website!