通过重载下标操作符()从矩阵中获取向量

我想这样做:

Matrix m;    // (4x4 matrix)
Vector4 v;   // (4-elements vector)
m(0) = v;    // replace first 4-elements matrix row by vector v
v = m(0);    // replace vector v by first 4-elements matrix row

下面是我的代码:

Vector4& Matrix::operator() (unsigned row)
{
    return Vector4(mat[row][0], mat[row][1], mat[row][2], mat[row][3]);
}
Vector4 Matrix::operator() (unsigned row) const
{
    return Vector4(mat[row][0], mat[row][1], mat[row][2], mat[row][3]);
}

第二个操作符工作正常，但当我试图编译第一个操作符时，我得到这个错误:

错误:从' Vector4 '类型的右值初始化' Vector4 '类型的非const引用无效

那么问题在哪里呢?在这种情况下，重载operator()而不是operator[]是个好主意?

通过只从矩阵中获取一个元素，我使用了另外两个操作符:

float& Matrix::operator() (unsigned row, unsigned col)
{
    return mat[row][col];
}
float Matrix::operator() (unsigned row, unsigned col) const
{
    return mat[row][col];
}

编辑1(几乎解决)

我想我找到解决办法了。第一个操作符被替换为:

Matrix::MatrixHelper operator() (unsigned row)
{
    MatrixHelper m;
    m.f1 = &mat[row][0];
    m.f2 = &mat[row][1];
    m.f3 = &mat[row][2];
    m.f4 = &mat[row][3];
    return m;
}

是MatrixHelper类的定义:

class MatrixHelper
{
    public:
    friend class Matrix;
    void operator= (const Vector4& v)
    {
        *f1 = v.x;
        *f2 = v.y;
        *f3 = v.z;
        *f4 = v.w;
    }
    private:
    float* f1;
    float* f2;
    float* f3;
    float* f4;
};

现在可以这样做:

m(0) = Vector4(3,3,3,3);

但是在调用this时出现新的问题:

(m)(0) * someScalar;

第二个操作符从未被调用，所以我必须在我的MatrixHelper类中实现它们对吗?我走对了吗?

编辑2

如果两个操作符同时工作，这个问题就解决了。但现在只能启用其中一个。我不明白为什么总是工作第一个操作符，例如有这个代码(只是示例):

Vector4& Matrix::operator() (unsigned row)
{
    std::cout << "Operator one is working nown";
}
Vector4 Matrix::operator() (unsigned row) const
{
    std::cout << "Operator two is working nown";
}

无论我是否在做

m(0) = Vector(4,4,4,4)

或

Vector4 v = m(0)

总是操作第一个操作符。为什么?

Edit 3 (Solution)

我已经找到了一些其他的解决方案。现在一切正常，但性能可能有一点问题。解决方案没有以我想要的方式解决，而且有点牵强。下面是代码:

操作符:

Vector4 Matrix::operator() (unsigned row)
{
    return Vector4 (&mat[row][0], &mat[row][1], &mat[row][2], &mat[row][3]);
}
Vector4 Matrix::operator() (unsigned row) const
{
    return Vector4 (mat[row][0], mat[row][1], mat[row][2], mat[row][3]);
}

如你所见，第一个操作符

返回一个接受指针的向量。艰苦的工作现在发生在Vector4类而不是矩阵。Vector4现在有一个额外的构造函数:

Vector4(float* x, float* y, float* z, float* w)
{
    this->px = x; this->py = y; this->pz = z; this->pw = w;
    this->x = *x; this->y = *y; this->z = *z; this->w = *w;
    pointer = true;
}

第一行是指针，第二行是变量，第三行是布尔类型变量，表示调用了什么构造函数(普通或指针)。

最后一个操作符(operator=):

Vector4 operator= ( const Vector4& v)
{
    if ( pointer )
    {
        *px = x = v.x;
        *py = y = v.y;
        *pz = z = v.z;
        *pw = w = v.w;
    }
    else
    {
        x = v.x;
        y = v.y;
        z = v.z;
        w = v.w;
    }
}

如果pointer为真，则意味着- px, py, pz和pw是指向矩阵中某些行元素的指针，我们必须改变它们。

现在的问题是…这是糟糕的糟糕解决方案，还是只是糟糕?: D