Chuyển tiếp khai báo các kiểu / lớp lồng nhau trong C ++

Gần đây tôi đã bị mắc kẹt trong một tình huống như thế này:

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

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

Thông thường bạn có thể khai báo tên lớp:

class A;

Nhưng bạn không thể chuyển tiếp khai báo một kiểu lồng nhau, các nguyên nhân sau đây gây ra lỗi biên dịch.

class C::D;

Có ý kiến ​​gì không?

Bạn không thể làm điều đó, đó là một lỗ hổng trong ngôn ngữ C ++. Bạn sẽ phải hủy lồng ít nhất một trong các lớp lồng nhau.

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

Tôi cần một tài liệu tham khảo về phía trước như:

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

Cách giải quyết của tôi là:

class IDontControl_Nested; // Forward reference to distinct name.

Sau này khi tôi có thể sử dụng định nghĩa đầy đủ:

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

Kỹ thuật này có thể sẽ rắc rối hơn giá trị của nó nếu có các hàm tạo phức tạp hoặc các hàm thành viên đặc biệt khác không được kế thừa trơn tru. Tôi có thể tưởng tượng ma thuật mẫu nhất định phản ứng xấu.

Nhưng trong trường hợp rất đơn giản của tôi, nó dường như làm việc.

Nếu bạn thực sự muốn tránh # bao gồm tệp tiêu đề khó chịu trong tệp tiêu đề của mình, bạn có thể làm điều này:

tập tin hpp:

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

tập tin cpp

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

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

Nhưng sau đó:

1. bạn sẽ phải chỉ định loại nhúng tại thời điểm cuộc gọi (đặc biệt nếu chức năng của bạn không nhận bất kỳ tham số nào của loại được nhúng)
2. chức năng của bạn không thể là ảo (vì nó là một mẫu)

Vì vậy, yeah, đánh đổi ...

Điều này có thể được thực hiện bằng cách chuyển tiếp khai báo lớp bên ngoài như một không gian tên .

Ví dụ: Chúng ta phải sử dụng một lớp lồng nhau khác :: A :: Nested in other_a.h, nằm ngoài tầm kiểm soát của chúng ta.

những người khác_a.h

namespace others {
struct A {
    struct Nested {
        Nested(int i) :i(i) {}
        int i{};
        void print() const { std::cout << i << std::endl; }
    };
};
}

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

Tôi sẽ không gọi đây là câu trả lời, nhưng dù sao cũng là một phát hiện thú vị: Nếu bạn lặp lại tuyên bố về cấu trúc của mình trong một không gian tên gọi là C, mọi thứ đều ổn (ít nhất là trong gcc). Khi định nghĩa lớp của C được tìm thấy, nó dường như âm thầm ghi đè lên không gian tên 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;
}

Đây sẽ là một cách giải quyết (ít nhất là cho vấn đề được mô tả trong câu hỏi - không phải cho vấn đề thực tế, tức là khi không có quyền kiểm soát định nghĩa về 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
}

Nếu bạn có quyền truy cập để thay đổi mã nguồn của lớp C và D, thì bạn có thể tách riêng lớp D và nhập một từ đồng nghĩa cho nó trong lớp C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;