Editar: Encontradoduplicar

Reduje un poco el código del problema al caso de trabajo más simple para ilustrar lo siguiente: la clase derivada no hereda mi typedef en una clase base abstracta pura. En el siguiente código me gustaría heredar elsystem_t escribir en elConcreteTemplateMethod:

#include <iostream>

// pure abstract template-method
template <typename T>   // T == Analyzer<U>
class TemplateMethod {
  public:
    typedef T system_t;

    virtual void fn (const system_t& t) const = 0;
};


template <typename T>
class Analyzer {
  public:
    void TemplatedAlgorithm (const TemplateMethod< Analyzer <T> >& a) const {
      printf ("Analyzer::TemplatedAlgorithm\n");
      a.fn(*this);  // run the template-method
    }

    void fn () const {
      printf ("Analyzer::fn\n");
    }
};


// concrete template-method
template <typename T>
class ConcreteTemplateMethod : public TemplateMethod < Analyzer<T> > {
  public:
    typedef Analyzer<T> system_t;

    virtual void fn (const system_t& t) const {
      printf ("ConcreteTemplateMethod::fn\n");
      t.fn(); // perform Analyzer's fn
    }
};

int main () {

  Analyzer <double> a;
  ConcreteTemplateMethod<double> dtm;
  a.TemplatedAlgorithm(dtm);

  return 0;
}

Este código se compila y se ejecuta como se esperaba. En elConcreteTemplateMethod se requiere lo siguiente, y cuando se elimina provoca errores de compilación:

typedef Analyzer<T> system_t;

Tenga en cuenta que elsystem_t tipo ya estátypedef'ed en la clase base, sin embargo. ¿Por qué debo incluir otro typedef al heredar?

Me doy cuenta de que puedo calificar el tipo de nombre desystem_t en el derivadoConcreteTemplateMethod mediante el usotypename TemplateMethod< Analyzer<T> >::system_t&, pero eso es un poco detallado, y me gustaría evitar tener que volver atypedef a la base cada vez que heredo y necesito usar ese mismosystem_t. ¿Hay alguna forma de evitar esto que pueda definir en la baseTemplateMethod?