c++ - 矩阵模板实现的坏方面

Question

我像这样实现了模板矩阵类。

template<typename T, int NRows, int NCols>
class MatrixMN;

但现在我怀疑用模板实现矩阵是否是正确的选择，原因如下。

1。 operator*= 无法定义

这是因为用于矩阵乘法的 *= operator 可能会返回具有不同维度的矩阵类型。

不同的维度意味着模板实现的不同类型。

2。不能为具有不同 T 参数

的两个 MatrixMN 定义算术运算符

让我们为矩阵乘法定义一个二元运算符。

template <typename T1, int NRows1, int NCols1, typename T2, int NRows2, int NCols2>
MatrixMN<??, NRows1, NCols2> operator*(const MatrixMN<T1, NRows1, NCols1> &m1, const MatrixMN<T2, NRows2, NCols2> &m2)

T1 和 T2 可能是 {int 和 double} 或 {double > 和 int}。

所以我无法决定返回的 MatrixMN 的 T 参数。

我想出了一些解决方法。

• 强制返回的 MatrixMN 具有 float 据类型，如 double
• 只是不要为两个不同的 T 参数定义运算符。

但是这些都不能完美的解决问题...

---

这样实现矩阵类是错误的吗？

Answer 1

您可以限制 operator* 仅适用于相同类型的矩阵，并且您知道结果大小:m×n 乘以 n×k 结果是 m×- k矩阵。把它放在一起，你会得到:

template<typename T, int M, int N, int K>
MatrixMN<T, M, K> operator*(const MatrixMN<T, M, N> &lhs, const MatrixMN<T, N, K> &rhs)

如果你只想允许隐式转换类型那么使用std::common_type :

// Arithmetic operation allowing for implicitly convertible types
template<typename TL, typename TR, int M, int N, int K>
MatrixMN<typename std::common_type<TL, TR>::type, M, K> operator*(
        const MatrixMN<TL, M, N> &lhs,
        const MatrixMN<TR, N, K> &rhs)

如果你想允许你定义的类型的任意组合，这就是 traits 的用途:

template<typename LHS, typename RHS, typename RES>
struct MatrixMNBinaryTraitsBase {
    typedef LHS TypeLeft;       // Element type of left hand side
    typedef RHS TypeRight;      // Element type of right hand side
    typedef RES TypeMultResult; // Element type of matrix multiplication
};

// Base case: support for implicitly convertible types
template<typename TL, typename TR>
struct MatrixMNBinaryTraits : MatrixMNBinaryTraitsBase<TL, TR, typename std::common_type<TL, TR>::type> { };

// Special case Foo x Bar -> Foobar
template<>
struct MatrixMNBinaryTraits<Foo, Bar> : MatrixMNBinaryTraitsBase<Foo, Bar, Foobar> { };

// Arithmetic operation allowing for different types according to MatrixMNBinaryTraits
template<typename TL, typename TR, int M, int N, int K>
MatrixMN<typename MatrixMNBinaryTraits<TL, TR>::TypeMultResult, M, K> operator*(
        const MatrixMN<TL, M, N> &lhs,
        const MatrixMN<TR, N, K> &rhs)