如何根据类型是整型还是浮点型更改模板方法？

Question

我正在研究一个矩阵类，它采用整数（short，int，long）和浮点类型（float，double）。我希望某些方法仅限于浮点类型（例如反转方法），而某些方法对于浮点类型和整数类型（例如==运算符）具有不同的实现。我有一种预感，正确的方法是使用boost的“enable_if”和“is_integral”/“is_floating_point”，但我似乎无法让它工作。

我的实现类似于此c半伪代码：

template <typename T>
class Matrix
{
    ...
    bool operator==(Matrix<typename enable_if<is_integral<T> T >::type >) const;
    bool operator==(Matrix<typename enable_if<is_floating_point<T>::type T> >) const;
    typename enable_if<is_floating_point<T> T> computeInverse() const;
    ...
};
// implementation
bool Matrix<T>::operator==(Matrix<typename enable_if<is_integral<T> T >::type >) const {
  //implementation without precision
}
bool Matrix<T>::operator==(Matrix<typename enable_if<is_integral<T> T >::type >) const {
  //implementation using precision
}
Matrix<typename enable_if<is_floating_point<T> T>::type > Matrix<T>::computeInverse() const {
  //implementation requiring floating points
}

这会产生很多编译错误，而我认为这些是最相关的错误：

error: no type named ‘type’ in ‘struct boost::enable_if<boost::is_integral<float>, float>’

和

error: no type named ‘type’ in ‘struct boost::enable_if<boost::is_floating_point<int>, int>’

这表明我不能为不同的类型使用不同的实现，至少不能使用boost的enable_if，这是否正确？

如果是这样，我该怎么做？我知道模板专门化是一种方法，但是我想避免重复太多的代码。

Answer 1

您应该尝试并遵循@DavidRodriguez的建议，将类的公共功能划分为基类；然后在功能不同的地方提供整个派生类的专门化。这将是更好的办法。

如果您确实希望保留当前实现，则可以按如下方式将不需要的运算符版本从重载解决方案中删除：

#include <iostream>
#include <type_traits>

template<class T>
struct Matrix
{
  // ...
};

template<class T>
typename std::enable_if<
    std::is_integral<T>::value, bool
  >::type
operator==( const Matrix<T>&, const Matrix<T>& )
{
  std::cout << "Integer version" << std::endl;
  return true;
}

template<class T>
typename std::enable_if<
    !std::is_integral<T>::value, bool
  >::type
operator==( const Matrix<T>&, const Matrix<T>& )
{
  std::cout << "Floating point version" << std::endl;
  return true;
}

int main()
{
  Matrix<int> m1, m2;
  Matrix<double> m3, m4;

  if( m1 == m2 ) {}

  if( m3 == m4 ) {}
}

如果您希望操作符作为成员函数，我所知道的使其工作的唯一方法是向操作符添加一个虚拟模板参数并添加

Answer 2

最简单的方法是在矩阵中使用重载函数：

template <typename T>
class Matrix
{
    template <bool isInteger> class Discrim;
    //  ...
    bool isEqual( Matrix const& other, Discrim<true> ) const
    {
        //  Integer implementation...
    }

    bool isEqual( Matrix const& other, Discrim<false> ) const
    {
        //  Floating point implementation...
    }

public:
    bool isEqual( Matrix const& other ) const
    {
        return isEqual( other, Discrim<std::numeric_limits<T>::is_integer>() );
    }
};

你的运算符==和运算符！=当然会调用Matrix::isEqual。

话虽如此：从您的评论来看，如果T是浮点类型，您需要一个“几乎相等”的函数。不要这样做。它只会让人感到困惑，并在今后的道路上造成无穷无尽的问题（因为==将不再是一个可传递的操作）。