การส่งต่อการประกาศประเภท / คลาสที่ซ้อนกันใน 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. ฟังก์ชั่นของคุณไม่สามารถเป็นเสมือน (เพราะเป็นเทมเพลต)

ดังนั้นใช่การแลกเปลี่ยน ...

ซึ่งสามารถทำได้โดยการประกาศไปข้างหน้าชั้นนอกเป็นใน namespace

ตัวอย่าง: เราต้องใช้คลาสที่ซ้อนกันอื่น ๆ :: A :: ซ้อนใน others_a.h ซึ่งอยู่นอกเหนือการควบคุมของเรา

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 ดูเหมือนว่าจะเขียนทับ 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;
}

นี่จะเป็นวิธีแก้ปัญหา (อย่างน้อยสำหรับปัญหาที่อธิบายในคำถาม - ไม่ใช่สำหรับปัญหาจริงเช่นเมื่อไม่สามารถควบคุมคำจำกัดความของ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;