Question

I need some design suggestions for an Image class hierarchy.
Currently, I have 2 types of images (one is a standard image, the second doesn’t contain standard image data).
Sometimes I want the object to allocate the memory for the image data, and other times I just want it to point to it.

The problem arises when I want to give TypeA images specific functionality.
If TypeA images inherit from Image, I will have to duplicate the functionality of the Allocated vs. non-Allocated Image.

I’m sure there is a better way to do this, I remember some elegant solutions with mixins during university, but can’t find a way to use that here.

My current design looks like:

class Image
{
public:
Image(int width, int height, int bpp);
virtual ~Image() {};
    // getters

    template <typename T>                                  
    T* ptr() { return reinterpret_cast<T*>(m_imageData); } // T depends on bpp

 protected:
    // metadata
    char* m_imageData;
};

class AllocImage : public Image
{
public:
    AllocImage(int width, int height, int bpp, DataType dataType) :
        Image(width, height, bpp, dataType)
    {
        m_imageData = new char[m_dataSize];
    }

    ~AllocImage()
    {
        delete m_imageData;
    }
};

class ImageHolder : public Image
{
public:
    ImageHolder(int width, int height, int bpp, DataType m_dataType);

    void setPtr(const void* ptr);
};

class AllocatedImageTypeA : public AllocImage
{
public:
    // Type A specific methods
};

class NonAllocatedImageTypeA : public ImageHolder
{
public:
    // duplicated Type A specific methods
};

Answer 1

If all the differences are constrained to how the image is held (allocated or not), you could use the policy model.

The short explanation is that you would pass a policy object to the image, where the policy describes whether you need to deallocate the image or not, how to access it, etc., basically anything that relates to the differences that arise from how the image data is held (allocated vs. pointed). Then all your access to the image will be through the policy.

For example, instead of writing

delete image;

You would write:

policy.del(image);

Where policy.del can be a delegate to delete or a no-op, depending on the actual type of the policy (that is in line with what the image requires)