typedef héritage à partir d'une base abstraite pur

Question

Edit: Trouvé double

J'ai amenuisé un code de problème au cas de travail le plus simple pour illustrer ce qui suit: mon typedef dans une classe de base abstraite pure est pas héritée par la classe dérivée. Dans le code ci-dessous je voudrais hériter du typedef system_t dans le 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;
}

Ce code compile, et fonctionne comme prévu. Dans le ConcreteTemplateMethod ce qui suit est nécessaire, et lors de leur retrait provoque des erreurs du compilateur:

typedef Analyzer<T> system_t;

Notez que le type de system_t est déjà typedef'ed dans la classe de base, cependant. Pourquoi dois-je inclure une autre typedef quand héritant?

Je me rends compte que je peux qualifier la typename de system_t dans le ConcreteTemplateMethod dérivé en utilisant typename TemplateMethod< Analyzer<T> >::system_t&, mais c'est un peu bavard, et je voudrais éviter d'avoir à re-typedef à chaque fois de base inherit et le besoin d'utiliser cette même system_t. Y at-il un moyen de contourner ce que je peux définir dans la TemplateMethod de base?

Answer 1

vous devez faire

typedef typename TemplateMethod<X>::system_t system_t;

pour typedef "inherit". typedef est pas hérité automatiquement (si le compilateur est conforme).

si vous regardez à travers un débordement de pile, il y aura double de ce quelque part question.