On Mon, 04 Aug 2003 19:27:23 -0400, dcipher <jw****@neuraldk.org>
wrote:
I'm in the process of rewritting my graphics library to be purely OO using
C++.
The following is a section of my heirarchy of classes:
PImage // defines all basic graphics routines as virtual functions
PImage8 // implements those routines for 8bpp
PImage15 // and for 15bpp
PImage16 // and 16bpp
PImage24 // and so on...
PImage32
What I would now like to do is define even more specific classes such as
X11Image, but instead of having to define X11Image8 ... X11Image32, I'm
wondering if it's possible to do something like the following:
class X11Image : public PImage {
X11Image() {
switch(bpp) {
case 8:
// set all virtual methods to those of PImage8, eg:
// putPixel = &PImage8::putPixel
// this doesn't work, however... is there a way to do this?
break;
case 15:
// set all virtual methods to those of PImage15
break;
// and so on...!
}
}
}
Do your X11Image classes override any methods of PImage?
It sounds like you are trying to place two orthogonal things into the
same class heirarchy, which is a design error. Your X11 stuff is
presumably specific to X11 graphics, and this is orthogonal to how
many bits per pixel are in an image. So you need two separate
heirarchies, something like this:
PImage // defines all basic graphics routines as virtual
PImage8 // implements those routines for 8bpp
PImage15 // and for 15bpp
PImage16 // and 16bpp
PImage24 // and so on...
PImage32
Now, you want a separate heirarchy giving the operations you can
perform on an different heirarchy, say:
GraphicsSystem
X11
OpenGL
or whatever. Then your PImage implementations can contain a pointer to
a GraphicsSystem, and use this pointer to do the basic, bit depth
independent operations.
The precise breakdown depends on the the details of what PImage is,
but whatever you do, remember that composition is generally much more
powerful than inheritence. Break down the problem into abstract
classes with fewer responsibilities, and then compose them together
into more fully featured classes, even classes with no virtual
methods. e.g.
class PImage
{
GraphicsSystem* m_graphicsSystem;
BitDepthDependentAlgorithms* m_bppAlgo;
CoordinateTransformation* m_transform;
ImageStorage* m_storage;
int m_width;
int m_height;
public:
//implement methods using the composite parts
//no need for virtual functions, since
//behaviour can be changed by different
//subparts.
};
Tom