eredità typedef da una base astratta pura

Question

Edit: Trovato duplicato

Ho whittled giù qualche codice problema al caso di lavoro più semplice per illustrare i seguenti: il mio typedef in una pura classe di base astratta non viene ereditata dalla classe derivata. Nel codice di seguito mi piacerebbe ereditare il typedef system_t nel ConcreteTemplateMethod:

#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;
}

Questa compila codice e funziona come previsto. Nella ConcreteTemplateMethod è necessaria la seguente, e quando viene rimosso causa errori di compilatore:

typedef Analyzer<T> system_t;

Si noti che il tipo system_t è già typedef'ed nella classe base, tuttavia. Perché devo inserire un altro typedef quando ereditare?

Mi rendo conto che posso qualificare il typename del system_t nel ConcreteTemplateMethod derivato utilizzando typename TemplateMethod< Analyzer<T> >::system_t&, ma questo è un po 'prolisso, e vorrei evitare di dover ri-typedef alla ogni volta di base ho ereditato e necessità di utilizzo che stessa system_t. C'è un modo per aggirare questo che posso definire nel TemplateMethod di base?

Answer 1

si dovrebbe fare

typedef typename TemplateMethod<X>::system_t system_t;

per typedef "ereditare". typedef non è ereditato automaticamente (se compilatore è compatibile).

se si guarda attraverso overflow dello stack, non ci sarà duplicato di questo problema da qualche parte.