Design of classes containing different data - c++

Question

I'm currently learning C++ and for this I'm writing a simple image-converter.
I would like to have a base image class that contains different memorylayouts of the image, say DXTn or BMP.
How do I properly design my class that can contain these different datatypes?
Is there a better way of storing the memory in a (smart)pointer?
class Image
{
public:
void loadDXT() { }
void loadBMP() { }
private:
char* data1;
std::unique_ptr< char* > data2;
}
Or would it be better to derive a more specific classfrom a simple baseclass:
class baseImage
{
public:
enum imgType { BMP , DXT };
void load() = 0;
}
class BMPImage : public baseImage
{
//bmp specific stuff here
}
This isn't only specific to this imageclass, I'm in general curious how do I design classes that contain different data member.
Thank you.

Answer 1

I agree with jwg a virtual abstract interface would make your life easier.
For example:
class BaseImage//base class
{
public:
virtual void DoThingsRelatedToAllImages_1()=0;
virtual void DoThingsRelatedToAllImages_2()=0;
//...and so on and whatever else
private:
int DataUsedForAllImageTypes;
};
//this is our child class
class Bmp: public BaseImage
{
private:
int DataUsedOnlyForBmpTypeImages;
};
void Bmp::DoThingsRelatedToAllImages_1()
{
//Do Whatever this function should do for a bitmap
}
void Bmp::DoThingsRelatedToAllImages_2()
{
//Do Whatever this function should do for a bitmap
}
Just keep in mind than an abstract class cannot be instantiated because it has no implementation. If you go with a virtual class not an abstract class you in theory could have typeless image classes to work with if you needed it. all you would need to do is provide a basic implementation to your virtual class.
For example:
class BaseImage//base class
{
public:
virtual void DoThingsRelatedToAllImages_1();
virtual void DoThingsRelatedToAllImages_2();
//...and so on and whatever else
private:
int DataUsedForAllImageTypes;
};
void BaseImage::DoThingsRelatedToAllImages_1()
{
//Do Whatever this function should do for a base image
}
void BaseImage::DoThingsRelatedToAllImages_2()
{
//Do Whatever this function should do for a base image
}
//this is our child class
class Bmp: public BaseImage
{
private:
int DataUsedOnlyForBmpTypeImages;
};
void Bmp::DoThingsRelatedToAllImages_1()
{
//Do Whatever this function should do for a bitmap
}
void Bmp::DoThingsRelatedToAllImages_2()
{
//Do Whatever this function should do for a bitmap
}
Hopefully this was a helpful example.
I would also say that Template classes could be very useful but I will leave you to figure that out as I do not really want to go into that right now.
Good luck, Let me know if i can clarify anything i said.

Answer 2

I would say that the second method is definitely what you need. You are basically specifying an interface - what you would use an abstract class for in C++. The base class should contain all the functions that you think every image should be able to provide - probably as pure virtual functions since there is no 'general image' which implements these the same way for any image. (You might have things like common metadata which have the same structure for every image type, and these could be dealt with by methods in the base class.)
Then each class will implement the virtual functions based on its own private data stored in the way that makes sense for that type of image. If some image types share some, but not all operations, you could have several layers of inheritance, eg RasterImage inherits from Image and BMPImage and PNGImage inherit from RasterImage.
There are libraries around that do a lot of this stuff to permit rendering of graphs, vector objects, etc. into multiple formats. You probably don't want to use a big outside library since you are doing this to teach yourself, but you might like to look at how one is structured to get some ideas. (Note that some graphics libraries will justifiably have a much more complex and flexible structure then you probably want to imitate. If there are so many layers of abstraction and inheritance that you can't keep track of them, it might not be the best source to learn by example from.)