Пользуясь рекуррентными формулами, вычислить значения многочлена степеней от 0 до N

 #include <iostream>
 #include <vector>
 #include <cmath>
 //-----------------------------------------------------------------
 class polynom
 {
     std::vector<double>  coefficients;
     size_t               degree;
 
   public:
 
     polynom()
     {
       coefficients = { 0 };
       degree       = 0;
     }
 
     polynom( const std::vector<double> &coefficients )
            : coefficients ( coefficients )
     {
       degree = coefficients.size() - 1;
     }
 
     // Значение многочлена от x
     double  get_value( const double &x )
     {
       size_t  n = coefficients.size() - 1;
       double  s = 0.0f;
           for ( const auto &v : coefficients )
           {
             s += v * pow( x, n );
             --n;
           }
       return s;
     }
 
     unsigned int deg() const
     {
       return degree;
     }
 
     polynom& operator = ( const polynom &rhs )
     {
           if ( this == &rhs )
           return *this;
       this->coefficients = rhs.coefficients;
       this->degree       = rhs.degree;
       return  *this;
     }
 
     // x^shift*polynom:
     polynom& operator << ( unsigned  shift )
     {
       this->degree += shift;
           while ( shift-- )
           this->coefficients.push_back( 0 );
       return  *this;
     }
 
     // умножение полинома на число слева:
     friend polynom operator * ( double k, const polynom &p )
     {
       polynom kp = p;
           for ( auto &term : kp.coefficients )
           term *= k;
       return kp;
     }
 
     friend polynom operator + ( polynom p, polynom g )
     {
       int  p_size = p.deg() + 1;
       int  g_size = g.deg() + 1;
           if ( p_size > g_size )
           {
                 while ( g_size && p_size )
                   p.coefficients[--p_size] += g.coefficients[--g_size];
             return p;
           }
           else
           {
                 while ( p_size && g_size )
                   g.coefficients[--g_size] += p.coefficients[--p_size];
             return g;
           }
     }
 
     friend std::ostream& operator << ( std::ostream &out, const polynom &p )
     {
       size_t  n = p.coefficients.size() - 1;
           for ( const auto &v : p.coefficients )
              std::cout << v << "x^" << n-- << " + ";
       return out << "\b\b \b\b\n";
     }
 }; // class polynom...
 //----------------------------------------------------------------------
 polynom  U( unsigned int  n )
 {
       if ( n == 0 )
          return  polynom( {1} );
 
       if ( n == 1 )
          return  polynom( {2, 0 } );
 
   return  2*( U( n - 1 ) << 1 ) + U( n - 2 );
 }
 //----------------------------------------------------------------------
 int main()
 {
   const size_t  N = 8;
       for ( size_t n = 0; n <= N; ++n )
         std::cout << "U_" << n << " = " << U( n ) << "\n";
 
   double x = 2.0;
       for ( size_t n = 0; n <= N; ++n )
         std::cout << "U_" << n << "(" <<  x << ") = "
                   << U( n ).get_value( x ) << "\n";
 
   //std::cin.get();
   return  0;
 }