Como faço para declarar frente uma classe interna? [duplicado]

Question

Duplicate possíveis:
declaração Atacante de tipos aninhados / classes em C ++

Eu tenho uma classe assim ...

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

    ...
};

Em outro lugar, eu quero passar uma Container :: Iterator por referência, mas eu não quero incluir o arquivo de cabeçalho. Se eu tentar declarar a frente da classe, recebo erros de compilação.

class Container::Iterator;

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

Compilando o código acima 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

Como posso declarar frente esta classe para que eu não tenho que incluir o arquivo de cabeçalho que declara a classe Iterator?

Answer 1

Isso simplesmente não é possível. Você não pode declarar frente uma estrutura aninhada fora do recipiente. Você pode apenas encaminhar declará-la dentro do recipiente.

Você vai precisar fazer um dos seguintes

• Verifique a classe não-aninhados
• Altere seu pedido de declaração para que a classe aninhada é totalmente definido pela primeira vez
• Criar uma classe base comum que pode ser tanto usado na função e implementada pela classe aninhada.

Answer 2

Eu não acredito frente declarando classe interna de em um obras classe incompletos (porque sem a definição de classe, não há nenhuma maneira de saber se há realmente é uma classe interna). Então você vai ter que incluir a definição de Container, com uma classe interna para frente declarou:

class Container {
public:
    class Iterator;
};

Então, em um cabeçalho separado, implementar Container :: Iterator:

class Container::Iterator {
};

Em seguida, # incluí apenas o cabeçalho recipiente (ou não se preocupar com a frente declarar e apenas incluem ambos)

Answer 3

Não conheço nenhuma maneira de fazer exatamente o que você quiser, mas aqui está uma solução alternativa, se você estiver disposto a usar modelos:

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

Esperamos que este idioma pode ser de alguma utilidade para você (e esperemos que o seu compilador é baseado em EDG e implementos exportação;)).