Переадресація декларування вкладених типів / класів у C ++

Нещодавно я застряг у такій ситуації:

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

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

Зазвичай ви можете оголосити ім'я класу:

class A;

Але ви не можете переслати оголошення про вкладений тип, наступні причини викликають помилку компіляції.

class C::D;

Будь-які ідеї?

Ви не можете цього зробити, це отвір у мові C ++. Вам доведеться розв’язати хоча б один із вкладених класів.

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

Мені потрібна була пряма посилання на кшталт:

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

Моє вирішення було:

class IDontControl_Nested; // Forward reference to distinct name.

Пізніше, коли я міг використовувати повне визначення:

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

Ця методика, мабуть, матиме більше проблем, ніж варто, якби були складні конструктори чи інші спеціальні функції, які не успадковувалися гладко. Я міг уявити, що певна магія шаблону погано реагує.

Але в моєму дуже простому випадку це, здається, працює.

Якщо ви дійсно хочете уникати #including неприємного файлу заголовка у вашому файлі заголовка, ви можете зробити це:

hpp-файл:

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

cpp-файл

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

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

Але з іншого боку:

1. вам доведеться вказати вбудований тип під час виклику (особливо якщо ваша функція не приймає жодних параметрів вбудованого типу)
2. ваша функція не може бути віртуальною (тому що це шаблон)

Отже, так, компроміси ...

Це можна зробити, оголосивши зовнішній клас як простір імен .

Зразок: ми повинні використовувати вкладений клас others :: A :: Вкладений в 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();
}

Я б не назвав це відповіддю, але, тим не менш, цікавою знахідкою: Якщо ви повторите декларацію своєї структури в просторі імен під назвою C, все добре (принаймні в gcc). Коли знайдено визначення класу C, здається, він мовчки перезаписав нампростір 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;
}

Це було б вирішенням рішення (принаймні, для проблеми, описаної у питанні, - не для фактичної проблеми, тобто, коли не має контролю над визначенням 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
}

Якщо у вас є доступ до зміни вихідного коду класів C і D, ви можете вийняти клас D окремо і ввести його синонім у клас C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;