Вызов правильной свободной функции из базового указателя/ссылки

Может быть, шаблон Brigde может вам помочь.

Этот шаблон можно использовать, когда вы хотите избежать постоянной привязки между абстракцией и ее реализацией.

(Я не вижу вашего комментария о вашем ограничении использования С++ 11, но вы можете удалить ключевые слова std::unique_ptr, std::move и override)

class AppSpecificImp
{
public:
   virtual void DoWork() = 0;
};

class Base 
{ 
public:
   virtual ~Base() throw(); 

   virtual DoWork() = 0;
};

class DerivedA : public Base 
{ 
public:
   DerivedA(std::unique_ptr<AppSpecificImp> appImp)
      : imp(std::move(appImp))
   {
   }

   void DoWork() override
   {
       // DerivedA specific code 

       imp->DoWork();
   }

private:
   std::unique_ptr<AppSpecificImp> imp;
};

class DerivedB : public Base 
{ 
public:
   DerivedB(std::unique_ptr<AppSpecificImp> appImp)
      : imp(std::move(appImp))
   {
   }

   void DoWork() override
   {
       // DerivedB specific code 

       imp->DoWork();
   }

private:
   std::unique_ptr<AppSpecificImp> imp;
};

Изменить, чтобы показать использование шаблона посетителя:

С шаблоном посетителя вы можете делать то, что хотите, но с большим усилием.

class Visitor
{
public:
   virtual void VisitDerivedA(DerivedA* object) = 0;

   virtual void VisitDerivedB(DerivedB* object) = 0;
};

class Base
{
public:
   virtual void Visit(Visitor* visitor) = 0;
};

class DerivedA : public Base 
{ 
public:
   virtual void Visit(Visitor* visitor)
   {
       visitor->VisitDerivedA(this);
   }
};

class DerivedB : public Base 
{ 
public:
   virtual void Visit(Visitor* visitor)
   {
       visitor->VisitDerivedB(this);
   }
};

class AppSpecificVisitor : public Visitor
{
public:
   void VisitDerivedA(DerivedA* object)
   {
       // Do any work related to DerivedA class
   }

   void VisitDerivedB(DerivedB* object)
   {
       // Do any work related to DerivedB class
   }
}


int main()
{
    AppSpecificVisitor myVisitor;

    Base* myBase = // any class in your hierarchy

    myBase->Visit(&myVisitor);
}

Как я уже сказал в комментариях, с помощью шаблона посетителя вы можете добавлять новые функции без изменения основной иерархии (базовые-> производные типы). Вы просто определяете новую реализацию посетителя и пишете свою логику для каждого класса в основной иерархии. В вашем примере вы можете упаковать конкретную логику приложения в объект и ссылаться на нее в своих производных объектах, что является более простым подходом.

Почему бы не использовать новый набор иерархий для конкретной реализации приложения?

class AppBase
{
public:
    virtual ~AppBase() throw();
    virtual void work_with_app() = 0;
};

class Base
{
public:
    Base(AppBase& app) : m_app(app) {}
    virtual ~Base() throw();
protected:
    AppBase& m_app;
};

class DerivedA : public Base { DerivedA(AppBase& app) : Base(app) {} };

class DerivedB : public Base { DerivedA(AppBase& app) : Base(app) {} };

// Application specific implementation :
class AppLuaSpecific : public AppBase
{
public:
    void work_with_app()  { /* Lua app specific */ }
};

Таким образом, ваша 1-я иерархия: Base, DerivedA, DerivedB может жить, ничего не зная о конкретном коде приложения, реализованном в AppLuaSpecific.

Вы можете реализовать свою собственную отправку для конкретного приложения следующим образом (проверьте ее вживую на Coliru) :

#include <iostream>
#include <typeinfo>


struct Base { virtual ~Base() {} };

struct DerivedA : public Base { };

struct DerivedB : public Base { };

namespace AppSpecific
{

template<class F>
void dispatch(const Base& b)
{
    const std::type_info& t = typeid(b);
    if ( t == typeid(DerivedA) )
        F::doit(static_cast<const DerivedA&>(b));
    else if ( t == typeid(DerivedB) )
        F::doit(static_cast<const DerivedB&>(b));
}

struct Foo
{
    static void doit(const DerivedA& da) { std::cout << "Foo(DerivedA)\n"; }
    static void doit(const DerivedB& db) { std::cout << "Foo(DerivedB)\n"; }
};

struct Bar
{
    static void doit(const DerivedA& da) { std::cout << "Bar(DerivedA)\n"; }
    static void doit(const DerivedB& db) { std::cout << "Bar(DerivedB)\n"; }
};

} // namespace AppSpecific

int main()
{
    DerivedA da;
    DerivedB db;

    Base& b1 = da;
    Base& b2 = db;
    AppSpecific::dispatch<AppSpecific::Foo>(b1);
    AppSpecific::dispatch<AppSpecific::Foo>(b2);
    AppSpecific::dispatch<AppSpecific::Bar>(b1);
    AppSpecific::dispatch<AppSpecific::Bar>(b2);
}