Question

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

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并且它强制构建另一个运算符，我不想这样做。

我该怎么办？谢谢，

Answer 1

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

一种可能的解决方案是定义两个类： Matrix 和 Row 。
您可以定义operator[]的{{1}}，以便它返回Matrix，然后为Row定义相同的运算符，以便它返回实际值（{{1}或者你想要什么，你的Row也可以是模板。）这样，声明int将是合法且有意义的。

可以执行相同的操作，以便为Matrix分配新的myMatrix[row][col]或更改Row中的值。

*编辑*

根据评论中的建议，对于此类情况，您应take in consideration使用Matrix代替Row。
这样，就不再需要operator()课了。

Answer 2

您可以为班级定义自己的#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

程序输出

transparent(/* something */)

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

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

#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

export(XDir) var x_dir: int

这可以帮助您

operator overloading [] [] 2d array c ++

5 个答案: