35

我正在构建一些需要具有整数和/或双精度函数的输入检查器（例如，'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();
   }   
};

但如果我将它用作模板参数（如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()’

我无法弄清楚第二个版本有什么问题。

4

3 回答 3

40

默认模板参数不是模板签名的一部分（因此两个定义都尝试定义相同的模板两次）。但是，它们的参数类型是签名的一部分。所以你可以做

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();
   }
};
于 2012-06-15T18:32:28.190 回答
10

问题是编译器看到相同方法的 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 实例化。

于 2012-06-15T18:18:55.403 回答
3

我知道这个问题是关于的std::enable_if，但是，我想提供一个替代解决方案来解决相同的问题，而无需 enable_if。它确实需要 C++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它作为返回类型。

于 2018-08-02T18:12:24.153 回答