Question

我有以下模板类：

template<int size, typename Type>
class Matrix {
    public:
        Matrix();
        ...
        Type operator ()(int row, int column) {...}
    private:
        std::array<Type, size*size> _array;
}

我想重载equal to比较运算符来比较Matrix个对象：

template <int size, typename LeftType, typename RightType>
bool operator ==(const Matrix<size, LeftType> & left, const Matrix<size, RightType> & right) {
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            ...
        }
    }
}

问题是整数类型和实际类型的比较是完全不同的：

real case：

template <int size, typename LeftType, typename RightType>
bool operator ==(const Matrix<size, LeftType> & left, const Matrix<size, RightType> & right) {
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            if (qFuzzyIsNull(left(i, j)) || qFuzzyIsNull(right(i, j))) {
                if (!qFuzzyCompare(left(i, j) + 1, right(i, j) + 1)) {
                    return false;
                }
            } else {
                if (!qFuzzyCompare(left(i, j), right(i, j))) {
                    return false;
                }
            }
        }
    }
    return true;
}

（我使用Qt＆＃39; qFuzzyCompare和qFuzzyIsNull）

integer case：

template <int size, typename LeftType, typename RightType>
bool operator ==(const Matrix<size, LeftType> & left, const Matrix<size, RightType> & right) {
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            if (left(i, j) != right(i, j)) {
                return false;
            }
        }
    }
    return true;
}

如果integer case和LeftType整数同时启用RightType，如果至少有一个real case或LeftType是真的，则启用RightType？

Answer 1

这个怎么样：

template <int size, typename LeftType, typename RightType>
bool operator ==(const Matrix<size, LeftType> & left, const    Matrix<size,    RightType> & right) {
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            if (not is_equal(left(i,j), right(i,j)) {
                return false;
            }
        }
    }
    return true;
}

然后你要么定义几个is_equal的重载变体，要么将is_equal定义为模板并定义它的特化，比如

template<class T> 
bool is_equal(const T a, const T b);

template<>
bool is_equal<int>(const int a, const int b){
    return a == b;
}

template<>
bool is_equal<real>(const real a, const real b){
    ...
}

（如果可能发生，则作为两种类型的模板）

当然，您可以专门操作运算符本身，但这意味着您必须重新编写相同的代码，而不会重复使用它。同时，is_equal可能成为您程序中的一些常用工具。

（注意：is_equal是一个有点基本的名称，所以它应该在命名空间中，显然）

模板比较运算符

1 个答案: