// было
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 .....
  }
  .....
};

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

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

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

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

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