déclaration avant de types/classes imbriquées dans C++

Question

Je suis récemment coincé dans une situation comme celle-ci:

class A 
{ 
public: 
    typedef struct/class {...} B; 
... 
    C::D *someField; 
} 

class C 
{ 
public: 
    typedef struct/class {...} D; 
... 
    A::B *someField; 
} 

Normalement, vous pouvez déclarer un nom de classe:

class A; 

Mais vous ne pouvez pas en avant déclarer un type imbriqué, ce qui suit provoque une erreur de compilation.

class C::D; 

Des idées?

Answer 1

Vous ne pouvez pas le faire, c'est un trou dans le langage C++. Vous devrez démonter au moins l'une des classes imbriquées.

Answer 2

Je n'appellerais pas cela une réponse, mais néanmoins une trouvaille intéressante: Si vous répétez la déclaration de votre struct dans un espace de nom appelé C, tout va bien (en gcc au moins). Lorsque la définition de la classe C se trouve, il semble écraser en silence le namspace C.

namespace C { 
    typedef struct {} D; 
} 

class A 
{ 
public: 
typedef struct/class {...} B; 
... 
C::D *someField; 
} 

class C 
{ 
public: 
    typedef struct/class {...} D; 
... 
    A::B *someField; 
} 

Answer 3

class IDontControl 
{ 
    class Nested 
    { 
     Nested(int i); 
    }; 
}; 

je besoin d'une référence en avant comme:

class IDontControl::Nested; // But this doesn't work. 

Ma solution était:

class IDontControl_Nested; // Forward reference to distinct name. 

Plus tard, quand je pourrais utiliser la définition complète:

#include <idontcontrol.h> 

// I defined the forward ref like this: 
class IDontControl_Nested : public IDontControl::Nested 
{ 
    // Needed to make a forwarding constructor here 
    IDontControl_Nested(int i) : Nested(i) { } 
}; 

Cette technique poserait probablement plus de problèmes que cela en valait la peine s'il existait des constructeurs compliqués ou d'autres fonctions membres spéciales héritées sans heurts. Je pourrais imaginer que certains modèles de magie réagissent mal.

Mais dans mon cas très simple, cela semble fonctionner.

Answer 4

Si vous voulez vraiment éviter #including le fichier d'en-tête méchant dans votre fichier d'en-tête, vous pouvez le faire:

fichier HPP:

class MyClass 
{ 
public: 
    template<typename ThrowAway> 
    void doesStuff(); 
}; 

fichier cpp

#include "MyClass.hpp" 
#include "Annoying-3rd-party.hpp" 

template<> void MyClass::doesStuff<This::Is::An::Embedded::Type>() 
{ 
    // ... 
} 

Mais alors:

1. vous devrez spécifier le type embarqué à l'heure d'appel (surtout si votre fonction ne prend aucun paramètre de type embarqué)
2. votre fonction ne peut pas être virtuelle (parce qu'il est un modèle)

Alors, oui, ... compromis

Answer 5

Ce serait une solution (au moins pour le problème décrit dans la question - non pas pour le problème réel, à savoir, lorsqu'il n'a pas de contrôle sur la définition de C):

class C_base { 
public: 
    class D { }; // definition of C::D 
    // can also just be forward declared, if it needs members of A or A::B 
}; 
class A { 
public: 
    class B { }; 
    C_base::D *someField; // need to call it C_base::D here 
}; 
class C : public C_base { // inherits C_base::D 
public: 
    // Danger: Do not redeclare class D here!! 
    // Depending on your compiler flags, you may not even get a warning 
    // class D { }; 
    A::B *someField; 
}; 

int main() { 
    A a; 
    C::D * test = a.someField; // here it can be called C::D 
}