Section 34.10: Nested Classes/Structures

A class or struct can also contain another class/struct definition inside itself, which is called a "nested class"; in this situation, the containing class is referred to as the "enclosing class". The nested class definition is considered to be a member of the enclosing class, but is otherwise separate.

struct Outer {

struct Inner { };

};

From outside of the enclosing class, nested classes are accessed using the scope operator. From inside the enclosing class, however, nested classes can be used without qualifiers:

struct Outer {

struct Inner { };

Inner in;

};

// ...

Outer o;

Outer::Inner i = o.in;

As with a non-nested class/struct, member functions and static variables can be defined either within a nested class, or in the enclosing namespace. However, they cannot be defined within the enclosing class, due to it being considered to be a di erent class than the nested class.

// Bad. struct Outer {

struct Inner {

void do_something();

};

void Inner::do_something() {}

};

// Good. struct Outer {

struct Inner {

void do_something();

};

};

void Outer::Inner::do_something() {}

As with non-nested classes, nested classes can be forward declared and defined later, provided they are defined before being used directly.

class Outer { class Inner1; class Inner2;

class Inner1 {};

Inner1 in1;

Inner2* in2p;

public: Outer(); ~Outer();

};

class Outer::Inner2 {};

Outer::Outer() : in1(Inner1()), in2p(new Inner2) {} Outer::~Outer() {

if (in2p) { delete in2p; }

}

Version < C++11

Prior to C++11, nested classes only had access to type names, static members, and enumerators from the enclosing class; all other members defined in the enclosing class were o -limits.

Version ≥ C++11

As of C++11, nested classes, and members thereof, are treated as if they were friends of the enclosing class, and can access all of its members, according to the usual access rules; if members of the nested class require the ability to evaluate one or more non-static members of the enclosing class, they must therefore be passed an instance:

class Outer { struct Inner {

int get_sizeof_x() {

return sizeof(x); // Legal (C++11): x is unevaluated, so no instance is required.

}

int get_x() {

return x; // Illegal: Can't access non-static member without an instance.

}

int get_x(Outer& o) {

return o.x; // Legal (C++11): As a member of Outer, Inner can access private members.

}

};

int x;

};

Conversely, the enclosing class is not treated as a friend of the nested class, and thus cannot access its private members without explicitly being granted permission.

class Outer { class Inner {

// friend class Outer;

int x;

};

Inner in;

public:

int get_x() {

return in.x; // Error: int Outer::Inner::x is private. // Uncomment "friend" line above to fix.

}

};

Friends of a nested class are not automatically considered friends of the enclosing class; if they need to be friends of the enclosing class as well, this must be declared separately. Conversely, as the enclosing class is not automatically considered a friend of the nested class, neither will friends of the enclosing class be considered friends of the nested class.

class Outer {

friend void barge_out(Outer& out, Inner& in);

class Inner {

friend void barge_in(Outer& out, Inner& in);

int i;

};

int o;

};

void barge_in(Outer& out, Outer::Inner& in) { int i = in.i; // Good.

int o = out.o; // Error: int Outer::o is private.

}

void barge_out(Outer& out, Outer::Inner& in) {

int i = in.i; // Error: int Outer::Inner::i is private. int o = out.o; // Good.

}

As with all other class members, nested classes can only be named from outside the class if they have public access. However, you are allowed to access them regardless of access modifier, as long as you don't explicitly name them.

class Outer { struct Inner {

void func() { std::cout << "I have no private taboo.\n"; }

};

public:

static Inner make_Inner() { return Inner(); }

};

// ...

Outer::Inner oi; // Error: Outer::Inner is private.

auto oi = Outer::make_Inner(); // Good.

You can also create a type alias for a nested class. If a type alias is contained in the enclosing class, the nested type and the type alias can have di erent access modifiers. If the type alias is outside the enclosing class, it requires that either the nested class, or a typedef thereof, be public.

class Outer {

class Inner_ {};

public:

typedef Inner_ Inner;

};

typedef Outer::Inner ImOut; // Good. typedef Outer::Inner_ ImBad; // Error.

As with other classes, nested classes can both derive from or be derived from by other classes.

struct Base {};

struct Outer {

struct Inner : Base {};

};

struct Derived : Outer::Inner {};

This can be useful in situations where the enclosing class is derived from by another class, by allowing the programmer to update the nested class as necessary. This can be combined with a typedef to provide a consistent name for each enclosing class' nested class:

class BaseOuter { struct BaseInner_ {

virtual void do_something() {} virtual void do_something_else();

} b_in;

public:

typedef BaseInner_ Inner;

virtual ~BaseOuter() = default;

virtual Inner& getInner() { return b_in; }

};

void BaseOuter::BaseInner_::do_something_else() {}

// ---

class DerivedOuter : public BaseOuter {

// Note the use of the qualified typedef; BaseOuter::BaseInner_ is private. struct DerivedInner_ : BaseOuter::Inner {

void do_something() override {} void do_something_else() override;

} d_in;

public:

typedef DerivedInner_ Inner;

BaseOuter::Inner& getInner() override { return d_in; }

};

void DerivedOuter::DerivedInner_::do_something_else() {}

// ...