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"))
}

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);

constexpr auto foo()
{
    while(true);
    return true;
}

int main()
{
    constexpr auto x = foo();
}

#include <iostream>

template<class T>
class obj
{
  public:
    int foo () { return 0; }
};


class file1_xml { public: const char* name() {return "file1_xml"; } };
class file2_xml { public: const char* name() {return "file2_xml"; } };

template<>
class obj<file1_xml>
{
  public:
    int foo () { file1_xml f; fopen(f.name(), "r"); /*do something*/ return 1; }
};


template<>
class obj<file2_xml>
{
  public:
    int foo () { return 2; }
};


template<class T>
obj<T> getfromconfig()
{
    return obj<T>();
}


template<class T>
int entry(T x)
{
  return x.foo();
}


int main(int argc, char * argv[])
{
  std::cout << entry( getfromconfig<file1_xml>() ) << std::endl;
  std::cout << entry( getfromconfig<file2_xml>() ) << std::endl;

  std::cout << "the end" << std::endl;
  //_getch();
  return 0;
}

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;}

#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);
}

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();
}

class PredicateExample {
 public:
  static int Do(int param) {return 0;}
};
class BaseObj {
 public:
  typedef  int  (*Function)(int);
  BaseObj(Function fu)    :  foo_address(fu) {}
  int foo(int param) {return foo_address(param);}

 protected:
  void set_foo_address(Function fu) {foo_address = fu;}

 private:
  Function foo_address;
};

template <class Predicate>
class Obj : public BaseObj
{
public:
  Obj()   :  BaseObj(Predicate::Do) {}
};

class APredicate;
class BPredicate;
class A : public Obj<APredicate> {};
class B : public Obj<BPredicate> {};
//...

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

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

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;  
};

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 );
  ...
}

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);
  })
});

// было
class Environment
{
  Base* x;
  Base* y;

  void one(char cx) { x = getconfig(cx); }
  void two(char cy) { y = getconfig(cy); }
  void three()
  {
    ..... здесь гора всякого полезного кода .....
  }
  .....
};

// стало
struct IEnvironment
{
  IEnvironment* one(char cx);
  virtual IEnvironment* two(char cy) = 0;
  virtual IEnvironment* three() = 0;
};

template<class X, class Y> // чтобы компилировалось, нужно начать с каких-то null-объектов - заглушек (например)
class Environment : public IEnvironment
{
  X x;
  Y y;

  virtual IEnvironment* one(char cx) override
  {
    IEnvironment* res = nullptr;
    getconfig(cx, [&](auto x) { res = new Environment<decltype(x),Y>(); res->x = x; });
    return res;
  }
  virtual IEnvironment* two(char cy) override
  {
    IEnvironment* res = nullptr;
    getconfig(cy, [&](auto y) { res = new Environment<X,decltype(y)>(); res->y = y; });
    return res;
  }
  virtual void three() override
  {
    ..... код, конкретизированный для X,Y .....
  }
  .....
};

template<
  class AcousticModelType, // 2 типа акустических моделей, - грузятся из файла (выбранного в конфиге)
  class GraphType,         // 3 формата графов переходов, - грузятся из бинарного файла (выбранного в конфиге)
  class OutputLatticeType  // 2 типа выходной сетки гипотез, - выбираются в конфиге
>
class SpeechDecoderImpl { ..... };

T>/* returns A is config have 'a', B is 'b', and so on */
T>obj * getfromconfig (const char *filename);
T>
T>int
T>entry (obj *x)
T>{
T>  return x->foo();
T>}
T>

using obj = boost::variant<A, B>;

obj getfromconfig(const char *filename);

int entry(obj x)
{
    return apply([](auto x){ return x.foo(); }, x);
}

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 is config have 'a', B is 'b', and so on */
T>obj * getfromconfig (const char *filename);

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

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

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

class A {//: public obj {
 public:
  int foo() {return (int)'a';}
};

class B {//: public obj {
 public:
  int foo() {return (int)'b';}
};

template <class Object>
class Config1 {
 public:
Object GetFrom (const char *filename) {return Object();}
};

template <class Object>
class Config2 {
 public:
Object GetFrom (const char *filename) {return Object();}
};

template <template<typename> class Config, class Object>
int entry(const char * filename, Config<Object> & config) {
  return config.GetFrom(filename).foo();
}

int main() {
    Config1<A> config;
    return entry("my.xml",config);
}