class obj
{
public:
  virtual int foo (int) = 0;    
};

class A : public obj;
class B : public obj;
...

/* returns A is config have 'a', B is 'b', and so on */
obj * getfromconfig (const char *filename);

int
entry (obj *x)
{
  return x->foo();
}

int
main (void)
{
  return entry (getfromconfig("my.xml"))
}

/* returns A if config have 'a', B is 'b', and so on */
obj * 
getfromconfig (const char *filename)
{
  fstream f (filename, ios_base::in);
  if (existsin (f, 'a'))
    return new A();
  if (existsin (f, 'b'))
    return new B();
  ...
}

struct obj
{
public:
  virtual int foo () = 0;  
};

struct A : public obj
{
    virtual int foo () {std::cout<<"FOO::A"<<std::endl; return 0;} 
};

struct B : public obj
{
    virtual int foo () {std::cout<<"FOO::B"<<std::endl; return 0;} 
};

template<typename T>
struct entryByFile: public T
{
    int entry() 
    {
        return T::make()->foo();
    }
};

struct fileA 
{
    obj* make() {return new A;}
};

struct fileB
{
    obj* make() {return new B;}
};

int
main (void)
{
    return entryByFile<fileB>().entry();
}

struct obj
{
public:
  virtual int foo () = 0;  
};

template<typename T>
struct entryByFile: public T
{
    int entry() 
    {
        return T::foo();
    }
};

struct fileA 
{
    int foo() {std::cout<<"DO something"<<std::endl; return 0;}
};

struct fileB
{
    int foo() {std::cout<<"DO nothing"<<std::endl; return 0;}
};

int main() 
{
    return entryByFile<fileB>().foo();
}

T>class obj
T>{
T>public:
T>  virtual int foo (int) = 0;    
T>};

T>class A : public obj;
T>class B : public obj;
T>...

T>/* returns A if config have 'a', B is 'b', and so on */
T>obj * 
T>getfromconfig (const char *filename)
T>{
T>  fstream f (filename, ios_base::in);
T>  if (existsin (f, 'a'))
T>    return new A();
T>  if (existsin (f, 'b'))
T>    return new B();
T>  ...
T>}

T>int
T>entry (obj *x)
T>{
T>  return x->foo(); // тут, кситати, не верно метод вызываешь, или неверно описал я  :xz: 
T>}

T>int
T>main (void)
T>{
T>  return entry (getfromconfig("my.xml"))
T>} 
T>

template<typename TObj> int entry( TObj* obj ) { return obj->foo(); }
int
main (void)
{
   const char *filename = "my.xml";
  fstream f (filename, ios_base::in);
  if (existsin (f, 'a'))
    return entry( new A );
  if (existsin (f, 'b'))
    return entry( new B );
  ...
}

struct Base
{
    void foo()
    {
        std::cout << "doNothing" << std::endl;
    }
};
struct A:Base
{
    void foo()
    {
        std::cout << "A" << std::endl;
    }
};
struct B:Base
{
    void foo()
    {
        std::cout << "B" << std::endl;
    }
};
template<typename _Type>
struct RttiEntry
{
    static const int kind = -1; //never hit
    typedef Base Type;
};
template<int kind>
struct InverseRttiEntry
{
    typedef RttiEntry<void> RttiEntryR;
};

template<>
struct RttiEntry<A>
{
    static const int kind = 0xA;
    typedef A Type;
};
template<>
struct RttiEntry<B>
{
    static const int kind = 0xB;
    typedef B Type;
};
template<>
struct InverseRttiEntry<RttiEntry<A>::kind>
{
    typedef RttiEntry<A> RttiEntryR;
};
template<>
struct InverseRttiEntry<RttiEntry<B>::kind>
{
    typedef RttiEntry<B> RttiEntryR;
};

template<int, typename Type>
struct ComparativeCaller:Base{
    void foo(Base* base)
    {
        return base->foo();
    };};
template<>
struct ComparativeCaller<0, A>
{
    void foo(Base* base)
    {
        return ((A*)base)->foo();
    }
};
template<>
struct ComparativeCaller<0, B>
{
    void foo(Base* base)
    {
        return ((B*)base)->foo();
    }
};


template<int kind>
struct Interface:Interface<kind-1>
{
    void foo(int argKind, Base* base)
    {
        if(kind == argKind)
        {
           ComparativeCaller<0, typename InverseRttiEntry<kind>::RttiEntryR::Type>().foo(base);
        }
        else
        {
            Interface<kind-1>::foo(argKind, base);

        }
    }
};
template<>
struct Interface<0>
{
    void foo(int kind, Base* base)
    {
        std::cout << " not implemented " << std::endl;
    }
};


int main() {
    Interface<0xF> rttiInterface;
    A a;
    B b;

    rttiInterface.foo(RttiEntry<A>::kind, &a);
        rttiInterface.foo(RttiEntry<B>::kind, &b);
        rttiInterface.foo(1, &a);

    return 0;}

struct Entry // чтобы с шаблонами меньше возиться, сделаем дженерик для бедных - конечный тип с полиморфизмом внутри
{
  template<class T> void operator()(T* obj) const { ... }
};

template<class K> void getfromconfig(const char* filename, K kont)
{
  .....
  kont(new A());
  .....
  kont(new B());
  .....
}

int main()
{
  getfromconfig(filename, Entry());
}

PolymorphResult foo(Args...);
void foo(Args..., PolymorphResult& res);
void foo(Args..., function<PolymporphResult&> kont);
void foo(Args..., PolymorphFunction kont);

int entry (obj *, obj *);
...
entry (getfromconfig("my.xml"), getfromconfig("his.xml"))

T>int entry (obj *, obj *);
T>...
T>entry (getfromconfig("my.xml"), getfromconfig("his.xml"))
T>

int res;
getfromconfig("my.xml", [&](auto my) {
  getfromconfig("his.xml", [&](auto his) {
    res = entry(my,his);
  })
});

#include <cstdio>
#include <vector>

#include <functional>
using namespace std;
using namespace std::placeholders;


// семейство типов ABCD

void show(char x) { printf("%c ", x); }

struct A { int      foo() { show('A'); return 1; } } const a;
struct B { unsigned foo() { show('B'); return 2; } } const b;
struct C { long     foo() { show('C'); return 3; } } const c;
struct D { double   foo() { show('D'); return 4; } } const d;

// все наши полиморфные функции будут иметь первоклассный фиксированный тип

struct getconfig_t // void g(char,K)
{
    template<class K> // где K имеет сигнатуру void f(ABCD)
    void operator()(char t, K kont) const
    {
        switch(t)
        {
        case 'a': kont(A()); break;
        case 'b': kont(B()); break;
        case 'c': kont(C()); break;
        case 'd': kont(D()); break;
        default:  printf("exception %c\n", t); break; // исключение состоит в том, чтобы не вызывать продолжение :)
        }
    }
} const getconfig;

struct entry_t // void e(ABCD,ABCD,K)
{
  template<class T1, class T2, class K> // где T1 и T2 это ABCD, а K имеет сигнатуру void f(NUM)
  void operator()(T1 t1, T2 t2, K kont) const
  {
    kont(t1.foo()*10 + t2.foo()); // будем изучать правила продвижения числовых типов
  }
} const entry;

struct finish_t // void f(NUM)
{
    void operator()(int           n) const { printf("int    %d\n",  n); }
    void operator()(unsigned      n) const { printf("uint   %u\n",  n); }
    void operator()(long          n) const { printf("long   %ld\n", n); }
    void operator()(unsigned long n) const { printf("ulong  %lu\n", n); }
    void operator()(double        n) const { printf("double %g\n",  n); }
} const finish;



// протектор, аналогичный boost::protect
// (его нет в стандартной библиотеке, поэтому пришлось стырить из интернета рецепт)

template<typename T>
struct protect_wrapper : T
{
    protect_wrapper(const T& t) : T(t)
    {

    }

    protect_wrapper(T&& t) : T(std::move(t))
    {

    }
};

template<typename T>
typename std::enable_if< !std::is_bind_expression< typename std::decay<T>::type >::value,
                T&& >::type
protect(T&& t)
{
    return std::forward<T>(t);
}

// нам потребуется только эта ветка
template<typename T>
typename std::enable_if< std::is_bind_expression< typename std::decay<T>::type >::value,
                protect_wrapper<typename std::decay<T>::type > >::type
protect(T&& t)
{
    return protect_wrapper<typename std::decay<T>::type >(std::forward<T>(t));
}

// устойчивая идиома: изоляция bind-выражения

template<class... Args>
auto probind(Args... args) -> decltype(protect(bind(args...))) { return protect(bind(args...)); }



// карринг двухместной функции

struct curry_t
{
    template<class F, class X>
    auto operator()(F&& f, X&& x) const -> decltype( probind(f,x,_1) ) { return probind(f,x,_1); }
} const curry;

// комбинируем!

void run(char x, char y)
{
    // кирпичики: продолжения
    auto g = protect(bind(getconfig, x, _1));  // void(K)
    auto h = protect(bind(getconfig, y, _1));  // void(K)
    auto e = protect(bind(entry, _1, _2, _3)); // void(ABCD,ABCD,K)
    // последний кирпичик - без продолжения
    auto f = finish;

    // комбинации
    auto fe   = probind(e,_1,_2,f);
    auto feh  = probind(h, bind(curry,fe,_1));
    auto fegh = probind(g, feh);

    // запускаем
    fegh();
}

int main()
{
    vector<char> abcd = { 'a','b','c','d','e' };
    for(auto x : abcd)
        for(auto y : abcd)
            run(x,y);
}