Weiterleitungsdeklaration verschachtelter Typen / Klassen in C ++

Ich bin kürzlich in einer Situation wie dieser festgefahren:

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;

Sie können einen verschachtelten Typ jedoch nicht weiterleiten. Folgendes führt zu einem Kompilierungsfehler.

class C::D;

Irgendwelche Ideen?

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

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

Ich brauchte eine Vorwärtsreferenz wie:

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

Meine Problemumgehung war:

class IDontControl_Nested; // Forward reference to distinct name.

Später, als ich die vollständige Definition verwenden konnte:

#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) { }
};

Diese Technik wäre wahrscheinlich schwieriger als es sich lohnt, wenn es komplizierte Konstruktoren oder andere spezielle Elementfunktionen gäbe, die nicht reibungslos vererbt würden. Ich könnte mir vorstellen, dass bestimmte Vorlagenmagie schlecht reagiert.

Aber in meinem sehr einfachen Fall scheint es zu funktionieren.

Wenn Sie wirklich vermeiden möchten, # die böse Header-Datei in Ihre Header-Datei aufzunehmen, können 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 müssen den eingebetteten Typ zum Zeitpunkt des Aufrufs angeben (insbesondere wenn Ihre Funktion keine Parameter des eingebetteten Typs akzeptiert).
2. Ihre Funktion kann nicht virtuell sein (da es sich um eine Vorlage handelt).

Also, ja, Kompromisse ...

Dies kann erfolgen, indem die äußere Klasse als Namespace vorwärts deklariert wird .

Beispiel: Wir müssen eine verschachtelte Klasse other :: A :: Nested in Others_a.h verwenden, die außerhalb unserer Kontrolle liegt.

Andere_a.h

namespace others {
struct A {
    struct Nested {
        Nested(int i) :i(i) {}
        int i{};
        void print() const { std::cout << i << std::endl; }
    };
};
}

my_class.h

#ifndef MY_CLASS_CPP
// A is actually a class
namespace others { namespace A { class Nested; } }
#endif

class MyClass {
public:
    MyClass(int i);
    ~MyClass();
    void print() const;
private:
    std::unique_ptr<others::A::Nested> _aNested;
};

my_class.cpp

#include "others_a.h"
#define MY_CLASS_CPP // Must before include my_class.h
#include "my_class.h"

MyClass::MyClass(int i) :
    _aNested(std::make_unique<others::A::Nested>(i)) {}
MyClass::~MyClass() {}
void MyClass::print() const {
    _aNested->print();
}

Ich würde dies keine Antwort nennen, aber dennoch 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 sie den Namensraum C stillschweigend zu überschreiben.

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;
}

Dies wäre eine Problemumgehung (zumindest für das in der Frage beschriebene Problem - nicht für das eigentliche Problem, dh wenn Sie keine Kontrolle über die Definition von haben 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
}

Wenn Sie Zugriff haben, um den Quellcode der Klassen C und D zu ändern, können Sie die Klasse D separat herausnehmen und in Klasse C ein Synonym dafür eingeben:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;