c++ handling function pointer across super/base class - c++

Question

I have a template defined class that handles processing of all the different methods. these methods vary or can be grouped based on type of execution im doing. so I am going to inherit the super class processing attributes but define all the different methods that needs to be processed.
I have function pointer mismatch error. could anyone suggest a solution for this issue
template <class T_ENUM>
class Injection
{
public:
Injection();
~Injection();
virtual void addAllCalls( void );
bool addCall( T_ENUM );
protected:
void* data; // drive of device under test
struct call_info {
T_ENUM call_ref;
string time_stamp;
};
// class specific function pointer defenition
// call_status_s is defined struct
typedef void (Injection::*funcType)(call_status_s*);
// map contains all calls initialized and ready to be processed
std::map<T_ENUM, funcType> func_call_map;
// here i process the function pointer based on the T_ENUM
bool processCall ( T_ENUM );
virtual void initCallMap( void );
// initialise the functions taken from child class and store here
};
class Type_Injection : public Injection<enum_defined_for_Type> {
public:
void addAllCalls( void );
private:
void initCallMap ( void );
// would initialise func_call_map with the functions pointer of TypeFunction1
// this is the function im going to save as pointers in the list defined in super class
void TypeFunction1 ( call_status_s* );
};
compile error:
error: cannot convert ‘void (Type_Injection::*)(call_status_s*)’ to
‘void (Injection<enum_defined_for_Type>::*)(call_status_s*)’ in
assignment
Again sorry could not add the complete code.

Answer 1

This isn't typesafe, because you have a (hidden) covariant parameter.
The actual function Type_Injection::TypeFunction1 requires a this argument of type Type_Injection. But the call site is only providing an Injection<enum_defined_for_type> and not every instance of the latter actually is one of the former.
It may be that the actual parameter always is of the more derived type, in which case you can use a cast to override the compiler type checking. But I would just use std::function<void (call_status_s*)> instead, and use std::bind when adding the callbacks to the map to specify the target object (assuming that the target object is always the class instance holding the map, and does not vary at call time).
typedef std::function<void (call_status_s*)> funcType;
// map contains all calls initialized and ready to be processed
std::map<T_ENUM, funcType> func_call_map;
void Type_Injection::initCallMap ( void ) override
{
using std::placeholders::_1;
func_call_map[T_ENUM_FUNCTION1] = std::bind(&Type_Injection::TypeFunction1, this, _1);
}
In your particular case, another option is just to make your processCall function that takes in the T_ENUM selector virtual (shouldn't it also accept the call_status_s* function argument to pass to the function being called?). In the derived class, you can use a switch statement to map T_ENUM values to functions in the derived class. This is very efficient, perfectly typesafe, and can delegate to the base class when the value doesn't match/isn't known, to allow different behaviors to be implemented in different levels of the class hierarchy. Unlike a map this only allows lookup, so if iteration is a requirement the map of std::function would be a better option.
Another option is the "Curiously Recurring Template Pattern", which allows the derived class to inform the base class of the real type of the object, so that the map can contain void (DerivedType::*)(call_status_s*) function pointers. But this removes the ability to have behaviors provided at multiple levels of the call tree.