Question

我已经声明了一个带有两个operator（）函数的类Image，一个用于只读，另一个用于读写访问。

这是一个摘录：

class Image {
  //...
  public: 

  uint16_t operator()(int x, int y) const
  {
    return data_[x + y*width_];                  // read-only at pixle (x,y)
  }

  uint16_t & operator()(int x, int y)
  {
    return data_[x + y*width_];                 // read/write to pixle (x,y)
  }

 //... 
}

在此之后，我在main（）函数中声明了一个Image对象并写入它（由于提到的公共接口operator（）而必须工作），但是几个编译器只能识别第一个operator（）函数只有阅读权限。

示例：

if (count_alive_neighbors(image, i, j) == 3) {
   image(i, j) = 255; 
}

我的想法是，也许人们可以通过声明指针并通过改变值来克服这个问题。代码：

    uint16_t* f = &image(i, j);
    *f = 255;

在Microsoft Visual Studio 2015上，这首先在if循环之外单独进行了测试，但在刚才提到的函数中它并没有。但它不是编译器错误，我已经用Clang，g ++和MinGW测试了它。

所有人都打印出如下错误信息：

 error: lvalue required as unary '&' operand
     uint16_t* f = &(image(i, j));
                      ^

总结一下，问题如下：如何通过不关注指针声明来克服这个问题，怎样才能告诉编译器它必须使用哪个版本的operator（）？它本身并没有认识到它，或者我没有认识到必须改变哪些设置/代码才能使程序正常工作。

提前致谢。

编辑：全班定义和功能

#include <vector>
#include <string>
#include <stdexcept>
#include <fstream>
#include <cstdint>

class Image
{
    int width_;
    int height_;
    std::vector<uint16_t> data_;

    public:

    Image()
    : width_(0)
    , height_(0)
    {}

    Image(unsigned int width, unsigned int height)
    : width_(width)
    , height_(height)
    , data_(width*height, uint16_t())
    {}

    int width() const
    {
        return width_;
    }

    int height() const
    {
        return height_;
    }

    int size() const
    {
        return width_*height_;
    }

    void resize(unsigned int new_width, unsigned int new_height)
    {
        data_.resize(new_width*new_height, uint16_t());
        width_  = new_width;
        height_ = new_height;
    } 

    uint16_t operator()(int x, int y) const
    {
        return data_[x + y*width_];
    }

    uint16_t & operator()(int x, int y)
    {
        return data_[x + y*width_];
    }

    uint16_t get_periodic(int x, int y) const
    {
        int xres = x % width_;
        int yres = y % height_;

        return data_[xres + yres*width_];
    }
};


int count_alive_neighbors(Image const & image, int x, int y) {
    int res = 0;
    for (int i = -1; i <= 1; i++) {
        for (int j = -1; j <= 1; j++) {
            if (image.get_periodic(x + i, y + j) == 255) {
                res += 1;
            }
        }
    }
    if (image.get_periodic(x, y) == 255) {
        res -= 1;
    }
}

Image conway_step(Image const & image) {
    for (int i = 0; i <= image.width(); i++) {
        for (int j = 0; j <= image.height(); j++) {
            if (count_alive_neighbors(image, i, j) == 2)
            {
            }

            if (count_alive_neighbors(image, i, j) == 3) {
                image(i, j) = 255;
            }

            if (count_alive_neighbors(image, i, j) < 2) {
               image(i, j) = 0;
            }

            if (count_alive_neighbors(image, i, j) > 3) {
                image(i, j) = 255;  
            }
        }
    }
}

int main() {
    Image img(3, 3);              // declaring object
    img(3, 3) = 255;              /* !ATTENTION! this works, but inside       
                                     conway_steps it doesn't */

}

Answer 1

[基于评论] conway_step应该复制其参数，修改该副本并返回副本。您的问题是您没有制作副本并尝试修改原件。

Answer 2

请从

更改您的功能签名

Image conway_step(Image const & image)

到

Image conway_step(Image & const image) //ill formed

或以更好的方式

Image conway_step(Image & image)

在第一种情况下，它相当于const Image & image，因此它会调用const限定运算符=＆gt; image(i, j)=255; =＆GT; uint16_t=255 =＆gt; left operand must be l-value错误

在第二种/第三种情况下，声明对非const对象的const引用。

C ++函数在类中重载

2 个答案: