Przekazywanie deklaracji zagnieżdżonych typów / klas w C ++

Niedawno utknąłem w takiej sytuacji:

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

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

Zwykle możesz zadeklarować nazwę klasy:

class A;

Nie można jednak zadeklarować typu zagnieżdżonego, ponieważ powoduje to błąd kompilacji.

class C::D;

Jakieś pomysły?

Nie możesz tego zrobić, to dziura w języku C ++. Musisz odblokować co najmniej jedną z zagnieżdżonych klas.

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

Potrzebowałem referencji takich jak:

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

Moim obejściem było:

class IDontControl_Nested; // Forward reference to distinct name.

Później, kiedy mogłem użyć pełnej definicji:

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

Ta technika byłaby prawdopodobnie większym problemem niż jest warta, gdyby istniały skomplikowane konstruktory lub inne specjalne funkcje składowe, które nie zostałyby odziedziczone płynnie. Mogłem sobie wyobrazić, że pewna magia szablonu źle reaguje.

Ale w moim bardzo prostym przypadku wydaje się, że działa.

Jeśli naprawdę chcesz uniknąć # włączenia nieprzyjemnego pliku nagłówka do pliku nagłówka, możesz to zrobić:

plik hpp:

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

plik CPP

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

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

Ale wtedy:

1. będziesz musiał określić typ osadzony w czasie połączenia (szczególnie jeśli twoja funkcja nie przyjmuje żadnych parametrów typu osadzonego)
2. twoja funkcja nie może być wirtualna (ponieważ jest to szablon)

Więc tak, kompromisy ...

Można to zrobić przez zadeklarowanie klasy zewnętrznej jako przestrzeni nazw .

Przykład: musimy użyć zagnieżdżonej klasy others :: A :: Nested in others_a.h, która jest poza naszą kontrolą.

inne_a.h

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

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

moja_klasa.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();
}

Nie nazwałbym tego odpowiedzią, ale mimo to ciekawym znaleziskiem: jeśli powtórzysz deklarację swojej struktury w przestrzeni nazw o nazwie C, wszystko jest w porządku (przynajmniej w gcc). Po znalezieniu definicji klasy C wydaje się, że dyskretnie zastępuje obszar nazw 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;
}

Byłoby to obejście (przynajmniej dla problemu opisanego w pytaniu - nie dla rzeczywistego problemu, tj. Gdy nie ma się kontroli nad definicją 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
}

Jeśli masz dostęp do zmiany kodu źródłowego klas C i D, możesz osobno wyjąć klasę D i wprowadzić jej synonim w klasie C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;