Dichiarazioni di classi annidate
La classe può essere dichiarata con un'altra classe.Tale classe viene denominata “una classe annidata.„ Le classi annidate sono considerate nella classe interna e possono essere utilizzate all'interno di tale ambito.Per fare riferimento a una classe annidata da un ambito diverso dal relativo ambito che lo contiene immediato, è necessario utilizzare un nome completo.
Nell'esempio seguente viene illustrato come dichiarare le classi annidate:
// 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::BufferedInput e BufferedIO::BufferedOutput vengono dichiarati in BufferedIO.Questi nomi di classe non sono visibili all'ambito di classe BufferedIO.tuttavia, un oggetto di tipo BufferedIO non contiene alcun oggetto dei tipi BufferedInput o BufferedOutput.
Le classi annidate possono utilizzare direttamente i nomi, i nomi dei tipi, i nomi dei membri statici e gli enumeratori solo dalla classe interna.Per utilizzare i nomi degli altri membri della classe, è necessario utilizzare i puntatori, i riferimenti, o i nomi dell'oggetto.
Nel precedente BufferedIO esempio, l'enumerazione IOError è possibile accedere direttamente alle funzioni membro delle classi annidate, BufferedIO::BufferedInput o BufferedIO::BufferedOutput, come illustrato nella funzione good.
[!NOTA]
Le classi annidate dichiarano solo i tipi all'interno dell'ambito della classe.Non consentire agli oggetti contenuti della classe annidata a essere creati.Nell'esempio precedente viene dichiarata due classi annidate ma non dichiara gli oggetti di questi tipi di classe.
Un'eccezione alla visibilità dell'ambito di una dichiarazione di classe annidata è quando un nome di tipo viene dichiarato insieme a una dichiarazione con prototipo.In questo caso, il nome della classe dichiarata dalla dichiarazione con prototipo è visibile all'esterno della classe interna, con il relativo ambito definito essere il più piccolo ambito di inclusione non di classe.Di seguito è riportato un esempio:
// 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;
}