0

我写了一个 c++ 类，它表示任意维度 NxM 的数学矩阵。此外，我还写了一个向量类，从它派生......

template<size_t N, size_t M>
class matrix{ ... };

template<size_t N>
class vector : public matrix<N,1>{ ... };

...因此 N 向量可以被视为 Nx1 矩阵，例如，当涉及与整数值相乘或等维矩阵（或这方面的向量）的加法/减法时。这背后的想法是避免重复代码——我认为这通常是一个崇高的目标。但这是由此产生的问题：

这是加法的运算符重载，仅存在于矩阵类中：

matrix<N,M> operator+(const matrix<N,M>& right){
  //calculate some result and use it to construct a new instance
  return matrix<N,M>(result);
}

确保向量类为其矩阵表示提供了一个复制构造函数，应该可以这样说：

vector<3> a(1,2,3);
vector<3> b(3,2,1);
a = a+b;

但你不能这样说：

(a+b).some_vector_instance_method();

...因为 (a+b) 不是向量。

问题：是否有可能实现矩阵运算符+，以便它使返回类型依赖于它的调用源？因此，基本上，如果您在矩阵上调用 +，它应该返回一个矩阵；如果在向量上调用，它应该返回一个向量。

现在你可以这样做：

template<typename D>
D operator+(const D& right){
  //calculate result as usual, relying on 'right' to have what it takes
  return D(result);
}

......但它是不安全的地狱。

有任何想法吗？

4

1 回答 1

2

operator+=()实现的简单方法是为两者实现一个成员matrix<M, N>，vector<M>后者简单地委托给前者，矩阵运算符具有实际操作。就这些运算符而言，使用一些标记operator+()然后将其实现为非成员运算符。这是一个简短的草图：

#include <iostream>

namespace matrix_operators
{
    struct tag {};
    template <typename T>
    T operator+ (T const& lhs, T const& rhs) {
        return T(lhs) += rhs;
    }
}

template<size_t N, size_t M>
class matrix
    : matrix_operators::tag
{
public:
    matrix<N, M>& operator+= (matrix<N, M> const&) {
        std::cout << "matrix<" << N << ", " << M << "::operator+=()\n";
        return *this;
    }
};

template<size_t N>
class vector:
    public matrix<N,1>
{
public:
    vector<N>& operator+= (vector<N> const& other) {
        matrix<N, 1>::operator+= (other);
        return *this;
    }
    void some_other_method() {
        std::cout << "vector<" << N << ">::some_other_method()\n";
    }
};

int main()
{
    vector<3> a, b;
    (a + b).some_other_method();
}
于 2013-11-08T22:09:14.880 回答