Résolution d'une dépendance circulaire entre les classes de modèles

Question

J'ai deux classes, Foo<T> et Bar<T>, dérivées de Base. Chaque instance remplace une méthode virtual Base* convert(ID) const, où ID est une instance d'un type qui identifie de manière unique une instanciation particulière de Foo ou Bar (prétendre qu'il s'agit d'un enum). Le problème est que Foo::convert() doit être en mesure de renvoyer une instance Bar, et de même Bar::convert() doit être en mesure d'instancier Foo. Comme ce sont les deux modèles, cela entraîne une dépendance circulaire entre Foo.h et Bar.h. Comment résoudre ça?

Edit: Une déclaration avant ne fonctionne pas parce que la mise en œuvre de chaque méthode a besoin le constructeur de l'autre classe:

Foo.h:

#include <Base.h> 

template<class T> class Bar; 

template<class T> 
class Foo : public Base { ... }; 

template<class T> 
Base* Foo<T>::convert(ID id) const { 

    if (id == BAR_INT) 
     return new Bar<int>(value); // Error. 

    ... 

} 

Bar.h:

#include <Base.h> 

template<class T> class Foo; 

template<class T> 
class Bar : public Base { ... }; 

template<class T> 
Base* Bar<T>::convert(ID id) const { 

    if (id == FOO_FLOAT) 
     return new Foo<float>(value); // Error. 

    ... 

} 

L'erreur est, naturellement, "utilisation invalide de type incomplet".

Answer 1

Ce que vous devez faire est de séparer les déclarations de classe de l'implémentation. Donc, quelque chose comme

template <class T> class Foo : public Base 
{ 
    public: 
    Base* convert(ID) const; 
} 

template <class T> class Bar : public Base 
{ 
    public: 
    Base* convert(ID) const; 
} 

template <class T> Base* Foo<T>::convert(ID) const {return new Bar<T>;} 
template <class T> Base* Bar<T>::convert(ID) const {return new Foo<T>;} 

De cette façon, vous avez des définitions de classe complète lorsque les fonctions sont définies.

Answer 2

(Mise à jour) Vous devriez être capable de gérer cela comme avec les classes non-template. Écrivez votre Bar.h comme ceci. (Et même pour .h)

#if !defined(BAR_H_INCLUDED) 
#define BAR_H_INCLUDED 

template <class T> 
class Foo; 

template <class T> 
class Bar 
{ 
    /// Declarations, no implementations. 
}  

#include "Foo.h" 

template <class T> 
Base* Bar<T>::Convert() { /* implementation here... */ } 
#endif 

Answer 3

Vous devez utiliser la classe de modèles de déclarations anticipées dans les en-têtes soit

template <class T> 
class X; 

est parfaitement bonne classe modèle de déclaration avant.

Answer 4

La réponse de James Curran est une aubaine. D'une manière générale, l'idée de James est de restreindre l'inclusion des fichiers d'en-tête requis jusqu'au moment où les membres (les «déclarations») provenant des fichiers d'en-tête inclus sont nécessaires. A titre d'exemple:

t1.hh

#ifndef S_SIGNATURE 
#define S_SIGNATURE 

struct G; // forward declaration 

template<typename T> 
struct S { 
    void s_method(G &); 
}; 

#include "t2.hh" // now we only need G's member declarations 

template<typename T> 
void S<T>::s_method(G&g) { g.g_method(*this); } 

#endif 

t2.hh

#ifndef G_SIGNATURE 
#define G_SIGNATURE 

template<typename T> 
struct S; // forward declaration 

struct G { 
    template<typename T> 
    void g_method(S<T>&); 
}; 

#include "t1.hh" // now we only need S' member declarations 

template<typename T> 
void G::g_method(S<T>& s) { s.s_method(*this); } 

#endif 

t.cc

#include "t1.hh" 
#include "t2.hh" 

S<int> s; 
G g; 

int main(int argc,char**argv) { 
    g.g_method(s); // instantiation of G::g_method<int>(S<int>&) 
}