Использование указателя на метод вместо виртуального метода

class Base
{
  void Exec (void)
  {
    // общие действия
    ...
 
    // конкретные действия для производных классов
    Tail ();
  }
 
  virtual void Tail (void) = 0;
};
 
class Derived : public Base
{
  void MyExec (void)
  {
    // В процессе исполнения будет исполнен виртуальный метод Tail
    Exec ();
  }
 
  virtual void Tail (void)
  {
    // Определяем конкретные действия для нашего класса
  }
}

class Base
{
  void Exec (void (Base::*tail)(void))
  {
    // общие действия
    ...
 
    // конкретные действия для производных классов
    // здесь уже через указатель  на метод
    (this->*tail) ();
  }
};
 
class Derived : public Base
{
  void MyExec (void)
  {
    // Выполняем основные действия с двумя разными типами
    // частных действий. Необходимую операцию преобразования
    // указателя на метод опускаю, чтобы глаза не резало
    Exec (Tail1);
    Exec (Tail2);
  }
 
  void Tail1 (void)
  {
    // Определяем конкретные действия "вариант1" для нашего класса
  }
 
  void Tail2 (void)
  {
    // Определяем конкретные действия "вариант2" для нашего класса
  }
}

 void MyExec (void)
  {
    // Выполняем основные действия с двумя разными типами
    // частных действий. Вызов сути эквивалентен
    // "Exec (&this->Tail1)" и в closure-указатель копируется
    // this и адрес метода Tail1
    Exec ();
    Tail1();
    Exec ();
    Tail2();
  }

 void Tail1 (void)
  {
     Exec();
    // Определяем конкретные действия "вариант1" для нашего класса
  }

 void Tail1 (void)
  {
     Exec();
    // Определяем конкретные действия "вариант1" для нашего класса
  }

A a;
a.Exec( A::Tail );
 
B b;
a.Tail();

void BlackBox (void *this, void (*method)(void))
{
  ...
}
 
class A
{
  ...
  void func1 (void);
  void func2 (void);
};
 
class B
{
  ...
  void func1 (void);
  void func2 (void);
};
 
...
A a;
B b;
 
// Нужно, чтобы в конечном итоге как бы вызвалось a.func1()
BlackBox (&a, &A::func1);
 
// Нужно, чтобы в конечном итоге как бы вызвалось a.func2()
BlackBox (&a, &A::func2);
 
// Нужно, чтобы в конечном итоге как бы вызвалось b.func1()
BlackBox (&b, &B::func1);
 
// Нужно, чтобы в конечном итоге как бы вызвалось b.func2()
BlackBox (&b, &B::func2);
...

 void func1 (void)
{
        BlackBox( this );
        ...
}

class Base
{
public:
       virtual void Exec() = 0;
};
 
template<class T>
class Functor : public Base
{
public:
      T * obj;
      void Exec()
      {
           obj->func1();
      }
};

void BlackBox( Base * ptr )
{
     // какой-то код
     ptr->Exec();
}
 
// Какой-то класс с методом func1.
class MyClass;
 
MyClass a;
Functor<MyClass> f;
BlackBox(&f );

class UserForm : public LibForm
{
  ...
 
  void UserGetImage (void)
  {
    LibStartThread (UserDownloadImage, UserDisplayImage);
  }
 
  void UserDownloadImage (void)
  {
    // Скачивание картинки (в потоке)
  }
 
  void UserDisplayImage (void)
  {
    // Отрисовка картинки (в главном процессе)
  }
}

// Интерфейс функтора. Ничего не знает о классах A,B и любых других.
class FunctorBase
{ public:
        virtual void Execute() = 0;
};
 
// Никаких шаблонов нету.
void BlackBox( FunctorBase * f )
{
        // Твой код
        // Под конец выполняем функтор
        f->Execute();
}
 
// другой файл/модуль/пофиг
// 
template<class T>
class Functor : public FunctorBase
{
public:
      Functor( T * t )
      : obj(t)
      {}
 
      void Execute()
      {
            obj->func1();
      }
 
       T * obj;
};
 
// Пользовательские классы. Ничего не знают о FunctorBase и Functor  и BlackBox
class A
{
public:
      void func1();
};
class B;
class C
{
public:
         void func1();
         void func2();
};
 
template<>
void Functor<C>::Execute()
{
     obj->func1();
     obj->func2();
}
 
void main()
{
      A a;
      B b;
      C c;
 
      Functor<A> fa(&a);
      Functor<B> fb(&b);
      Functor<C> fc(&c);
 
      BlackBox( &fa );
      BlackBox( &fb );
      BlackBox( &fc );
 
}