dichiarazione anticipata di tipi nidificati/classi in C++

Question

Recentemente ho avuto bloccato in una situazione come questa:

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

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

Di solito è possibile dichiarare un nome di classe:

class A; 

ma non è possibile in avanti dichiarare un tipo annidato, il seguente causa errore di compilazione.

class C::D; 

Qualche idea?

Answer 1

Non puoi farlo, è un buco nel linguaggio C++. Dovrai annullare la nidificazione di almeno una delle classi nidificate.

Answer 2

Non definirei questa risposta, ma comunque una scoperta interessante: Se si ripete la dichiarazione della propria struttura in uno spazio dei nomi chiamato C, tutto è a posto (in gcc almeno). Quando viene trovata la definizione della classe di C, sembra per sovrascrivere in silenzio il 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; 
} 

Answer 3

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

avevo bisogno di un riferimento in avanti come:

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

mia soluzione era:

class IDontControl_Nested; // Forward reference to distinct name. 

In seguito, quando ho potuto utilizzare la definizione completa:

Questa tecnica sarebbe probabilmente più problematica di quanto valga se esistessero costruttori complicati o altre funzioni membro speciali che non sono state ereditate senza problemi. Potrei immaginare che alcuni modelli di magia reagiscano male.

Ma nel mio caso molto semplice, sembra funzionare.

Answer 4

Se si vuole davvero evitare #including il file di intestazione brutto nel file di intestazione, si potrebbe fare questo:

file di HPP:

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

di file cpp

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

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

Ma poi:

1. si dovrà specificare il tipo incorporato in fase di chiamata (soprattutto se la vostra funzione non accetta parametri di tipo embedded)
2. la funzione non può essere virtuale (perché è un modello)

Quindi, sì, compromessi ...

Answer 5

Questa sarebbe una soluzione (almeno per il problema descritto nella domanda - non per il problema reale, vale a dire, quando non si ha il controllo sulla definizione di 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 
}