Question

我正在用c ++编写一个矩阵类，并试图重载某些运算符，如=和＆gt;＆gt;和＆lt;＆lt;等

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

M1[1][2]=5;

OR

int X;

X=M1[4][5];

Answer 1

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

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

Answer 2

C ++中没有operator[][]。你必须return一个帮助对象然后重载operator[]，以获得这种访问权。

Answer 3

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

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

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 4

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

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

和

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

最后：

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

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类。所以，就像你一样，我遇到了这个障碍，我怎么能超载两个方括号。我如何处理这个案子非常简单;我将方括号运算符重载了两次作为成员函数。首先，我重载[]以便返回指向所需行的指针，可以这么说，然后以下成员函数（即operator []重载）返回一个与数组元素相同类型的左值。

但是，请注意，您调用前重载operator []的索引必须保存在某处，以便您可以在后者重载的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];  
}

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

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;

两个方括号超载

8 个答案: