QImage: How to destroy pointer to pixels data properly?

Question

In my main class that controls a window, I have this function, where pixmapItem is a QGraphicsPixmapItem* defined in the class header:

void updateDisplay() {
    uchar *data = new ...; // array of pixel data
    ...
    QImage image = QImage(data, width, height,
                          width, QImage::Format_Indexed8);

    pixmapItem->setPixmap(QPixmap::fromImage(image));
}

My question is: How can I destroy data when it is not needed anymore? "Not needed anymore" means that the function above or another function in my class sets the pixmap to another image.

I have seen that QImage has cleanup functions that may help, but the documentation is not really clear on how to use them and how to pass parameters such as the data pointer of the image to delete.

Answer 1

You can delete the data when the QImage is destroyed; this, as shown by @JeremyFriesner above, can be simply done by defining the QImage instance in an inner scope, and allocate/deallocate the data outside it.

However, why bother with all that work? That QImage constructor is there to accomodate complex use cases, where you already have the pixel data from some other source, or you need to keep it for a "strange" lifetime.

Your case instead is way simpler, the pixel data has exactly the same lifetime as the QImage, so it's a better idea to let it allocate the memory for pixels by itself; that way you can be sure that it's sized and aligned correctly, and it is owned/automatically destroyed by the QImage instance; after the QImage object is constructed, you can have a pointer to the pixel data using the bits method and do whatever you want with it.

This way, your code would simply become:

void updateDisplay() {
    QImage image = QImage(width, height,
                          width, QImage::Format_Indexed8);
    uchar *data = image.bits();
    ... 

    pixmapItem->setPixmap(QPixmap::fromImage(image));
}

simpler, safer and with zero risk of memory leaks.

Answer 2

From Qt documentation

Constructs an image with the given width, height and format, that uses an existing memory buffer, data. The width and height must be specified in pixels, data must be 32-bit aligned, and each scanline of data in the image must also be 32-bit aligned.

The buffer must remain valid throughout the life of the QImage. The image does not delete the buffer at destruction.

You need to implement your own way to delete that buffer

Answer 3

So you need to delete data yourself, but of course the trick is not to delete it too soon -- in particular, you don't want to delete it while the QImage object might still be using it. The easiest way to ensure that in your case is to delete it only after the QImage object has been destroyed:

void updateDisplay() {
   uchar *data = new ...; // array of pixel data
   ...
   {
      QImage image = QImage(data, width, height,
                      width, QImage::Format_Indexed8);

      pixmapItem->setPixmap(QPixmap::fromImage(image));
   }
   delete [] data;
}

(note the use of curly braces to create an inner scope, and thereby ensure that the QImage object gets popped off of the stack and destroyed before the delete [] data line executes!)

Of course an easier and safer approach would be to avoid the when-to-delete question altogether, by never manually allocating the array in the first place. Instead, let the QImage object allocate its own data array and just write into that instead:

QImage image(width, height, QImage::Format_Indexed8);
char * data = image.bits();
// write into (data) here if you want to, but don't delete [] data, ever!  
// instead, the QImage destructor will do any necessary deletes for you

Answer 4

You can subclass QImage with your own destructor that does the clean up.

class NativeBufferQImage : public QImage {
    uchar *data;

    // other stuff

public:
    ~NativeBufferQImage() {
        delete[] this->data; 
    }
};

Also note that since QImage is derived from QPaintDevice and QPaintDevice has a virtual destructor, so if someone delete your NativeBufferQImage by a pointer to its base class (i.e. QImage), your destructor will be called too.

Answer 5

The best way to do it is not to do it:

void updateDisplay() {
    QImage image(width, height, QImage::Format_Indexed8);
    auto const data = image.bits();
    // you can modify the data here
    pixmapItem->setPixmap(QPixmap::fromImage(image));
}