On Feb 22, 2:45 am, kwikius <a...@servocomm.freeserve.co.uk> wrote:
> On Feb 22, 1:27 am, Anja <anja.e...@googlemail.com> wrote:
>
>
>
> > Hi everyone,
>
> > I am using a third party library that uses templates quite heavily for
> > generalization. It is an image processing library and for example a
> > typical "Image" class has the following definition:
>
> > Image<PixelType, Dimensions>
>
> > The PixelType here represents the data type of the underlying
> > data...could be anything from chars to complex numbers and the
> > Dimensions are the dimensions of the image...which could be 2D to 4D
> > (3D and time).
>
> > Now, my problem is that I need to instantiate and store these
> > objects in my class. With non-templated objects it is trivial as
> > everything is known at compile time.
>
> > However, with this object, I do not know the PixelType and Dimensions
> > till run-time! So, I cannot, for example, have a member variable in a
> > class of the Image type. However, that is exactly what I need to do. I
> > need to create the image object and then later access this image
> > object and use its functions.
>
> > What design options do I have? I am pretty sure people have had this
> > problem before. What solutions can I choose from?
>
> <...>
>
> It depends on the Docs for your image type.
> My guess is that you are meant to supply your own types, but they will
> need to conform to some set of rules e.g interface or concept.
>
> Anyway wrapping different entities into one
> can be achieved by creating a wrapper, e.g lets call it pixel . pixel
> contains a pointer to an abstract base class, from where you can
> derive your actual own pixel types.
>
> IOW something like:
>
> template <
> typename PixelType,
> typename Dimensions
>
> struct Image
> {
> Image( Dimensions const & d)
> {
> }
>
> };
>
> // base class for real pixel types
> struct abc_pixel_type{
> virtual ~abc_pixel_type(){}
>
> };
>
> // various real pixel types
> struct col_pixel : abc_pixel_type{
> /****/
>
> };
>
> struct gray_pixel : abc_pixel_type{
> /****/
>
> };
>
> struct png_pixel : abc_pixel_type{
> /****/
>
> };
>
> // common wrapper for various pixels
> struct pixel{
>
> // somehow construct form real pixels...
> pixel(gray_pixel const & in)
> : m_pixel(new gray_pixel(in)){}
> pixel(png_pixel const & in)
> : m_pixel(new png_pixel(in)){}
> pixel(col_pixel const & in)
> : m_pixel(new col_pixel(in)){}
> ~pixel(){ delete m_pixel;}
> private:
> abc_pixel_type * m_pixel;
>
> };
>
> // wrap dimensions
> struct dimension{
> dimension(int x, int y): m_xvalue(x),m_yvalue(y){}
> private:
> int m_xvalue;
> int m_yvalue;
>
> };
>
> int main()
> {
> Image<pixel,dimension> my_image(dimension(1024,768));
>
> }
>
> However this will only be useful if you make sure you conform to the
> requirements of the image type of course ....
>
> regrads
> Andy Little

Hi,

Thanks for your reply. This is exactly my problem! In your example,
this statement:
> int main()
> {
> Image<pixel,dimension> my_image(dimension(1024,768));
>
> }

Say I needed to do this in a class function and created the object on
the heap and needed to store the pointer in a class variable. I am
stuck then!

Anja