#include <iostream>
using namespace std;
 
class SomeClass;
 
/* In the real code I have SomeClass< T, P, Q>
 * and this is not known when the compiler reaches A,B and C*/
struct OtherClass{
	int i;
	double d;
	OtherClass(int ii, double dd):i(ii),d(dd){};
};
 
/* My idea of A is this, although it is not 
 * possible to have a virtual template function */
class A{
public:
	template<class K>
	virtual void operator()(K input )=0;
};
 
template<int L, bool M, class S>
struct B : public A{
	template<class K>
	void operator()(K input ){ cout << "Inside B" << endl; };
};
 
template<class S>
struct B<0, true, S> : public A{
	template<class K>
	void operator()(K input ){ cout << "Inside B<0,true>"<< endl; };
};
 
/* This class creates and stores an object of type B (or one of the specializations).
 * But L and M are unknown so I created A to store the B object here
 * K is also unknown here. */
class C{
	A* object;
public:
	C(){
		/*
		 * Get some data from files and according
		 * to this data construct a B specialized object. */
		object = new B< 0, true, SomeClass>();
	};
 
	void go(){
		/*
		 * Later, I want to call B, that was stored through the interface A
		*/
		(*object)(new OtherClass(0,2));
	}
};
 
int main(void){
	C* c = new C();
	c->go();
 
	return 0;
};

#include <iostream>
 
class A { public: static void call() { std::cout<<"This is A"<<std::endl;} };
class B { public: static void call() { std::cout<<"This is B"<<std::endl;} };
 
class Base { public: virtual void go() {std::cout<<"Base"<<std::endl; } };
 
template<typename T>
class hold : public Base
{
public:
 
  hold() : Base() {}
  void go() { T::call(); }
};
 
 
class C 
{
  Base* object;
 
public:
 
  C() : object(new hold<A>()) {}
 
  template<typename T>
  void setHold() { delete object; object=new hold<T>; }
  void go() { object->go(); }
};
 
int main()
{
  C cobj;
  cobj.go();
  cobj.setHold<B>();
  cobj.go();
  return 0;
}

template<int N>
class A
{ };

#include <iostream>
#include "boost/any.hpp"
using namespace std;
 
class SomeClass;
struct OtherClass{
	int i;
	double d;
	OtherClass(int ii, double dd):i(ii),d(dd){};
};
 
struct Base{
	virtual double call(boost::any in)=0;
};
 
template<int L, bool M, class S, class T>
struct B : Base{
	double call(boost::any in ){ cout << "Inside B" << endl; return 0;};
};
 
template<class S,class T>
struct B<0, true, S,T>:Base{
	double call(boost::any in){ cout << "Inside B<0,true> and obj.i is "<< boost::any_cast<T*>(in)->i<< endl; return 0;};
};
 
template<class  Q>
class C{
	Base* i;
public:
	template< class T >
	C( T* t ){
		i = new B< 0, true, SomeClass, T>();
	};
 
	template<class T>
	void go( T* t ){
		i->call( boost::any(t) );
	}
};
 
int main(void){
	typedef C<SomeClass> CS;
	CS* c = new CS(new OtherClass(2,1));//dummy object
	c->go(new OtherClass(0,2));
 
	return 0;
};