运算符重载 [][] 二维数组 C++

Question

我有一个二维数组，我想定义一个函数，该函数返回用户使用运算符重载给我的索引值。 换句话说：

void MyMatrix::ReturnValue()
{
    int row = 0, col = 0;
    cout << "Return Value From the last Matrix" << endl;
    cout << "----------------------------------" << endl;
    cout << "Please Enter the index: [" << row << "][" << col << "] =" << ((*this).matrix)[row][col] << endl;
}

操作((*this).matrix)[row][col] 应该返回一个int。 我不知道如何构建operator [][]。
或者，我可以连接几个对operator [] 的调用，但我没有成功，因为对该操作符的第一次调用将返回int*，第二次调用将返回int，它迫使建立另一个运营商，我不想这样做。

数据矩阵定义如下

int** matrix; matrix = new int*[row];
if (matrix == NULL)
{
    cout << "Allocation memory - Failed";
}
for (int i = 0; i < row; i++)//Allocation memory
{
    matrix[i] = new int[col];
    if (matrix[i] == NULL)
    {
        cout << "Allocation memory - Failed";
        return;
    }
}

我能做什么？ 谢谢，

Answer 1

简单地说，such an operator does not exist，所以你不能超载它。

一种可能的解决方案是定义两个类：Matrix 和 Row。
您可以定义Matrix 的operator[]，使其返回Row，然后为Row 定义相同的运算符，使其返回实际值（int 或任何您想要的，您的@987654329 @ 也可以是模板）。
这样，myMatrix[row][col] 的声明就合法且有意义。

同样可以将新的Row 分配给Matrix 或更改Row 中的值。

* 编辑 *

根据 cmets 中的建议，在这种情况下，您也应该 take in consideration 使用 operator() 而不是 operator[]。
这样，就不再需要 Row 类了。

Answer 2

您可以为班级定义自己的operator []。一个简单的方法可以如下所示

#include <iostream>
#include <iomanip>

struct A
{
    enum { Rows = 3, Cols = 4 };
    int matrix[Rows][Cols];
    int ( & operator []( size_t i ) )[Cols]
    {
        return matrix[i];
    }
};

int main()
{
    A a;

    for ( size_t i = 0; i < a.Rows; i++ )
    {
        for ( size_t j = 0; j < a.Cols; j++ ) a[i][j] = a.Cols * i + j;
    }


    for ( size_t i = 0; i < a.Rows; i++ )
    {
        for ( size_t j = 0; j < a.Cols; j++ ) std::cout << std::setw( 2 ) << a[i][j] << ' ';
        std::cout << std::endl;
    }
}

程序输出是

 0  1  2  3 
 4  5  6  7 
 8  9 10 11 

Answer 3

我不知道如何构建operator [][]。

有时可以使用不同的运算符，即()：

int& Matrix::operator () (int x, int y)
{
    return matrix[x][y];
}

const int& Matrix::operator () (int x, int y) const
{
    return matrix[x][y];
}

int diagonal (const Matrix& m, int x)
{
    return m (x, x); // Usage.
}

优势：

• 无需使用像Row 或Column 这样的“中级”类。

• 比Row& Matrix operator (int); 更好的控制，因为有人可以使用Row 引用来插入一行非法长度。如果Matrix 应该代表一个矩形的东西（图像，代数中的矩阵），那是一个潜在的错误来源。

• 在较高维度上可能不那么乏味，因为operator[] 需要所有较低维度的类。

缺点：

• 不常见，不同的语法。

• 如果需要，无需再轻松替换完整的行/列。但是，无论如何，替换列并不容易，只要您使用行来建模（反之亦然）。

在任何一种情况下，如果在运行时不知道维数，则各有利弊。

Answer 4

我正在寻找自测阵列替换... 改进版本返回引用或空引用并检查内部边界。

#include <iostream>
#include <iomanip>

template<typename T, int cols>
class Arr1
{
public:
    Arr1(T (&place)[cols]) : me(place) {};
    const size_t &Cols = cols;
    T &operator [](size_t i)
    {
        if (i < cols && this != NULL) return me[i];
        else {
            printf("Out of bounds !\n");
            T *crash = NULL;
            return *crash;
        }
    }
private:
    T (&me)[cols];
};
template<typename T, int rows, int cols>
class Arr2
{
public:
    const size_t &Rows = rows;
    const size_t &Cols = cols;
    Arr2() {
        ret = NULL;
        for (size_t i = 0; i < rows; i++) // demo - fill member array
        {
            for (size_t j = 0; j < cols; j++) matrix[i][j] = cols * i + j;
        }
    }
    ~Arr2() {
        if (ret) delete ret;
    }
    Arr1<T, cols>(&operator [](size_t i))
    {
        if (ret != NULL) delete ret;
        if (i < rows) {
            ret = new Arr1<T, cols>(matrix[i]);
            return *ret;
        }
        else {
            ret = NULL;
            printf("Out of bounds !\n");
            return *ret;
        }
    }
    //T(&MemberCheck)[rows][cols] = matrix;
private:
    T matrix[rows][cols];
    Arr1<T, cols> *ret;
};
template<typename T,int rows, int cols>
class Arr
{
public:
    const size_t &Rows = rows;
    const size_t &Cols = cols;
    T(&operator [](size_t i))[cols]
    {
        if (i < rows) return matrix[i];
        else {
            printf("Out of bounds !\n");
            T(*crash)[cols] = NULL;
            return *crash;
        }
    }
    T (&MemberCheck)[rows][cols] = matrix;
private:
    T matrix[rows][cols];
};

void main2()
{
    std::cout << "Single object version:" << endl;
    Arr<int, 3, 4> a;

    for (size_t i = 0; i <= a.Rows; i++)
    {
        int *x = &a[i][0];
        if (!x) printf("Fill loop - %i out of bounds...\n", i);
        else for (size_t j = 0; j < a.Cols; j++) a[i][j] = a.Cols * i + j;
    }

    for (size_t i = 0; i < a.Rows; i++)
    {
        for (size_t j = 0; j <= a.Cols; j++) {
            std::cout << std::setw(2) << a[i][j] << ' ';
            if (a.MemberCheck[i][j] != a[i][j])
                printf("Internal error !");
        }
        std::cout << std::endl;
    }

    std::cout << endl << "Double object version:" << endl;

    Arr2<int, 3, 4> a2;
    for (size_t i = 0; i < a2.Rows; i++)
    {
        for (size_t j = 0; j <= a2.Cols; j++) {
            int &x = a2[i][j];
            if (&x)
            {
                x++;
                std::cout << std::setw(2) << a2[i][j] << ' ';
                //if (&a2.MemberCheck[i][j] != &a2[i][j])
                //  printf("Internal error !");
            }
        }
    }
}

输出

Single object version:
Out of bounds !
Fill loop - 3 out of bounds...
 0  1  2  3  4
 4  5  6  7  8
 8  9 10 11 -858993460

Double object version:
 1  2  3  4 Out of bounds !
 5  6  7  8 Out of bounds !
 9 10 11 12 Out of bounds !

Answer 5

#include<iostream>
using namespace std;
class matrix
{
     int **arr;
     int r;
     int c;
     public:
    /* another code*/
     class row
    {
        matrix &_a;
        int _i;
        public:
        row(matrix &a,int i) : _a(a),_i(i){}
        int operator[](int j) {return _a.arr[_i][j];}
     };
     row operator[](int i)
    {   
        return row(*this,i);
     }
 };

这对你有帮助