Declaração de encaminhamento de tipos / classes aninhados em C ++

Recentemente, fiquei preso em uma situação como esta:

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

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

Geralmente você pode declarar um nome de classe:

class A;

Mas você não pode encaminhar declarar um tipo aninhado, o seguinte causa erro de compilação.

class C::D;

Alguma ideia?

Você não pode fazer isso, é um buraco na linguagem C ++. Você precisará cancelar o aninhamento de pelo menos uma das classes aninhadas.

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

Eu precisava de uma referência direta como:

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

Minha solução alternativa foi:

class IDontControl_Nested; // Forward reference to distinct name.

Mais tarde, quando eu poderia usar a definição 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) { }
};

Essa técnica provavelmente seria mais problemática do que vale a pena se houvesse construtores complicados ou outras funções especiais de membros que não fossem herdadas sem problemas. Eu poderia imaginar certas mágicas reagindo mal.

Mas, no meu caso muito simples, parece funcionar.

Se você realmente deseja evitar # incluir o arquivo de cabeçalho desagradável no seu arquivo de cabeçalho, faça o seguinte:

arquivo hpp:

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

arquivo cpp

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

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

Mas então:

1. você precisará especificar o tipo incorporado no momento da chamada (especialmente se sua função não aceitar nenhum parâmetro do tipo incorporado)
2. sua função não pode ser virtual (porque é um modelo)

Então, sim, trocas ...

Isso pode ser feito declarando a classe externa como um espaço para nome .

Exemplo: Temos que usar uma classe aninhada others :: A :: Nested in others_a.h, que está fora de nosso controle.

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

Eu não chamaria isso de resposta, mas, mesmo assim, uma descoberta interessante: se você repetir a declaração de sua estrutura em um espaço para nome chamado C, está tudo bem (pelo menos no gcc). Quando a definição de classe de C é encontrada, ela substitui silenciosamente o espaço de nome 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;
}

Isso seria uma solução alternativa (pelo menos para o problema descrito na pergunta - não para o problema real, ou seja, quando não houver controle sobre a definição 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
}

Se você tiver acesso para alterar o código fonte das classes C e D, poderá retirar a classe D separadamente e inserir um sinônimo para ela na classe C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;