Meneruskan deklarasi tipe / kelas bersarang di C ++

Saya baru-baru ini terjebak dalam situasi seperti ini:

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

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

Biasanya Anda dapat mendeklarasikan nama kelas:

class A;

Tapi Anda tidak bisa meneruskan menyatakan tipe bersarang, berikut ini menyebabkan kesalahan kompilasi.

class C::D;

Ada ide?

Anda tidak dapat melakukannya, itu adalah lubang dalam bahasa C ++. Anda harus melepaskan sarang setidaknya dari salah satu kelas bersarang.

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

Saya membutuhkan referensi ke depan seperti:

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

Solusi saya adalah:

class IDontControl_Nested; // Forward reference to distinct name.

Kemudian ketika saya bisa menggunakan definisi lengkap:

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

Teknik ini mungkin akan lebih merepotkan daripada nilainya jika ada konstruktor yang rumit atau fungsi anggota khusus lainnya yang tidak diwarisi dengan lancar. Saya bisa membayangkan sihir template tertentu bereaksi buruk.

Tetapi dalam kasus saya yang sangat sederhana, tampaknya berhasil.

Jika Anda benar-benar ingin menghindari #termasuk file header jahat di file header Anda, Anda bisa melakukan ini:

file hpp:

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

file cpp

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

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

Tapi kemudian:

1. Anda harus menentukan jenis tertanam pada waktu panggilan (terutama jika fungsi Anda tidak mengambil parameter dari jenis tertanam)
2. fungsi Anda tidak bisa virtual (karena itu adalah templat)

Jadi, yeah, pengorbanan ...

Ini dapat dilakukan dengan meneruskan mendeklarasikan kelas luar sebagai namespace .

Contoh: Kita harus menggunakan kelas bersarang lain :: A :: Bersarang di others_a.h, yang di luar kendali kami.

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

Saya tidak akan menyebut ini sebagai jawaban, tetapi tetap saja merupakan temuan yang menarik: Jika Anda mengulangi deklarasi struct Anda dalam namespace yang disebut C, semuanya baik-baik saja (setidaknya dalam gcc). Ketika definisi kelas dari C ditemukan, tampaknya secara diam-diam menimpa 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;
}

Ini akan menjadi solusi (setidaknya untuk masalah yang dijelaskan dalam pertanyaan - bukan untuk masalah aktual, yaitu, ketika tidak memiliki kendali atas definisi 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
}

Jika Anda memiliki akses untuk mengubah kode sumber kelas C dan D, maka Anda dapat mengambil kelas D secara terpisah, dan memasukkan sinonim untuknya di kelas C:

class CD {

};

class C {
public:

    using D = CD;

};

class CD;