Come posso inoltrare una classe interna? [duplicare]

Question

  

Possibile duplicato:
   Dichiarazione a termine di tipi / classi nidificati in C ++

Ho una lezione del genere ...

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

    ...
};

Altrove, voglio passare un Container :: Iterator per riferimento, ma non voglio includere il file di intestazione. Se provo a dichiarare in avanti la classe, ottengo errori di compilazione.

class Container::Iterator;

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

Compilando il codice sopra riportato ...

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 questa classe in modo da non dover includere il file header che dichiara la classe Iterator?

Answer 1

Questo semplicemente non è possibile. Non è possibile inoltrare una struttura nidificata all'esterno del contenitore. Puoi solo inoltrarlo dichiarandolo nel contenitore.

Dovrai eseguire una delle seguenti operazioni

• Rendi la classe non nidificata
• Modifica il tuo ordine di dichiarazione in modo che la classe nidificata sia prima definita per intero
• Crea una classe base comune che può essere utilizzata sia nella funzione che implementata dalla classe nidificata.

Answer 2

Non credo che dichiarare in avanti la classe interna su una classe incompleta funziona (perché senza la definizione della classe, non c'è modo di sapere se in realtà è una classe interna). Quindi dovrai includere la definizione di Contenitore, con una classe interna dichiarata in avanti:

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 di dichiarare in avanti e includerli entrambi)

Answer 3

Non so come fare esattamente quello che vuoi, ma ecco una soluzione alternativa, se sei disposto a utilizzare i modelli:

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

---

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

}

---

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

Speriamo che questo idioma possa esservi utile (e spero che il vostro compilatore sia basato su EDG e implementa l'esportazione;)).