Dichiarazione diretta di tipi / classi nidificati in C ++

Di recente mi sono bloccato in una situazione come questa:

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

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

Di solito puoi dichiarare un nome di classe:

class A;

Ma non è possibile inoltrare un tipo nidificato, ciò che segue causa un errore di compilazione.

class C::D;

Qualche idea?

Non puoi farlo, è un buco nel linguaggio C ++. Dovrai annullare il nidificazione di almeno una delle classi nidificate.

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

Avevo bisogno di un riferimento futuro come:

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

La mia soluzione alternativa era:

class IDontControl_Nested; // Forward reference to distinct name.

Più tardi, quando ho potuto usare la definizione completa:

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

Questa tecnica sarebbe probabilmente più problematica di quanto valga la pena se ci fossero costruttori complicati o altre funzioni speciali dei membri che non sono state ereditate senza problemi. Potrei immaginare che certi modelli di magia reagiscano male.

Ma nel mio caso molto semplice, sembra funzionare.

Se vuoi davvero evitare #includendo il brutto file di intestazione nel tuo file di intestazione, puoi farlo:

file hpp:

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

file cpp

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

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

Ma allora:

1. dovrai specificare il tipo incorporato al momento della chiamata (specialmente se la tua funzione non accetta alcun parametro del tipo incorporato)
2. la tua funzione non può essere virtuale (perché è un modello)

Quindi sì, compromessi ...

Questo può essere fatto dichiarando in avanti la classe esterna come spazio dei nomi .

Esempio: dobbiamo usare una classe nidificata others :: A :: Nested in others_a.h, che è fuori dal nostro controllo.

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

Non chiamerei questa una risposta, ma comunque una scoperta interessante: se ripeti la dichiarazione della tua struttura in uno spazio dei nomi chiamato C, tutto va bene (almeno in gcc). Quando viene trovata la definizione di classe di C, sembra sovrascrivere silenziosamente il 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;
}

Questa sarebbe una soluzione alternativa (almeno per il problema descritto nella domanda - non per il problema reale, ovvero quando non si ha il controllo sulla definizione di 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
}

Se hai accesso per modificare il codice sorgente delle classi C e D, puoi estrarre la classe D separatamente e inserire un sinonimo nella classe C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;