11

我正在用 C++ 编写一个矩阵类，并尝试重载一些运算符，如 = 和 >> 和 << 等。

我无法为矩阵类重载运算符 [][]。如果我有一个像 M1 这样的类矩阵对象，那么我可以使用这种方式为每个元素赋值：

M1[1][2]=5;

或者

int X;

X=M1[4][5];
4

8 回答 8

22

只需重载operator[]并使其返回指向矩阵相应行或列的指针。由于指针支持按 下标[]，因此可以通过“双方”表示法[][]进行访问。

您还可以operator()使用两个参数重载。

于 2011-04-12T14:52:16.480 回答
9

C++中没有operator[][]。您必须拥有return一个辅助对象，然后也为此重载operator[]，才能获得这种访问权限。

于 2011-04-12T14:52:17.603 回答
7

你可以超载operator[]。因此，如果您想以这种方式使用矩阵，则应将矩阵设为向量数组。

class Matrix
{
...
  Vector & operator[]( int index );
...
};

和

class Vector
{
...
  double & operator[]( int index );
...
};

最后：

Matrix m;
...
double value = m[i][j];
...
于 2011-04-12T14:53:40.143 回答
4

没有operator[][]，您可以实现operator[]返回对行/列对象的引用，您可以在其中实现operator[]返回单元格引用。

您可以执行以下操作以避免所有麻烦..

struct loc
{
  int x;
  int y;
};

然后在您的operator[]超载中，接受 a loc，例如

T& operator[](loc const& cLoc)
{
 // now you have x/y you can return the object there.
}

要调用，您可以简单地执行以下操作：

matrix[loc(2,3)] = 5;
于 2011-04-12T14:53:26.740 回答
3

实际上，几年前我在自己的矩阵类中就是这样做的。在这种情况下，我定义了一个包含以下代码片段的矩阵模板类。

然后我能够迭代和分配如下：

          for(size_t k=1; k<n; ++k) {       
                   minor[p][k-1]=major[j][k];        
           }

我希望这有帮助。

// //////////////////////////////////////////////////////////////////////////////
// list is internal vector representation of n x m matrix
T* list;
// Proxy object used to provide the column operator
template < typename T >
class OperatorBracketHelper
{
    Matrix < T > & parent ;
    size_t firstIndex ;

    public :
        OperatorBracketHelper ( Matrix < T > & Parent , size_t FirstIndex ) : 
        parent ( Parent ), firstIndex ( FirstIndex ) {}

        // method called for column operator
        T & operator []( size_t SecondIndex )
        {
            // Call the parent GetElement method which will actually retrieve the element
            return parent.GetElement ( firstIndex , SecondIndex );
        }
};

// method called for row operator
OperatorBracketHelper < T > operator []( size_t FirstIndex )
{
    // Return a proxy object that "knows" to which container it has to ask the element
    // and which is the first index (specified in this call)
    return OperatorBracketHelper < T >(* this , FirstIndex );
}

T & GetElement ( size_t FirstIndex , size_t SecondIndex )
{
    return list[FirstIndex*cols+SecondIndex];
}
于 2014-06-06T20:22:29.487 回答
2

我正在研究一个矩阵类，我决定首先创建一个具有动态二维数组的 Array 类。所以，就像你一样，我遇到了这个障碍，我如何重载两个方括号。我如何处理这个案子很简单；我将方括号运算符作为成员函数重载了两次。首先，我重载了 [] 以便返回一个指向所需行的指针，可以这么说，然后下面的成员函数（即再次重载 operator []）返回一个与数组元素相同类型的左值。

但是，请注意，您调用前一个重载运算符 [] 的索引必须保存在某个地方，以便您可以在后一个重载运算符 [] 中使用它。出于这个原因，我只是在类 Array 中添加了一个 int 类型的新成员（我在下面的代码中将其命名为“test”）。

class Array {

private: 

 double **ptr; int test;
 ...   /* the rest of the members includes the number of rows and columns */

public:
    Array(int=3,int=3);  // Constructor
    Array(Array &);      // Copy Constructor
    ~Array();            // Destructor
    void get_array();
    void show_array();
    double* operator[] (int);
    double operator[] (short int);
    ...
};

... 

double* Array::operator[] (int a) {
    test = a;
    double* p = ptr[test];
    return p;
}

double Array::operator[] (short int b) {
   return ((*this)[test][b]);
}

因此，作为一个例子，我可以简单地写：

int main(){
Array example;
cout << example[1][2];  
}

我希望这会对你有所帮助。

于 2017-09-22T07:19:51.650 回答
0

你不能这样重载[][]，因为没有这样的运算符。您可以重载[]以返回也有[]定义的东西（代理）；在最简单的情况下，像 a 这样的东西double*会起作用，但通常使用完整的类会更好，尽管工作量更大。（例如，添加边界检查的地方。）

或者，您可以重载(x,y). 根据您的要求，一种格式或另一种格式“更好”。（事实上​​，这完全是风格问题。）

于 2011-04-12T15:22:03.973 回答
0

模板矩阵类

template <uint8_t rows, uint8_t cols, typename T>
class MatrixMxN {
public:
    T* operator[](uint8_t f_row) {
        return &m_val[f_row * cols];
    }
protected:
    T m_val[rows*cols];
};

这是3行4列整数类型的矩阵对象。

MatrixMxN<3, 4, int32_t> M;
M[2][3] = 10;
std::cout << M[2][3] << std::endl;
于 2018-10-05T07:45:54.843 回答