class AlgorithmDefaultTypes 

 {

 public:

   typedef int Adat;

 };

 template<class T = AlgorithmDefaultTypes>

 class AlgorithmTypes : public T 

 {

 public:

   template<class X>

   class SetAdat : public T { X Adat; };

 };

 template<class T = AlgorithmTypes<> >

 class AlgorithmDefaultDataFields : public T

 {

 protected:

   typename T::Adat adat;

 };

 template<class T = AlgorithmDefaultDataFields<> >

 class Algorithm : public T

 {

   int _intAdat;

 public:

   Algorithm() {};

   Algorithm(const T &tt) : T(tt) {};

   template<class X> class _SetAdat : public T {

     protected:

     X adat;

     public:

     _SetAdat() {}; //"Algorithm<>::_SetAdat<double> b;"-hez kell!!!!

                    // De az is rossz!!!!!

     _SetAdat(const T &t,const X& x) : T(t), adat(x) {};

   };

   template<class X>

   Algorithm<_SetAdat<X> > setAdat(const X &x) {

     return Algorithm<_SetAdat<X> >(_SetAdat<X>(*this,x));

   }

   Algorithm &setIntAdat(int i) {_intAdat=i;return *this;}

   //vagy:

   Algorithm &intAdat(int i) {_intAdat=i;return *this;}

   typename T::Adat run()

   {

     //Itt csinalunk valamit

     return typename T::Adat();    

   }

   ~Algorithm()

   {

     //Itt nem csinalunk semmit

   }

 };

 Algorithm<> algorithm() 

 {

   return Algorithm<>();

 }

 int main() 

 {

   Algorithm<> a;

   Algorithm<>::_SetAdat<double> b; b=b;//Ez itt nem az, amit szeretnenk!!! 

   Algorithm<>::SetAdat<double> c; c=c; //Ez itt nem az, amit szeretnenk!!!

   a.run();

   //  b.run();

   //  c.run();

   algorithm().run();

   algorithm().setAdat(5.2).run();

 }