image pointer to pointer initialization in C++ - c++

Question

I meet a problem when dealing with image initialization.
I have a class like this:
Class MyImage
{
private:
unsigned int** image;
const unsigned int w;
const unsigned int h;
public:
MyImage(unsigned int** _image,unsigned int _w,
unsigned int _h); // copy constructor
}
it seems if I use copy constructor as above, I need to delete image first like below:
MyImage(unsigned int** _image,unsigned int _w,unsigned int _h)
{
if (image)
{
for (int i = 0;i < w;++i)
delete[] image[i];
delete[] image;
}
// .. copy _image to imge
}
however if w and h are const members, it seems w and h must be initialized in the inialization list, like below:
MyImage(unsigned int** _image,unsigned int _w,unsigned int _h): w(_w),h(_h)
{
// ..code
}
then I can't delete image because w changes before it. My Question is what should I do if I don't want to eliminate const decoration in w and h? Any method? Thanks.

Answer 1

This is not a copy-constructor
MyImage(unsigned int** _image,unsigned int _w,unsigned int _h)
This is a copy-constructor
MyImage(const MyImage &image)
Don't use : w(_w) and first delete previous image, then use w = image._w.
However, you don't need delete anything because it's a constructor.

Answer 2

Use an encapsulated std::vector to manager the image data. The default copy constructor, move constructor, assignment operator, move assignment operator and default destructor will all be automatically generated for you and do the right things. Further by allocating the image data in a continuous block of memory and using a stride over row (or column) major order, it will be far more efficient than allocating a new memory block for every line...
struct MyImage
{
const size_t w, h;
vector<int> image;
MyImage(const vector<int>& image, size_t w, size_t h)
: image(image)
, w(w)
, h(h)
{
assert(image.size() == w*h);
}
MyImage(vector<int>&& image, size_t w, size_t h)
: image(move(image))
, w(w)
, h(h)
{
assert(image.size() == w*h);
}
int& pixel(size_t x, size_t y) { return image[w*y+x]; }
int pixel(size_t x, size_t y) const { return image[w*y+x]; }
};

Answer 3

In your case, there is nothing wrong with w and h being a const. You can write your constructor in the following way:
MyImage(unsigned int** _image,unsigned int _w,unsigned int _h)
: w(_w), h(_h)
{
// No data is allocated in the memory pointed to by image yet
// We have to allocate it here. Remember, that copy-ctor is
// a constructor, so it operates on newly created instance,
// not on an existing one.
image = new unsigned int * [h];
for (int i = 0; i < h; i++)
{
image[i] = new unsigned int [w];
memcpy(image[i], _image[h], w * sizeof(unsigned int));
}
}
From my image-processing experience, consider storing an image as a single table, row-by-row. You can access (x, y)-th element by calling data[y * w + x]; In such case, you can simplify your copy ctor:
MyImage::MyImage(unsigned int * source, int newW, int newH)
: w(newW), h(newH)
{
image = new unsigned int[w * h];
memcpy((void *)image, (void *)source, w * h * sizeof(unsigned int));
}
The copy constructor, as C++ community understands this term, would look like this:
MyImage::MyImage(const MyImage &source)
: w(source.w), h(source.h)
{
image = new unsigned int[w * h];
memcpy((void *)image, (void *)source.image, w * h * sizeof(unsigned int));
}
Notice, that the image field does not exist when you call the constructor, so you do not need to free anything.
// Your code
MyImage(unsigned int** _image,unsigned int _w,unsigned int _h)
{
// Class is allocated into some part of memory, which might
// have been used, so in effect this may be actually true,
// because image may contain some rubbish data
if (image)
{
// But this will result mostly likely in Access Violation
// error, because you would try to use (free!) some random
// data in memory.
for (int i = 0;i < w;++i)
delete[] image[i];
delete[] image;
}
// .. copy _image to imge
}
If you need an assign-like method, which copies contents of some image (either stored in a unsigned int * or in another Image class) to an existing instance of Image, w and h cannot be const.