Declarações de classe aninhada

Uma classe pode ser declarada dentro do escopo de outra classe.Essa classe é chamada uma "classe de aninhadas". Classes aninhadas são considerados dentro do escopo da classe delimitador e estão disponíveis para uso dentro desse escopo.Para consultar uma classe aninhada de um escopo diferente de seu escopo de fechamento imediato, você deve usar um nome totalmente qualificado.

O exemplo a seguir mostra como declarar classes aninhadas:

// nested_class_declarations.cpp
class BufferedIO
{
public:
   enum IOError { None, Access, General };

   // Declare nested class BufferedInput.
   class BufferedInput
   {
   public:
      int read();
      int good()
      {
         return _inputerror == None;
      }
   private:
       IOError _inputerror;
   };

   // Declare nested class BufferedOutput.
   class BufferedOutput
   {
      // Member list
   };
};

int main()
{
}

BufferedIO::BufferedInpute BufferedIO::BufferedOutput são declaradas dentro de BufferedIO.Esses nomes de classes não são visíveis fora do escopo da classe BufferedIO.No entanto, um objeto do tipo BufferedIO não contém todos os objetos dos tipos de BufferedInput ou BufferedOutput.

Classes aninhadas diretamente podem usar nomes, nomes de tipos, nomes de membros estáticos e enumeradores apenas da classe delimitador.Para usar nomes de outros membros da classe, você deve usar ponteiros, referências ou nomes de objeto.

No precedente BufferedIO por exemplo, a enumeração IOError podem ser acessados diretamente por funções de membro nas classes aninhadas, BufferedIO::BufferedInput ou BufferedIO::BufferedOutput, conforme mostrado na função good.

Observação
Classes aninhadas declarar apenas tipos dentro do escopo de classe.Eles fazem não causa contido objetos da classe aninhada a ser criado.O exemplo anterior declara duas classes aninhadas, mas não declarar quaisquer objetos desses tipos de classe.

Uma exceção para a visibilidade do escopo de uma declaração de classe aninhada é quando um nome de tipo é declarado em conjunto com uma declaração de reenvio.Nesse caso, o nome da classe declarado pela declaração de encaminhamento é visível fora da classe delimitador, com seu escopo definido para ser o escopo de classe não menor fechamento.Por exemplo:

// nested_class_declarations_2.cpp
class C
{
public:
    typedef class U u_t; // class U visible outside class C scope
    typedef class V {} v_t; // class V not visible outside class C
};

int main()
{
    // okay, forward declaration used above so file scope is used
    U* pu;

    // error, type name only exists in class C scope
    u_t* pu2; // C2065

    // error, class defined above so class C scope
    V* pv; // C2065

    // okay, fully qualified name
    C::V* pv2;
}

Consulte também

Referência

Classes, estruturas e uniões