C++ error: no matching function for call to function template

Question

I have a function template that extracts data from an image and copies it to a smaller array (which I call a Patch ) the template function is called copyPatch . It is defined as:

template <class DestType, class SrcType, class Transformation>
bool copyPatch(Patch<DestType> &patch, 
               ImageData<SrcType>* src_data, 
               size_t src_ul_pix, 
               size_t src_ul_line)

Note: the Transformation parameter allows me to pass in a class that performs some transformation on the data. I call the template function as follows,

copyPatch<float, uint8_t, StraightCopy>(m_patch_data, m_data.t8u,
                                        ul_pix, ul_line)

where m_patch_data is of type Patch<float> and m_data.t8u is a member of a union defined as follows:

union {
    ImageData<uint8_t>*     t8u;
    ImageData<uint16_t>*    t16u;
    ImageData<int16_t>*     t16s;
    ImageData<uint32_t>*    t32u;
    ImageData<int32_t>*     t32s;
    // A bunch more of these
    void*               tvoid;
} m_data;

When I compile this I get the following error (that I've doctored a bit):

error: no matching function for call to:

copyPatch(Patch<float>&, ImageData<unsigned char>*&, size_t&, size_t&)’
copyPatch<float, uint8_t, StraightCopy>( m_patch_data, m_data.t8u, ul_pix, ul_line);
                                                                                          ^
note: candidate is:

template<class DestType, class SrcType, class Transformation> 

bool copyPatch(Patch<T>&, ImageData<SrcType>*, size_t, size_t)
template argument deduction/substitution failed:

To me, I don't see why the function didn't match. The only possible reason I can see is that for the 2nd parameter it wants a pointer (which is what I thought I was passing), but the calling code seems to be passing a reference to a pointer.

Compiler is g++ 4.8.1.

As pointed out in the comments the problem possibly with my Transformation (StraightCopy) which is defined as follows:

template<class Dest, class Src>
class StraightCopy {
public:
    Dest operator()(Src s) { return static_cast<Dest>(s); } 
};

I missed passing the parameters to my StraightCopy class.

Answer 1

Thanks to PlasmaHH for pointing me in the right direction. My transformation type (StraightCopy) needed parameters. So my call looks like:

copyPatch<float, uint8_t, StraightCopy< float, uint8_t > >( m_patch_data, m_data.t8u, ul_pix, ul_line);

Isn't that beautiful :o)