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

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" для нашего класса
  }
}

virtual void Tail (void) = 0
{
    // Базовые операции для всех классов
}

template <typename T, typename MemFun>
struct memfun_binder : std::unary_function<void, void>
{
    memfun_binder(T * obj, MemFun memfun)
        : obj_(obj)
        , memfun_(memfun)
    {}
 
    void operator()()
    {
        memfun_(obj_);
    }
 
    T      * obj_;
    MemFun & memfun_;
};
 
 
class Base {
    // ...
    template <typename Func>
    void Exec(Func tail_func) {
        // ...
        tail_func();
     }
};
 
template <typename T, typename MemFun>
memfun_binder<T, MemFun> memfun_bind(T * obj, MemFun memfun)
{
    return memfun_binder<T, MemFun>(obj, memfun);
}
 
class Derived : public Base {
    // ...
private:
    void tail1() { ... }
    void tail2() { ... }
 
public:
    void MyExec() {
        Exec(memfun_bind(this, std::mem_fun(&Derived::tail1)));
        Exec(memfun_bind(this, std::mem_fun(&Derived::tail2)));
    }
};

// Обработка события нажатия на кнопку Reload/Stop
void __fastcall
TWindowChart::ButtonClick (TObject *Sender)
{
    if (m_IsReloading)
    {
        // KillExecute - метод базового класса для прибития потока
        // Возвращает true, если поток убили, возвращает
        // false, если убить не получилось (к моменту начала прибития поток
        // сам завершился)
        // В любом случае отработает метод Execute3 (см. ниже).
        // Таким образом в конкретно данном случае результат, возвращённый
        // методом KillExecute нам не важен
        KillExecute();
    } else
    {
        ReloadImage();
    }
}
 
// Скачивание и отображение картинки
void
TWindowChart::ReloadImage (void)
{
    // StartExecute - метод базового класса. В процессе своего исполнения
    // он исполнит три метода (виртуальных): Execute1, Executre2 и Execute3.
    //
    // Execute1 исполнится в самом начале в главном процессе и имеет смысл
    // подготовки к исполнению потока. После исполнения данного метода
    // мы выйдем из StartExecute и главный процесс продолжит работать
    // (обрабатывать события) без тормозов
    //
    // Execute2 исполнится в потоке. Он будет исполняться параллельно
    // основному процессу и в этом методе нужно поместить "длительные"
    // действия (скачивание из инета). Пока этот поток тормозит об инет,
    // основной процесс может нормально реагировать на события (двигать
    // окошки и т.п.
    //
    // Execute3 будет исполнен в главном процессе после завершения потока
    // Вызовется этот метод через стандартную очередь сообщений
    // (т.е. наравне со всеми прочими событиями типа нажатия на кнопку)
    // При этом параметром будет передана причина завершения потока:
    // поток завершился самостоятельно, принудительно (через Kill) или
    // по таймауту 
    //
    // ВАЖНО!
    // __ВО ВРЕМЕНИ__ эти три метода исполняются последовательно.
    // Это позволяет не корячиться с синхронизацией для обращения
    // к полям данного класса (m_IsReloading в нашем примере)
    StartExecute (30);  // параметр - время таймаута
}
 
void
TWindowChart::Execute1 (void)
{
    // Подготовительные действия. Вычисляем URL картинки и т.п.
    ...
 
    // На кнопку наносим надпись "Stop"
    ...
 
    // Флажок, который определяет текущую реакцию на нажатие на кнопку
    m_IsReloading = true;
}
 
void __IN_THREAD__
TWindowChart::Execute2 (void)
{
    // Скачиваем данные из инета
    ...
}
 
void
TWindowChart::Execute3 (int reason)
{
    // Через параметр reason передаётся причина завершения потока
 
    // Если поток прервали принудительно, то отображать ничего не надо
    if (reason == "поток умер через Kill")
    {
        goto Finish;
    }
 
    // Если поток умер по истечении времени (таймауту), то выдадим ошибку
    if (reason == "поток умер по таймауту")
    {
        UserError ("таймаут");
        goto Finish;
    }
 
    // Поток успешно завершился
    // Проверяем ошибки: не удалось скачать данные с сервера, данные скачались,
    // но картинка оказалась битая и т.п. Рисуем картинку в случае успеха
    ...
 
  Finish:
    // Завершающие действия
    ...
 
    // На кнопку наносим надпись "Reload"
    ...
 
    // Флажок, который определяет текущую реакцию на нажатие на кнопку
    m_IsReloading = false;
}

typedef unsigned (__stdcall *PTHREAD_START)(void *);
 
#define chBEGINTHREADEX(psa, cbStack, pfnStartAddr,         \
                        pvParam, fdwCreate, pdwThreadID)    \
                        ((HANDLE) _beginthreadex(           \
                        (void *) (psa),                     \
                        (unsigned) (cbStack),               \
                        (PTHREAD_START) (pfnStartAddr),     \
                        (void *) (pvParam),                 \
                        (unsigned) (fdwCreate),             \
                        (unsigned *) (pdwThreadID)))
 
template <class ExecRoutine_, class Arg_>
class async_delegate : public unary_function<Arg_, DWORD>
{
public:
 
 
public:
 
                            async_delegate      ( ExecRoutine_ pStartAddr_)
                                : m_pExecFunc   ( pStartAddr_ ),
                                  m_hExecThread ( INVALID_HANDLE_VALUE )
                            {
                            }
 
public:
 
    virtual DWORD           operator()          (Arg_* arg1_)
    {
        DWORD  dwResult    = S_OK;
        HANDLE hExecThread = INVALID_HANDLE_VALUE;
 
        __try
        {
            if (m_hExecThread != INVALID_HANDLE_VALUE)
            {
                __leave;
            }
 
            m_hExecThread = chBEGINTHREADEX(NULL, 
                                            0, 
                                            m_pExecFunc,
                                            arg1_,
                                            0,
                                            NULL);
 
            if (hExecThread == INVALID_HANDLE_VALUE)
            {
                // Handle error
            }
 
        }
        __finally
        {
        }
        
        return dwResult;
    }
 
public:
            DWORD           Pause               ( void )
            {
                DWORD dwResult         = S_OK;
                DWORD dwExitCodeThread = EXIT_SUCCESS;
 
                __try
                {
                    dwExitCodeThread = Status();
 
                    if (dwExitCodeThread == -1)
                    {
                        dwResult = S_FALSE;
                        __leave;
                    }
 
                    if (dwExitCodeThread == STILL_ACTIVE)
                    {
                        dwResult = SuspendThread(m_hExecThread);
 
                        if (dwResult == (DWORD)-1)
                        {
                            dwResult = GetLastError();
                            __leave;
                        }
                    }
                    else
                    {
                        dwResult = dwExitCodeThread;
                        __leave;
                    }
                }
                __finally
                {
 
                }
 
                return dwResult;
            }
 
            DWORD           Resume              ( void )
            {
                DWROD       dwResult       = S_OK;
                DWORD       dwSuspendCount = 0;
                __try
                {
                    if (Status() == INVALID_HANDLE_VALUE)
                    {
                        __leave;
                    }
 
                    dwSuspendCount = ResumeThread(m_hExecThread);
 
                    if (dwSuspendCount == (DWORD)-1)
                    {
                        dwResult = GetLastError();
                        __leave;
                    }
                }
                __finally
                {
                }
                
                return dwResult;
            }
 
            DWORD           Stop                ( void )
            {
                DWORD dwResult         = S_OK;
                DWORD dwExitCodeThread = EXIT_SUCCESS;
                __try
                {
                    dwExitCodeThread = Status();
 
                    if (dwExitCodeThread == -1)
                    {
                        dwResult = S_FALSE;
                        __leave;
                    }
 
                    if (dwExitCodeThread == STILL_ACTIVE)
                    {
                        // Так делать нельзя
                        TerminateThread(m_hExecThread, ERROR_CANCELLED);
                    }
                    
                }
                __finally
                {
                    if (SUCCEEDED(dwResult))
                    {
                        m_hExecThread = INVALID_HANDLE_VALUE;
                    }
                }
 
                return dwResult;
            }
 
            DWORD           Status              ( void )
            {
                DWORD dwExitcodeThread = -1;
 
                __try
                {
                    if (m_hExecThread == INVALID_HANDLE_VALUE ||
                        !GetExitCodeThread(m_hExecThread, &dwExitcodeThread))
                    {
                        __leave;
                    }
                }
                __finally
                {
                }
 
                return dwExitcodeThread;
            }
private:
    ExecRoutine_        m_pExecFunc;
    HANDLE              m_hExecThread;
};

static unsigned __stdcall ThreadDummy ( void * arg_) // аргументом будет кортеж данных- аргументов функции
{
    __try
    {
        StartAddr(...);
    }
    __finally
    {
        ComplitionCallback();
    }
}