两个方括号重载

Question

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

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

M1[1][2]=5;

或者

int X;

X=M1[4][5];

Answer 1

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

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

Answer 2

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

Answer 3

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

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

最后

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

：

Matrix m;
...
double value = m[i][j];
...

Answer 4

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

您可以执行如下操作来避免所有麻烦。

struct loc
{
  int x;
  int y;
};

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

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

要调用，您可以简单地执行某些操作喜欢：

matrix[loc(2,3)] = 5; 

Answer 5

事实上，几年前我在自己的矩阵课上就是这么做的。在本例中，我定义了一个矩阵模板类，其中包含下面的代码片段。

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

          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];
}

Answer 6

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

但是，请注意，您用于调用前一个重载运算符 [] 的索引必须保存在某个位置，以便您可以在后一个重载运算符 [] 中使用它。出于这个原因，我只是向 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]);
}

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

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

我希望这对你有帮助。

Answer 7

您不能像这样重载 [][] ，因为没有这样的
操作员。你可以重载 [] 来返回一些东西
定义了一个 [] （代理）；在最简单的情况下，
像 double* 这样的东西可以工作，但通常更好，
虽然多一点工作，但要使用完整的类。 （需要添加的地方
例如，边界检查。）

或者，您可以重载 (x,y)。取决于你是谁
问，一种格式或另一种“更好”。 （事实上​​，这是
严格来说是风格问题。）

Answer 8

模板矩阵类

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;