Forward-Deklaration von verschachtelten Typen/Klassen in C++

Question

ich vor kurzem in einer Situation wie dieser stecken geblieben:

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

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

Normalerweise können Sie einen Klassennamen deklarieren:

class A; 

Aber man kann nicht vorwärts Wenn Sie einen verschachtelten Typ deklarieren, verursacht das folgende Kompilierungsfehler.

class C::D; 

Irgendwelche Ideen?

Answer 1

Sie können es nicht tun, es ist ein Loch in der C++ Sprache. Sie müssen mindestens eine der verschachtelten Klassen entknoten.

Answer 2

Ich würde dies nicht eine Antwort nennen, aber nichtsdestotrotz einen interessanten Fund: Wenn Sie die Deklaration Ihrer Struktur in einem Namespace namens C wiederholen, ist alles in Ordnung (zumindest in gcc). Wenn die Klassendefinition von C gefunden wird, scheint es still um die 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); 
    }; 
}; 

ich wie ein Vorwärts-Referenz benötigt überschrieben:

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

Meine Abhilfe war:

class IDontControl_Nested; // Forward reference to distinct name. 

Später, als ich die volle Definition verwenden konnte:

Diese Technik wäre wahrscheinlich mehr Mühe als es wert wäre, wenn es komplizierte Konstruktoren oder andere spezielle Elementfunktionen gäbe, die nicht glatt geerbt wurden. Ich könnte mir vorstellen, dass bestimmte Schablonenmagie schlecht reagiert.

Aber in meinem sehr einfachen Fall scheint es zu funktionieren.

Answer 4

Wenn Sie wirklich die fiese Header-Datei in Ihrem Header-Datei vermeiden wollen #including, könnten Sie dies tun:

HPP-Datei:

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

CPP-Datei

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

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

Aber dann:

1. Sie den eingebetteten Typ bei Anrufzeit (vor allem, wenn Ihre Funktion nicht übernehmen alle Parameter des eingebetteten Typ)
2. Ihre Funktion kann nicht virtuell sein (weil es eine Vorlage)

müssen angeben,

Also, ja, Vor- und Nachteile ...

Answer 5

Dies würde eine Abhilfe (zumindest für das Problem in der Frage beschrieben - nicht für das eigentliche Problem, das heißt, wenn nicht die Kontrolle über die Definition von 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 
}