Std:: enable_if: параметр vs template

Я создаю несколько проверок ввода, которые должны иметь определенные функции для integer и/или double (например, 'isPrime' должен быть доступен только для целых чисел.

Если я использую enable_if в качестве параметра, он отлично работает:

template <class T>
class check
{
public:
   template< class U = T>
   inline static U readVal(typename std::enable_if<std::is_same<U, int>::value >::type* = 0)
   {
      return BuffCheck.getInt();
   }

   template< class U = T>
   inline static U readVal(typename std::enable_if<std::is_same<U, double>::value >::type* = 0)
   {
      return BuffCheck.getDouble();
   }   
};

но если я использую его как шаблон paramater (как показано на http://en.cppreference.com/w/cpp/types/enable_if)

template <class T>
class check
{
public:
   template< class U = T, class = typename std::enable_if<std::is_same<U, int>::value>::type >
   inline static U readVal()
   {
      return BuffCheck.getInt();
   }

   template< class U = T, class = typename std::enable_if<std::is_same<U, double>::value>::type >
   inline static U readVal()
   {
      return BuffCheck.getDouble();
   }
};

то я имею следующую ошибку:

error: ‘template<class T> template<class U, class> static U check::readVal()’ cannot be overloaded
error: with ‘template<class T> template<class U, class> static U check::readVal()’

Я не могу понять, что не так во второй версии.

Ответы

Ответ 1

Аргументы шаблона по умолчанию не являются частью сигнатуры шаблона (поэтому оба определения пытаются дважды определить один и тот же шаблон). Однако их типы параметров являются частью подписи. Таким образом, вы можете сделать

template <class T>
class check
{
public:
   template< class U = T, 
             typename std::enable_if<std::is_same<U, int>::value, int>::type = 0>
   inline static U readVal()
   {
      return BuffCheck.getInt();
   }

   template< class U = T, 
             typename std::enable_if<std::is_same<U, double>::value, int>::type = 0>
   inline static U readVal()
   {
      return BuffCheck.getDouble();
   }
};

Ответ 2

Проблема заключается в том, что компилятор видит 2 перегрузки одного и того же метода, оба из которых содержат одни и те же аргументы (в данном случае - нет) и одинаковое возвращаемое значение. Вы не можете предоставить такое определение. Самый чистый способ сделать это - использовать SFINAE для возвращаемого значения функции:

template <class T>
class check
{
public:
   template< class U = T>
   static typename std::enable_if<std::is_same<U, int>::value, U>::type readVal()
   {
      return BuffCheck.getInt();
   }

   template< class U = T>
   static typename std::enable_if<std::is_same<U, double>::value, U>::type readVal()
   {
      return BuffCheck.getDouble();
   }
};

Таким образом, вы предоставляете 2 разных перегрузки. Один возвращает int, другой возвращает double, и только один может быть создан с использованием определенного T.

Ответ 3

Я знаю, что этот вопрос о std::enable_if, однако я хотел бы предложить альтернативное решение для решения той же проблемы без enable_if. Это требует С++ 17

template <class T>
class check
{
public:
   inline static T readVal()
   {
        if constexpr (std::is_same_v<T, int>)
             return BuffCheck.getInt();
        else if constexpr (std::is_same_v<T, double>)
             return BuffCheck.getDouble();
   }   
};

Этот код выглядит так, как если бы вы написали его во время выполнения. Все ветки должны быть синтаксически правильными, однако семантика не должна быть. В этом случае, если T - int, getDouble не вызывает ошибок компиляции (или предупреждений), так как он не проверяется/не используется компилятором.

Если возвращаемый тип функции будет слишком сложным, вы всегда можете использовать auto в качестве возвращаемого типа.