Declaración directa de tipos / clases anidados en C ++

Recientemente me quedé atrapado en una situación como esta:

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

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

Por lo general, puede declarar un nombre de clase:

class A;

Pero no puede reenviar la declaración de un tipo anidado, lo siguiente provoca un error de compilación.

class C::D;

¿Algunas ideas?

No puedes hacerlo, es un agujero en el lenguaje C ++. Tendrás que anidar al menos una de las clases anidadas.

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

Necesitaba una referencia directa como:

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

Mi solución fue:

class IDontControl_Nested; // Forward reference to distinct name.

Más tarde, cuando podría usar la definición 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) { }
};

Esta técnica probablemente sería más problemática de lo que vale si hubiera constructores complicados u otras funciones miembro especiales que no se heredaran sin problemas. Me imagino que ciertas plantillas mágicas reaccionan mal.

Pero en mi caso muy simple, parece funcionar.

Si realmente quiere evitar #incluir el desagradable archivo de encabezado en su archivo de encabezado, puede hacer esto:

archivo hpp:

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

archivo cpp

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

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

Pero entonces:

1. tendrá que especificar el tipo incrustado en el momento de la llamada (especialmente si su función no toma ningún parámetro del tipo incrustado)
2. su función no puede ser virtual (porque es una plantilla)

Entonces, sí, compensaciones ...

Esto puede hacerse declarando la clase externa como un espacio de nombres .

Muestra: Tenemos que usar una clase anidada others :: A :: Anidado en others_a.h, que está fuera de nuestro control.

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

No llamaría a esto una respuesta, pero no obstante un hallazgo interesante: si repites la declaración de tu estructura en un espacio de nombre llamado C, todo está bien (al menos en gcc). Cuando se encuentra la definición de clase de C, parece sobrescribir en silencio el espacio nams 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;
}

Esta sería una solución alternativa (al menos para el problema descrito en la pregunta, no para el problema real, es decir, cuando no se tiene control sobre la definición 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
}

Si tiene acceso para cambiar el código fuente de las clases C y D, puede extraer la clase D por separado e ingresar un sinónimo en la clase C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;