2D 矩阵和重载operator()/丑陋的语法

Question

我在我的一个项目中使用二维矩阵。 这就像 C++ FAQ Lite。

巧妙的是，您可以像这样使用它：

int main()
{
  Matrix m(10,10);
  m(5,8) = 106.15;
  std::cout << m(5,8);
  ...
}

现在，我有一个由顶点组成的图，每个顶点都有一个指向 2D 矩阵的公共（只是为了简单起见）指针，如上所示。 现在我确实有一个非常丑陋的语法来访问它。

(*sampleVertex.some2DTable)(0,0) = 0; //bad
sampleVertex.some2DTable->operator()(0,0) = 0; //even worse...

由于我对运算符重载缺乏经验，可能我在这里缺少一些语法糖。 有更好的解决方案吗？

Answer 1

1. 考虑使用引用而不是指针（前提是它不能为 null 并且可以在构造函数中初始化）。

2. 考虑为顶点创建一个 getter 或矩阵包装类的实例，以返回对 2D 矩阵的引用（前提是它不能为 null）。

   sampleVertex.some2DTable()(0,0) = 0; 
     SampleVertex.some2DTableWrap(0,0) = 0; 
     

然而，对我来说，这听起来并不是什么问题，足以证明经历所有麻烦是合理的。

Answer 2

如果您有一个指向 Matrix 的指针，例如作为无法引用的函数参数（例如遗留代码），您仍然可以对其进行引用（伪代码）：

struct Matrix {
        void operator () (int u, int v) {
        }
};
int main () {
        Matrix *m;
        Matrix &r = *m;
        r (1,1);
}

Answer 3

您基本上仅限于 (*sampleVertex.some2DTable)(0,0)。 当然，如果您不需要重新设置，为什么不将实际值存储在矩阵中呢？

或者，将指针设置为私有并创建一个访问器（注意：以下示例假设 EntryTypes 矩阵）：

Matrix& Vertex::GetTableRef() 
{
    return *some2DTable; 
}
// or
Matrix::EntryType& Vertex::GetTableEntry(int row, int col)
{
    return (*some2DTable)(row,col);
}

// way later...
myVertex.GetTableRef()(0,0) = 0;
// or...
myVertex.GetTableEntry(0,0) = 0;

或者，如果您无法更改类 Vertex，只需定义一个内联函数来为您执行此操作：

// in some header file
inline Matrix& GetTableRef(Vertex& v)
{
    return *v.some2DTable;
}

// or you could do this
inline Matrix::EntryType& GetTableEntry(Vertex& v, int row, int col)
{
    return (*v.some2DTable)(row, col);
}


// later...
GetTableRef(myVertex)(0, 0) = 0;
// or
GetTableEntry(myVertex, 0, 0) = 0;

最后，不要忘记您没有必须使用运算符重载。 STL 集合实现了 at() 成员函数，该函数是经过检查的，而不是operator[] 是未经检查的。 如果您不介意边界检查的开销，或者只是想要非标准，则可以实现 at() ，然后只需调用 myVertex.some2DTable->at(0,0) ，完全避免了一些令人头痛的语法问题。

Answer 4

没有 C++ 语法糖可以减轻您所描述的痛苦：

(*sampleVertex.some2DTable)(0,0) = 0; //bad
sampleVertex.some2DTable->operator()(0,0) = 0; //even worse...

在这种情况下，我要么让图形返回引用而不是指针，要么让矩阵定义一个调用 operator() 的函数：

inline matrixType &Matrix::get( int x, int y ){ return operator()(x,y); }

然后，对于顶点示例来说，语法并不那么难看：

sampleVertex.some2DTable->get(0,0) = 0;

Answer 5

我会添加一个函数，返回一个像 rlbond 推荐的 ref 。 为了快速修复或者如果您无法控制它的源，我会这样做：

sampleVertex.some2DTable[0](0,0) = 0; // more readable

这实际上是等效的，因为如果 a 是指向已定义类的指针，则以下内容成立：

*a == *(a + 0) == a[0]

请参阅comp.lang.c++ 上关于同一问题的长讨论，并给出了很好的答案。

Answer 6

这是无需更改代码的最佳方法：

//some2DTable is a pointer to a matrix
(*sampleVertex.some2DTable)(0,0)

您还可以将 some2DTable 设为对矩阵的引用，而不是指向矩阵的指针。 然后，您将获得简化的语法，如第一个代码片段中所示。

//some2DTable is a reference to a matrix instead of a pointer to a matrix
sampleVertex.some2DTable(0,0)

或者，您可以保留 some2DTable 一个指向引用的指针，并简单地将引用变量存储到它并在代码块的上下文中使用它。

Answer 7

我会改变您获取“sampleVertex.some2DTable”的方式，以便它返回一个引用。

要么这样，要么自己创建参考：

Matrix& m = *sampleVertex.some2DTable;
m(1,2) = 3;

Answer 8

我不知道这是否值得这么麻烦，但你可以这样做：

class MatrixAccessor {
private:
  Matrix2D* m_Matrix;
public:
  MatrixAccessor(Matrix2D* matrix) : m_matrix(matrix) { }
  double& operator()(int i, int j) const { return (*m_Matrix)(i,j); }
  Matrix2D* operator->() const { return m_Matrix; }
  void operator=(Matrix2D* matrix) { m_Matrix = matrix; }
};

假设原始的operator()返回一个引用（就像在许多矩阵类中一样）。

然后，您在顶点类中提供该 MatrixAccessor：

class Vertex {
  Matrix2D* myMatrix;

public:
  MatrixAccessor matrix;
  Vertex(Matrix2D *theMatrix) : myMatrix(theMatrix), matrix(theMatrix) { }
};

然后您可以编写：

Vertex v;
v.matrix(1,0) = 13;
v.matrix->SomeOtherMatrixOperation();

编辑

我添加了 const 关键字（感谢 @phresnel 提出topic），以使解决方案在语义上等同于仅呈现公共 Matrix2D 指针的解决方案。

此解决方案的一个优点是，可以通过添加两个非 const 版本的operator()() 和operator-> 将常量转移到矩阵对象;()（即矩阵不能在 const 顶点上修改）并更改 const 顶点以返回 const double&和 const Matrix2D* 分别。

当使用指向矩阵对象的公共指针时，这是不可能的。

Answer 9

您可以通过调用成员函数来实现 Matrix::operator (int,int) 并在处理指针时直接使用该函数。

class Matrix
{
public:
  float ElementAt( int i, int j ) const { /*implement me*/ }
  float operator() ( int i, int j ) const { return ElementAt( i, j ); }
  ...
};

void Foo(const Matix* const p)
{
  float value = p->ElementAt( i, j );
  ...
}

void Bar(const Matrix& m)
{
  float value = m(i,j);
}