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