Question

我正在实现一个简单的C ++网格类。它应支持的一个函数是通过圆括号访问的，这样我就可以通过编写mygrid（0,0）来访问这些元素。我重载了（）运算符，我收到错误消息：“赋值中的非左值”。

我希望能够做到的事情：

//main

cGrid<cA*> grid(5, 5);

grid(0,0) = new cA();

我的网格类实现的摘录：

模板 class cGrid {

private:
    T* data;
    int mWidth;
    int mHeight;

public:
    cGrid(int width, int height) : mWidth(width), mHeight(height) { 
        data = new T[width*height]; 
    }

    ~cGrid() { delete data; }

    T operator ()(int x, int y)
    {
        if (x >= 0 && x <= mWidth) {
            if (y >= 0 && y <= mHeight) {
                return data[x + y * mWidth];
            }
        }
    }


    const T &operator ()(int x, int y) const
    {
        if (x >= 0 && x <= mWidth) {
            if (y >= 0 && y <= mHeight) {
                return data[x + y * mWidth];
            }
        }
    }

其余的代码处理迭代器的实现，不应该是相关的。

Answer 1

这个模板是什么：

 T &operator ()(int x, int y) const
{
    if (x >= 0 && x <= mWidth) {
        if (y >= 0 && y <= mHeight) {
            return data[x + y * mWidth];
        }
    }
}

如果x＆amp;你超出范围？你应该提出一个例外。你如何在构造函数中为内存分配内存？关于constness，你需要提供这个运算符的两个版本 - 一个返回const引用的const，以及一个返回非const引用的非const。

编辑：您在操作员中也有一个错误的错误。这编译并运行：

template <typename T>
struct Grid {
    Grid( int x, int y ) : mX(x), mY(y), mData(0) {
      mData = new T[ x * y ];
    }

    ~Grid() {
      delete [] mData;
    }

    T &operator ()(int x, int y)  {
        if (x >= 0 && x < mX) {
            if (y >= 0 && y < mY) {
                return mData[x + y * mX];
            }
        }
    throw "out of range" ;;
    }

    int mX, mY
    T * mData;
};


int main() {
    Grid <int> g(2,3);
    g(0,0) = 42;
}

Answer 2

比尔说，运营商不应该是const。我相信这是编译错误的原因（即使报告的错误看起来不同）。编译器只在分配行遇到错误，因为它是模板类。

要明确，您不能让const方法返回对非const的引用。即，问题是声明T &operator... const是非法的。它应该是T &operator...或const T &operator... const。当然，你可以同时拥有两者。

编辑：删除const无济于事，因为现在两种方法都具有相同的签名（出于解析调用的目的，返回类型不被视为签名的一部分）。被调用的方法是返回T而不是T &的方法。摆脱它（或用const方法替换它，返回const引用。）

试图在赋值中创建一个简单的网格类，非左值

2 个答案: