Passing a non-template function pointer into a template method - c++

Question

I've searched through Google and stackoverflow and was unable to find something that addresses this situation:
I have a template with a method that takes a function pointer.
The function pointer itself is NOT a template, it's a normal function pointer.
The function pointer, however, has the template args used in its parameters
File name: otherclasses.h
// This class is used as the template parameter
class B
{
public:
B() {}
~B() {}
int getVal() const { return val; }
void setVal(int v) { val = v; }
private:
int val;
};
// This is just a static function
class A
{
public:
static bool someStaticFunction(const B* left, const B* right);
};
inline
bool
A::someStaticFunction(
const B* left,
const B* right)
{
return left->getVal() < right->getVal();
}
File name: templateheader.h
#include "otherclasses.h"
template<typename T>
class theTemplate
{
public:
void insert(T val1, T val2)
{
stuff[0] = val1;
stuff[1] = val2;
}
bool usesSomeStaticFunction(bool (*funcp)(const T, const T))
{
// will return true
return funcp(stuff[0],stuff[1]);
}
private:
T stuff[2];
};
File name: main.cpp
#include "otherclasses.h"
#include "templateheader.h"
#include <stdio.h>
int main()
{
theTemplate<B*> foo;
printf("%d\n", foo.usesSomeStaticFunction(A::someStaticFunction));
return 0;
}
The error from Visual Studio:
error C2664: 'theTemplate<T>::usesSomeStaticFunction' : cannot convert
parameter 1 from 'bool (__cdecl *)(const B *,const B *)' to
'bool (__cdecl *)(const T,const T)'
with
[
T=B *
]
None of the functions with this name in scope match the target type
Two ways around this problem:
Use const void* instead of const T*
Remove const from the parameters of the function pointer and anything that uses it.
Thanks for your help
UPDATE
Turns out there's a better solution - just move the const to the right of B* in the static function:
File name: otherclasses.h EDITED
// This class is used as the template parameter
// This is unchanged.
class B
{
public:
B() {}
~B() {}
int getVal() const { return val; }
void setVal(int v) { val = v; }
private:
int val;
};
// This is just a static function
// This is changed
class A
{
public:
// The "const" is moved to the right side of B*
static bool someStaticFunction(B* const left, B* const right);
};
// This is changed
inline
bool
A::someStaticFunction(
// The function definition must match the function prototype...
B* const left,
B* const right)
{
return left->getVal() < right->getVal();
}

Answer 1

This is because const T becomes T* const, not T const*. One solution is to rework your code to not include the pointer in T (T = B) and include it in the template class instead:
template<typename T>
class theTemplate
{
public:
void insert(T* val1, T* val2)
{
stuff[0] = val1;
stuff[1] = val2;
}
bool usesSomeStaticFunction(bool (*funcp)(const T*, const T*))
{
// will return true
return funcp(stuff[0],stuff[1]);
}
private:
T* stuff[2];
};