Move semantics operator declaration in header

[kausikp11]

I have a doubt, while using a .hpp file to declare the move operator? When I tried I am getting the following error.

.hpp file

#include <iostream>

namespace pixelator
{
   struct Size
   {
      int *row;
      int *col;
   };
   class StbImageDataView
   {
   public:
      StbImageDataView() = default;
      explicit StbImageDataView(std::filesystem::path image_path);

      pixelator::Size size();
      int rows();
      int cols();
      bool empty();
      ftxui::Color at(int row, int col);
      ~StbImageDataView();

   private:
      unsigned char *image_{nullptr};
      pixelator::Size size_of_image_{};
      int *channels_{};
   };
} // namespace pixelator

#endif /* PIXELATOR_STB_IMAGE_DATA_VIEW_HPP */

.cpp declaration

#include <pixelator/stb_image_data_view.hpp>

pixelator::StbImageDataView::StbImageDataView(std::filesystem::path image_path)
{
    if (!std::filesystem::exists(image_path))
    {
        std::cerr << "Failed to open the image: " << image_path << std::endl;
        pixelator::StbImageDataView::size_of_image_.col = 0;
        pixelator::StbImageDataView::size_of_image_.row = 0;
        pixelator::StbImageDataView::channels_ = 0;
    }
    else
    {
        pixelator::StbImageDataView::image_ = stbi_load(image_path.c_str(), pixelator::StbImageDataView::size_of_image_.col, pixelator::StbImageDataView::size_of_image_.row, pixelator::StbImageDataView::channels_, 0);
    }
}

pixelator::StbImageDataView &operator = ( pixelator::StbImageDataView &&other )
{
    if (this == &other)
    {
        return *this;
    }
    if (this.image_)
        stbi_image_free(this.image_);

    this.image_ = other.image_;
    this.size_of_image_.row = other.size_of_image_.row;
    this.size_of_image_.col = other.size_of_image_.col;
    this.channels_ = other.channels_;

    other.image_ = nullptr;
    other.size_of_image_.row = 0;
    other.size_of_image_.col = 0;
    other.channels_ = 0;

    return *this;
};

bool pixelator::StbImageDataView::empty()
{
    if (pixelator::StbImageDataView::size_of_image_.row == 0 && pixelator::StbImageDataView::size_of_image_.col == 0)
    {
        return true;
    }
    return false;
}

pixelator::Size pixelator::StbImageDataView::size()
{
    return pixelator::StbImageDataView::size_of_image_;
}

int pixelator::StbImageDataView::rows()
{
    int row = *this->size_of_image_.row;
    return row;
}
int pixelator::StbImageDataView::cols()
{
    int col = *this->size_of_image_.col;
    return col;
}

ftxui::Color pixelator::StbImageDataView::at(int row, int col)
{
    ftxui::Screen screen{ftxui::Screen(*this->size_of_image_.row, *this->size_of_image_.col)};
    screen.Print();
    auto &pixel = screen.PixelAt(row, col);
    auto color = pixel.foreground_color;
    return color;
}

pixelator::StbImageDataView::~StbImageDataView()
{
    stbi_image_free(pixelator::StbImageDataView::image_);
}

Please share your suggestion how to add it

[niosus]

@kausikp11 Sorry to hear it doesn't work for you. But I think you might have forgotten to specify what error you are getting. Also, I went ahead and modified your message so that the code gets properly rendered, please feel free to examine the changes I made for future references. The easiest way for me to be able to help out is to make sure I understand the problem. Formulating and formatting the question as precise as possible is a key part of me being able to help.

[kausikp11]

Hi Igor, I checked your code. The place where I get error is the &operator which we use to apply the move function.

Attaching the code error I got. I have gone through the lecture, but where I got confused is the part on how to split the move operator and its function from header and source file.

Specifically at this implementation I have the doubt - pixelator::StbImageDataView &operator(already in code), pixelator::StbImageDataView::StbImageDataView(StbImageDataView&& other_image)(Yet to add)

[kausikp11]

you can also see my current code which I am facing this issue.
Link:- https://github.com/kausikp11/cpp_homework/tree/main

[niosus]

@kausikp11 as your code stands now, you only have the implementation of the move assignment operator in the cpp file. But you are missing a couple of things. First, you are missing a declaration of this operator in your class in the header file. Second, you are missing an indicator StbImageDataView:: that your operator belongs to your class. You have it for other functions, but not for the operator.

In the end of the day, the operator= part is just a name of the function, nothing more than that. You are handling all the other functions correctly in your code, so you're nearly there! I've also set up a small example here that you can use as a hint too: https://godbolt.org/z/eKEaqd3Tq

Hope this helps!

[kausikp11]

Got it now. So we are using that "operator" to the class like a variable and the "&" symbol is linked to the class.
Thank you for correcting me.

[niosus]

Glad it worked for you! I still wouldn't go as far as say that "operator to the class is like a variable etc. The operator is just a function. The name of that function is operator=. The parameter types that we pass into this function are, depending on if we want a copy or a move assignment operator, const StbImageDataView& or StbImageDataView&&. Hope this makes some sense. And if you issue is resolved please mark the comment that helped you resolve it as an answer to this discussion.

[kausikp11]

And another thing that pops up is that you are using int* a lot, for example for the struct Size. Why do you need the fields of that struct to be pointers?

I made it as pointer because to assign the row and cols using stb library. But it can be made different using private variable and assign size whenever needed.

[niosus]

Can you elaborate a bit on this? Why would making the size entry pointers help assign them with the STL library?

[kausikp11]

I was trying to use pass by reference to update the value of row and column. But now understood instead of it using the private variable and assigning it later to size struct works better.