Chuyển tiếp tuyên bố của các loại/lớp lồng nhau trong C++

Question

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 một tên lớp:

class A; 

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

class C::D; 

Bất kỳ ý tưởng nào?

Answer 1

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 bỏ ít nhất một trong các lớp lồng nhau.

Answer 2

Tôi sẽ không gọi đây là câu trả lời, nhưng dù sao tìm kiếm thú vị: Nếu bạn lặp lại khai báo cấu trúc của bạn trong một không gian tên gọi là C, mọi thứ đều ổn (ít nhất là gcc). Khi định nghĩa lớp của C được tìm thấy, nó có vẻ âm thầm ghi đè lên C. namspace

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

Answer 3

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

tôi cần một tham chiếu về phía trước như:

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

workaround của tôi là:

class IDontControl_Nested; // Forward reference to distinct name. 

Sau đó 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ẽ gặp nhiều rắc rối hơn giá trị 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 thuận lợi. Tôi có thể tưởng tượng một số ma thuật mẫu nhất định phản ứng nặng nề.

Nhưng trong trường hợp rất đơn giản của tôi, có vẻ như nó hoạt động.

Answer 4

Nếu bạn thực sự muốn tránh #including file header khó chịu trong tập tin tiêu đề của bạn, bạn có thể làm điều này:

hpp file:

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 xác định loại nhúng vào thời điểm cuộc gọi (đặc biệt nếu chức năng của bạn không mất bất kỳ thông số của các loại nhúng)
2. chức năng của bạn không thể ảo (vì nó là một mẫu)

Vì vậy, vâng, sự cân bằng ...

Answer 5

Đây sẽ là một giải pháp (í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 của 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 
}