基于基本功能的模板操作

Question

I have an interface IImage , which is derived by a template class CTypedImage , whith the pixel type as template argument.

class IImage
{
public:
    virtual ~IImage() {}
    ...

    static int IImage::ReadFile(IImage* &outImage, QString path, QString file);
};

template<class T>
class CTypedImage : public IImage
{
    ...
};

This way, I can just call:

IImage* image = nullptr;
int ret = IImage::ReadFile(image, path, file);

without knowledge of the underlying pixel type.

This piece of code is generic and may be used in many projects, so I don't want to implement specific processings in it.

Instead, I want to localy define the operations to apply on the data. The problem is that in my main code, I don't have acces to the type of pixel (and I don't want to handle it if it's not necessary), so I can't just call

OperationOnData<type_of_pixel>(image);

I tried with this idea:

• Adding a function CallOperation to the interface IImage :

   virtual int CallOperation(class IOperation* op) = 0; 

  with

   class IOperation { public: virtual ~IOperation() {} virtual int Apply(IImage* img) = 0; }; 

• Define the specific operations locally:

   template<class T> class MyOperation: public IOperation { public: MyOperation() {} ~MyOperation() {} int Apply(IImage* img); }; template<class T> int MyOperation::Apply(IImage* img) { /* do things with pixels of type T */ } 

• Call the operation with the type as a template argument::

   template<class T> int CTypedImage<T>::CallOperation(IOperation* op) { if (op == nullptr) return -1; return op->Apply<T>(this); } 

But all the variations I tried around this idea did not work, either because it did not compile (for example because I can't have a virtual fonction in a template) or it doesn't use the derived Apply function.

I tried different syntaxes, but I can't find a way to achieve what I want.

Any help will be greatly appreciated, even telling me I need to rewrite all the thing.

Answer 1

Add an accept virtual function to your CTypedImage like this:

template<class T>
class CTypedImage : public IImage
{

    ...
   virtual void accept(IOperation *operation)
   {
       operation->Apply(this) ;
   }
};

Your operation then will be defined like this:

class IOperation
{
public:
    virtual ~IOperation() {}
    virtual int Apply(CTypedImage<char> * img) = 0; // one function for every kind of pixel
    virtual int Apply(CTypedImage<short> * img) = 0; // a typelinst could be handy 
                            // while defining the type set but that's another story
};

A concrete operation may be defined like this

class MyIOperation : public Operation
{
public:
    virtual ~IOperation() {}
    virtual int Apply(CTypedImage<char> * img) 
    {                      // forward to generic implementation
        ApplyT(img) ;      // note: image type is known here 
    }
    virtual int Apply(CTypedImage<short> * img) 
    { ApplyT(img) ;}      

    template <class T>
    int ApplyT(CTypedImage<T> * img)
    { 
        // generic implementation
    }
};

So given a pointer to an operation and a generic image you can apply the operation like this

IOperation *operation ;
IImage *image ;

image->accept(operation) ;

This is an application of the visitor pattern , where the operation act as visitor.