Come posso dichiarare una class interiore?

Possibile duplicato:
Dichiarazione anticipata di tipi / classi annidati in C ++

Ho una class come questa …

class Container { public: class Iterator { ... }; ... }; 

Altrove, voglio passare un container :: Iterator per riferimento, ma non voglio includere il file di intestazione. Se provo ad inoltrare la class, ottengo errori di compilazione.

 class Container::Iterator; class Foo { void Read(Container::Iterator& it); }; 

La compilazione del codice sopra dà …

 test.h:3: error: 'Iterator' in class 'Container' does not name a type test.h:5: error: variable or field 'Foo' declared void test.h:5: error: incomplete type 'Container' used in nested name specifier test.h:5: error: 'it' was not declared in this scope 

Come posso inoltrare la dichiarazione di questa class in modo da non dover includere il file di intestazione che dichiara la class Iterator?

Questo semplicemente non è ansible. Non è ansible inoltrare la dichiarazione di una struttura nidificata all’esterno del contenitore. È ansible inoltrare solo dichiararlo all’interno del contenitore.

Avrai bisogno di fare una delle seguenti azioni

  • Rendi la class non annidata
  • Cambia il tuo ordine di dichiarazione in modo che la class annidata sia completamente definita per prima
  • Creare una class base comune che possa essere utilizzata sia nella funzione sia implementata dalla class nidificata.

Non credo che in avanti dichiarando la class interiore di un lavoro di class incompleto (perché senza la definizione di class, non c’è modo di sapere se esiste effettivamente una class interiore). Quindi dovrai includere la definizione di Container, con una class interna dichiarata inoltrata:

 class Container { public: class Iterator; }; 

Quindi, in un’intestazione separata, implementare Container :: Iterator:

 class Container::Iterator { }; 

Quindi # include solo l’intestazione del contenitore (o non preoccuparti della dichiarazione in avanti e includi solo entrambi)

Non conosco alcun modo per fare esattamente quello che vuoi, ma ecco una soluzione alternativa, se sei disposto a utilizzare i modelli:

 // Foo.h struct Foo { export template void Read(T it); }; 

 // Foo.cpp #include "Foo.h" #include "Container.h" /* struct Container { struct Inner { }; }; */ export template<> void Foo::Read(Container::Inner& it) { } 

 #include "Foo.h" int main() { Foo f; Container::Inner i; f.Read(i); // ok f.Read(3); // error } 

Spero che questo idioma possa essere di qualche utilità per te (e spero che il tuo compilatore sia basato su EDG e implementa l’esportazione;)).