4 Functors to encapsulate C and C++ Function Pointers
4.1 What are Functors ?
Functors are functions with a state. In C++ you can realize them as a class with one or more private members
to store the state and with an overloaded operator6 () to execute the function. Functors can encapsulate C and
C++ function pointers employing the concepts templates and polymorphism. You can build up a list of pointers
to member functions of arbitrary classes and call them all through the same interface without bothering about
their class or the need of a pointer to an instance. All the functions just have got to have the same return-
type and calling parameters. Sometimes Functors are also known as Closures. You can also use Functors to
implement callbacks.
4.2 How to Implement Functors ?
First you need a base class TFunctor which provides a virtual function named Call or a virtually overloaded
operator () with which you will be able to call the member function. It’s up to you if you prefer the overloaded
operator or a function like Call. From the base class you derive a template class TSpecificFunctor which
is initialized with a pointer to an object and a pointer to a member function in its constructor. The derived
class overrides the function Call and/or the operator () of the base class: In the overrided versions
it calls the member function using the stored pointers to the object and to the member function.
//-----------------------------------------------------------------------------------------
// 4.2 How to Implement Functors
// abstract base class
class TFunctor
{
public:
// two possible functions to call member function. virtual cause derived
// classes will use a pointer to an object and a pointer to a member function
// to make the function call
virtual void operator()(const char* string)=0; // call using operator
virtual void Call(const char* string)=0; // call using function
};
// derived template class
template <class TClass> class TSpecificFunctor : public TFunctor
{
private:
void (TClass::*fpt)(const char*); // pointer to member function
TClass* pt2Object; // pointer to object
6If you prefer you can also use a function called Execute or something like that.
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
TSpecificFunctor(TClass* _pt2Object, void(TClass::*_fpt)(const char*))
{ pt2Object = _pt2Object; fpt=_fpt; };
// override operator "()"
virtual void operator()(const char* string)
{ (*pt2Object.*fpt)(string);}; // execute member function
// override function "Call"
virtual void Call(const char* string)
{ (*pt2Object.*fpt)(string);}; // execute member function
};