An object-oriented wrapper around function pointers

#include <stdexcept>

// ------------------------------------------------------------------
template <typename Class, typename Return, typename Arg1>
class Functor {
public:
  typedef Return (Class::*FunctionPointer)(Arg1);
  Functor() : object_(0), function_(0) {}
  Functor(Class* obj, FunctionPointer ptr) : object_(obj), function_(ptr) {}
  Return operator()(Arg1 arg1) const { 
    if(! (object_ && function_)) {
      throw std::runtime_error("XX");
    }
    return (object_->*function_)(arg1); 
  }

  void set (Class* obj) { object_ = obj; }
  void set (Functor::FunctionPointer ptr) { function_ = ptr; }

private:
  Class* object_;
  FunctionPointer function_;
};

class Test { ... };

typedef Functor<Test, int, const int&> Function;
// ...

void TestFunc3() {
  printf ("TestFunc3\n");
  Test t1, t2, t3;
  Test tests[] = { t1, t2, t3 };
  int nTest = sizeof(tests) / sizeof(tests[0]);

  Function::FunctionPointer funcs[] = { &Test::Add, &Test::Mul };
  int nFuncs = sizeof(funcs) / sizeof(funcs[0]);

  Function f;
  for (int i = 0; i < nTest; ++i) { 
    f.set (&tests[i]);                 
    for (int k = 0; k < nFuncs; ++k) { 
       f.set (funcs[k]);                 
       f(5);
    }
  }
}

2. Functor is polymorphic. You should mention that you can specify a base class as template argument and pass a derived object to the constructor:

typedef Functor <BaseClass, int, int> Function;
Function myadd (derivedObject, &Test::Add);

Hints to make Functor compile with VC++ 6.0:
- #include <stdexcept>
- void return types don't work with VC++ 6.0 (probably a compiler bug)
- templates must be inline (in VC++ 6.0), see: http://www.decadentplace.org.uk/womble/cplusplus/template-faq.html#vc6-non-inline-mem

I don't quite understand your rationale with respect to the one-argument
constructor (ie. Functor(Class* cls) : class_(cls), function_(NULL)) and operator=
(ie. operator=(typename Functor::FunctionPointer ptr)). I left them out in
my destilled version that now looks like this (default copy ctor and operator= are ok):

#include <stdexcept>

template <typename Class, typename Return, typename Arg1>
class Functor {
public:
  typedef Return (Class::*FunctionPointer)(Arg1);
  Functor() : object_(0), function_(0) {}
  Functor(Class* obj, FunctionPointer ptr) : object_(obj), function_(ptr) {}
  Return operator()(Arg1 arg1)  {
    if(! (object_ && function_)) {
      throw std::runtime_error("XX");
    }
    return (object_->*function_)(arg1); 
  }
private:
  Class* object_;
  FunctionPointer function_;
};

template <typename Class, typename Return, typename Arg1>
class FunctorConst {
public:  
  typedef Return (Class::*FunctionPointer)(Arg1) const;
  FunctorConst() : object_(0), function_(0) {}
  FunctorConst(const Class* obj, FunctionPointer ptr) 
     : object_(obj), function_(ptr) {}
  Return operator()(Arg1 arg1)  {
    if(! (object_ && function_)) {
       throw std::runtime_error("XX");
    }
    return (object_->*function_)(arg1); 
  }
private:
  const Class* object_;
  FunctionPointer function_;
};

I hope you find time to refactor code and article (keep it simple, don't boost the code).
It's a "Nice topic" and there's "a lot of room for improvement though" (Kevin Hall).

Best wishes,
Roland Pibinger

PS.: This has been my test code (compiles with VC++ 6.0, BCC 5.5, gcc 3.2(MingW)):

#include <stdio.h>
#include "functor.h"

class Test {
public:
 Test() : value_(0) {}

 int Add (const int& x) { printf ("Add\n"); value_ += x; return value_; }
 int Mul (const int& x) { printf ("Mul\n"); value_ *= x; return value_; }
 int Foo (const int& x) const { printf ("Foo\n"); return value_; } // const!
private:
 int value_;
};

typedef Functor<Test, int, const int&> Function;
typedef FunctorConst<Test, int, const int&> FunctionConst;

void DoSomething (int x, Function f) {f(x);}
void DoSomething (int x, FunctionConst f) {f(x);}

void TestFunc1() {
   printf ("TestFunc1\n");
   Test t1;
   Function myadd (&t1, &Test::Add);
   Function mymul (&t1, &Test::Mul);

   Function myfuncTest;

   DoSomething (5, myadd);
   DoSomething (5, mymul);
   
   Function myfunc (myadd);
   DoSomething (5, myfunc);
   myfunc = mymul;
   DoSomething (5, myfunc);
}

void TestFunc2() {
   printf ("TestFunc2\n");
   Test t2;
   FunctionConst myconst (&t2, &Test::Foo);

   DoSomething (5, myconst);

   FunctionConst myfuncConst;
   myfuncConst = myconst;
   DoSomething (5, myfuncConst);
}

int main() {
   TestFunc1();
   TestFunc2();

   return 0;
}