0

我正在写一个矩阵模板类。一切都很顺利，直到我重载了乘法运算符。我的班级看起来像这样：

template <typename TNum> class Matrix
{
private:
    // ...
    TNum* Data;
public:
    const TMatIdx NRows; // Type TMatIdx defined somewhere else.
    const TMatIdx NCols;
    const TMatIdx Size;

    // ...
    // Matrix * matrix
    template <typename T2>
    const Matrix<TNum> operator*(const Matrix<T2>& right) const;

    // Matrix * number
    template <typename T2>
    Matrix<TNum>& operator*=(const T2& scale);
};

// Matrix * number
template <typename TNum, typename T2>
Matrix<TNum> operator*(Matrix<TNum> lhs, const T2& rhs);
// Number * matrix
template <typename TNum, typename T2>
Matrix<TNum> operator*(const T2& lhs, Matrix<TNum> rhs);

我希望使用相同的*运算符涵盖矩阵和数字之间所有可能的乘法组合。

然后我写了一个将两个 s 相乘的小测试程序Matrix<double>，我的 clang++ 编译器抱怨歧义：

test.cpp:46: error: ambiguous overload for 'operator*' in 'M * N'
matrix.h:225: note: candidates are: const QCD::Matrix<TNum> QCD::Matrix<TNum>::operator*(const QCD::Matrix<T2>&) const [with T2 = double, TNum = double]
matrix.h:118: note:                 QCD::Matrix<TNum> QCD::operator*(const T2&, QCD::Matrix<TNum>) [with TNum = double, T2 = QCD::Matrix<double>]
matrix.h:109: note:                 QCD::Matrix<TNum> QCD::operator*(QCD::Matrix<TNum>, const T2&) [with TNum = double, T2 = QCD::Matrix<double>]
test.cpp:52: error: ambiguous overload for 'operator*' in 'M * N'
matrix.h:225: note: candidates are: const QCD::Matrix<TNum> QCD::Matrix<TNum>::operator*(const QCD::Matrix<T2>&) const [with T2 = double, TNum = double]
matrix.h:118: note:                 QCD::Matrix<TNum> QCD::operator*(const T2&, QCD::Matrix<TNum>) [with TNum = double, T2 = QCD::Matrix<double>]
matrix.h:109: note:                 QCD::Matrix<TNum> QCD::operator*(QCD::Matrix<TNum>, const T2&) [with TNum = double, T2 = QCD::Matrix<double>]

是否有可能在不必明确写下 T2 的所有可能专业化的情况下克服这种歧义？

仅供参考，这是我的实现：

template<typename TNum> template <typename T2>
Matrix<TNum>& Matrix<TNum> ::
operator*=(const T2& rhs)
{
    for(TMatIdx i = 0; i < Size; i++)
        Data[i] *= rhs;
    return *this;
}

template<typename TNum> template <typename T2>
const Matrix<TNum> Matrix<TNum> ::
operator*(const Matrix<T2>& right) const
{
    Matrix<TNum> c(NRows, right.NCols);
    TNum sum_elems;
    for(TMatIdx i = 0; i < NRows; i++)
    {
        for(TMatIdx j = 0; j < right.NCols; j++)
        {
            sum_elems = TNum(0);
            for(TMatIdx k = 0; k < right.NRows; k++)
            {
                sum_elems += at(i, k) * right.at(k, j);
            }

            c.at(i, j) = sum_elems;
        }
    }
    return c;
}


template <typename TNum, typename T2>
Matrix<TNum> operator*(Matrix<TNum> lhs, const T2& rhs)
{
    lhs *= rhs;
    return lhs;
}

template <typename TNum, typename T2>
Matrix<TNum> operator*(const T2& lhs, Matrix<TNum> rhs)
{
    rhs *= lhs;
    return rhs;
}
4

2 回答 2

3

我将用c++11描述一个解决方案，然后解释如何在c++98中实现它。

在 c++11 中，标头<type_traits>包括类型函数和类型谓词。这使得执行约束更加方便。

std::is_same<T1, T2>::value如果T1是相同的类型，则为真T2，否则为假。

typename std::enable_if< bool, T >::typeT如果 bool 为真，则为定义明确的类型，否则为定义不明确的类型。

当编译器查找候选模板函数和方法时，如果尝试的特化失败，它不会抛出错误。它只是抛出了那个候选人。这意味着以下代码将消除歧义：

template <typename TNum, typename T2>
typename std::enable_if< (!std::is_same<Matrix<TNum>, T2>::value),
Matrix<TNum> >::type operator*(const T2& lhs, Matrix<TNum> rhs);

做出此决定时仅考虑声明。上述逻辑在语义上是合理的，但读起来很碍眼。所以 c++11 支持模板别名和 constexpr 函数。

template<bool B, typename T = void>
using Enable_if = typename std::enable_if<B, T>::type;

template<typename T1, typename T2>
constexpr bool Is_same(){
  return std::is_same<T1, T2>::value;
}

那么上面就变成了：

template <typename TNum, typename T2>
Enable_if<( !Is_same<Matrix<TNum>, T2>() ),
Matrix<TNum> > operator*(const T2& lhs, Matrix<TNum> rhs);

概念将提供工具，使这更方便。

现在，如果您没有 c++11，您将无法获得眼球。但是，Boost 提供了相同的功能。假设您都没有，实施它们并不可怕。

编译时函数依赖于多种语言规则，这使得它们难以理解。我们会enable_if先考虑。我们希望typename enable_if<true, T>::type得到明确的定义，但是，typename enable_if<false, T>::type是胡说八道。我们使用专业化：

template<bool B, typename T = void>
struct enable_if {
  typedef T type;
};

template<typename T>
struct enable_if<false, T> {};

注意 false 恰好处理了一半的相关案例。以上值得细细细细品味。

为了实现is_same，我们在编译时需要一个 true 或 false 的概念。我们可以用静态常量变量来保证这一点。我们希望is_same有一个编译时的真值，只要它的模板参数是相同的。专业化系统规则直接处理这个问题。

template<typename, typename>
struct is_same{
  static const bool value = false;
};

template<typename T>
struct is_same<T, T>{
  static const bool value = true;
};

这应该做你想要的。请注意，您可以进一步抽象一步并制作另一对结构。

struct false_type {
  static const bool value = false;
};

struct true_type {
  static const bool value = true;
};

然后is_same变成：

template<typename, typename>
struct is_same : false_type {};

template<typename T>
struct is_same<T, T> : true_type {};

这使它看起来更像一个函数。

我更喜欢这个类别解决方案，因为将元程序分成头文件更容易。然后，您可以在其他地方重用该逻辑。不过，如果您不使用 c++11 甚至 boost，那么制作必要的编译时函数可能会让人头疼。

如果使用复杂（或任何简单的重新设计）满足您当前和未来的要求 - 更喜欢。否则，我认为这个解决方案是合理的未来证明。

于 2013-10-21T20:04:21.993 回答
0

这可能会有所帮助。

#include<utility>

template<class Type>
struct test{
private:
    struct _matrix{};
    struct _scalar{};
    template<class T>
    struct category{
        typedef _scalar type;
    };
    template<class T>
    struct category<test<T>>{
        typedef _matrix type;
    };

    template<class T>
    void do_foo(T, _matrix){}

    template<class T>
    void do_foo(T, _scalar){}

public:
    //c++11
    template<class T>
    void operator*(T&& a){
        do_foo(std::forward<T>(a), category<T>::type());
    }
    //Older Compiler
    //template<class T>
    //void operator*(const T& a){
    //  do_foo(a, category<T>::type());
    //}

};

int main(){
    typedef test<int> int_matrix;
    int_matrix obj;
    obj*int_matrix();
    obj*obj;
    obj*1;
    obj*1.;

    return 0;
}
于 2013-10-16T02:44:33.150 回答