嵌套的 ClassesStructures

classstruct 本身也可以包含另一个 class / struct 定义,称为嵌套类; 在这种情况下,包含类被称为封闭类。嵌套类定义被认为是封闭类的成员,但在其他方面是分开的。

struct Outer {
    struct Inner { };
};

从封闭类的外部,使用范围运算符访问嵌套类。但是,从封闭类内部可以使用嵌套类而不使用限定符:

struct Outer {
    struct Inner { };

    Inner in;
};

// ...

Outer o;
Outer::Inner i = o.in;

与非嵌套的 class / struct 一样,成员函数和静态变量可以在嵌套类中定义,也可以在封闭名称空间中定义。但是,它们不能在封闭类中定义,因为它被认为是与嵌套类不同的类。

// 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() {}

与非嵌套类一样,嵌套类可以在以后声明和定义,前提是它们在直接使用之前定义。

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

在 C++ 11 之前,嵌套类只能访问封闭类中的类型名称,static 成员和枚举器; 封闭类中定义的所有其他成员都是禁止的。

Version >= C++ 11

从 C++ 11 开始,嵌套类及其成员被视为封闭类的 friends,并且可以根据通常的访问规则访问其所有成员; 如果嵌套类的成员需要能够评估封闭类的一个或多个非静态成员,则必须将它们传递给实例:

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

相反,封闭类被视为嵌套类的朋友,因此在未明确授予权限的情况下无法访问其私有成员。

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.
    }
};

嵌套类的朋友不会自动被视为封闭类的朋友; 如果他们也需要成为封闭类的朋友,则必须单独声明。相反,由于封闭类不会自动被视为嵌套类的朋友,封闭类的朋友也不会被视为嵌套类的朋友。

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

与所有其他类成员一样,如果嵌套类具有公共访问权限,则只能从类外部命名。但是,只要你没有明确命名它们,就可以访问它们而不管访问修饰符。

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.
oi.func();                     // Good.
Outer::make_Inner().func();    // Good.

你还可以为嵌套类创建类型别名。如果封闭类中包含类型别名,则嵌套类型和类型别名可以具有不同的访问修饰符。如果类型别名在封闭类之外,则它要求嵌套类或其中的 typedef 是公共的。

class Outer {
    class Inner_ {};

  public:
    typedef Inner_ Inner;
};

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

// ...

Outer::Inner  oi; // Good.
Outer::Inner_ oi; // Error.
ImOut         oi; // Good.

与其他类一样,嵌套类既可以从其他类派生,也可以从其他类派生。

struct Base {};

struct Outer {
    struct Inner : Base {};
};

struct Derived : Outer::Inner {};

通过允许程序员根据需要更新嵌套类,这在封闭类派生自另一个类的情况下非常有用。这可以与 typedef 结合使用,为每个封闭类的嵌套类提供一致的名称:

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() {}

// ...

// Calls BaseOuter::BaseInner_::do_something();
BaseOuter* b = new BaseOuter;
BaseOuter::Inner& bin = b->getInner();
bin.do_something();
b->getInner().do_something();

// Calls DerivedOuter::DerivedInner_::do_something();
BaseOuter* d = new DerivedOuter;
BaseOuter::Inner& din = d->getInner();
din.do_something();
d->getInner().do_something();

在上面的例子中,BaseOuterDerivedOuter 分别提供成员类型 Inner,分别为 BaseInner_DerivedInner_。这允许在不破坏封闭类的接口的情况下导出嵌套类型,并允许以多态方式使用嵌套类型。