Accès à une classe de base modèle type pointeur de fonction

Question

J'ai une classe que j'ai pourvu que je ne veux vraiment pas changer, mais je ne veux prolonger. Je suis un débutant de modèle et modèle expérimenter avec un motif décorateur appliqué à une classe de modèle. classe modèle contient un pointeur à membre (si je comprends bien la sémantique) dans une autre classe. Le pointeur à membre est désérialiseur d'un XML istream. Le type 'T' est le type de document XML à désérialisée.

template <typename T> class B {
public:
  typedef std::auto_ptr<T> MYFUN( 
    std::istream&, const std::string&, const std::string& );

public:
  B<T>( MYFUN* p );

private:
  MYFUN *fptr;
  std::string aString1;
  std::string aString2;

};

Le typedef me semble bizarre après avoir lu http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-33.5 , et pourtant cette classe semble fonctionner très bien en l'état. Il n'y a pas de #defines supplémentaires dans le fichier d'en-tête fourni, donc c'est un peu mystérieux pour moi.

Maintenant, j'essaie de l'étendre, comme décorateur parce que je veux faire un peu plus de travail sur l'objet auto_ptr retourné par myfun:

template <typename T>
class D : public class B<T>
{
  D( B<T>::MYFUN *fPtr, B<T> *providedBase ); //compiler complaint
  //Looks like B
  private:
    B* base_;

};

template <typename T>
D<T>::D( B<T>::MYFUN *p, B<T> *base ) //compiler complaint
:
B<T>::B( p ), base_(providedBase)
{ }

Lorsque vous essayez de compiler, je reçois une plainte de syntaxe dans les deux lignes indiquées. L'erreur est quelque chose comme « prévu « ) » à * ». Il n'y a pas plainte myfun être définie.

Quand je redéfinir le pointeur à membre en D avec la même signature que dans D, i.e..

//change MYFUN to NEWFUN in D)
typedef std::auto_ptr<T> MYNEWFUN( 
    std::istream&, const std::string&, const std::string& );

Cela fonctionne. Je préfère ne pas avoir à faire pour chaque D / décorateur je pourrais faire de B. J'ai essayé d'effectuer le typedef plus globalement, mais n'a pas pu obtenir la bonne syntaxe en raison du paramètre de modèle étant défini.

Answer 1

L'erreur de compilation est due au fait que le compilateur ne peut pas vous dire parlez d'un type.

Essayez:

D( typename B<T>::MYFUN *fPtr, B<T> *providedBase );

et

template <typename T>
D<T>::D( typename B<T>::MYFUN *p, B<T> *base )

Voir: la section des modèles de C ++ FAQ Lite pour plus de détails sur pourquoi cela est nécessaire, mais le résumé est qu'en raison de la possibilité de spécialisation de modèle, il n'y a aucun moyen pour le compilateur pour être sûr que se réfère en fait B<T>::MYFUN à un type.

Answer 2

La définition du myfun typedef en B se fait avec une visibilité privée. D ne sera pas en mesure d'y accéder. Si vous modifiez à la protection ou public, il ne fonctionne alors?

template <typename T> class B {
  protected:
    typedef std::auto_ptr<T> MYFUN( 
      std::istream&, const std::string&, const std::string& );
...
};

Answer 3

Le problème que je vois avec ceci est que B :: myfun est privé typedef.

Par conséquent, toute classe héritant ne peut pas y accéder.

Modifier ceci:

template <typename T> class B 
{  
public:
   typedef std::auto_ptr<T> MYFUN(     std::istream&, const std::string&, const std::string& );
public:  
   B<T>( MYFUN* p );
private:  
   MYFUN *fptr;  
std::string aString1;  
std::string aString2;
};