在一个类中定义的类称为嵌套类，定义嵌套类的类称为外围类。

    定义嵌套类的目的在于隐藏类名，减少全局的标识符，从而限制用户能否使用该类建立对象。这样可以提高类的抽象能力，并且强调了两个类 (外围类和嵌套类) 之间的主从关系。下面是一个嵌套类的例子：

    1. class A
    2. 　{
    3. 　 public:
    4. 　　　class B
    5. 　　　{
    6. 　　　public:
    7. 　　　　　…
    8. 　　　private:
    9. 　　　　　…
    10. 　　　};
    11. 　　void f();
    12. 　private:
    13. 　　　int a;
    14. 　}

    其中，类 B 是一个嵌套类，类 A 是外围类，类 B 定义在类 A 的类体内。

    对嵌套类的若干说明：

    1、从作用域的角度看，嵌套类被隐藏在外围类之中，该类名只能在外围类中使用。如果在外围类的作用域内使用该类名时，需要加名字限定。

    2、从访问权限的角度来看，嵌套类名与它的外围类的对象成员名具有相同的访问权限规则。不能访问嵌套类的对象中的私有成员函数，也不能对外围类的私有部分中的嵌套类建立对象。

    3、嵌套类中的成员函数可以在它的类体外定义。

    4、嵌套类中说明的成员不是外围类中对象的成员，反之亦然。嵌套类的成员函数对外围类的成员没有访问权，反之亦然。国此，在分析嵌套类与外围类的成员访问关系时，往往把嵌套类看作非嵌套类来处理。这样，上述的嵌套类可写成如下格式：

    1. class A
    2. 　　{
    3. 　　public:
    4. 　　　　void f();
    5. 　　private:
    6. 　　　　int a;
    7. 　　};
    9. 　　class B
    10. 　　{
    11. 　　public:
    12. 　　　　…
    13. 　　private:
    14. 　　　　…
    15. 　　};

    由引可见，嵌套类仅仅是语法上的嵌入。

    5、在嵌套类中说明的友元对外围类的成员没有访问权。

    6、如果嵌套类比较复杂，可以只在外围类中对嵌套类进行说明，关于嵌套的详细的内容可在外围类体外的文件域中进行定义。

    7、嵌套类可以访问外围类的静态成员变量，即使它的访问权限是私有的。

    但是，如果一定要让嵌套类访问外围类，我们要采取什么样的办法？实际上实现的方法应该有很多种，这里介绍一种参见 com 实现中实现内嵌类访问外部类数据成员中所使用的方式，具体见《COM 本质论》。

    1. //嵌套类访问外围类中的成员变量
    4. class GH_A{
    5. 　　const static int s_data = 20;
    6. public:
    7. 　　int task_id;
    9. 　　class GH_B
    10. 　　{
    11. 　　public:
    12. 　　　　int attribute;
    13. 　　　　GH_A* parent;
    14. 　　　　GH_B(){
    15. 　　　　attribute = 5;
    16. 　　　　parent = (GH_A*)((char*)this-offsetof(GH_A,gh_b));
    17. 　　　　printf("外围类的private型静态变量：%d\n",s_data);
    18. 　　　　}
    19. 　　} gh_b;
    20. };
    22. 　　
    24. //嵌套类访问外围类成员变量的示例
    25. 　　GH_A aaaa;
    26. 　　aaaa.gh_b.parent->task_id = 16;
    27. 　　printf("外围类成员变量值被嵌套类访问并修改之后的值:%d\n",aaaa.task_id);
    28. 　　aaaa.task_id = aaaa.gh_b.attribute;
    29. 　　printf("嵌套类访问到外围类成员变量值:%d\n",aaaa.gh_b.parent->task_id);

    输出结果：

    C++嵌套类及对外围类成员变量的访问 - 图1

    这里，我们用到一个 C++ 库函数，原型是：

    1. size_t offsetof(
    2.       structName,
    3.       memberName 
    4. );

    以下是 MSDN 上的一些介绍：
    Parameters
    structName
    Name of the parent data structure.
    memberName
    Name of the member in the parent data structure for which to determine the offset.**Return Value
    offsetof returns the offset in bytes of the specified member from the beginning of its parent data structure. It is undefined for bit fields.
    **

    此外，再来介绍一下局部类
    　　在一个函数体内定义的类称为局部类。局部类中只能使用它的外围作用域中的对象和函数进行联系，因为外围作用域中的变量与该局部类的对象无关。局部类不能被外部所继承。在定义局部类时需要注意：局部类中不能说明静态成员函数，并且所有成员函数都必须定义在类体内。在实践中，局部类是很少使用的。** 下面是一个局部类的例子。

    1. int a;
    2. void fun()
    3. {
    4. static int s;
    5. class A
    6. {
    7. 　　public:
    8. 　　void init(int i) { s = i; }
    9. };
    10. A m;
    11. m.init(10);
    12. }
    14. // 局部类的另一个用途是用来实现类型转化，如下代码：
    16. class Interface
    17. {
    18. public:
    19.    virtual void Fun() = 0;  
    20. };
    22. template <class T, class P>
    23. Interface* MakeAdapter(const T& obj, const P& arg)
    24. {
    25.     int x;
    26.    class Local : public Interface
    27.    {
    28.    public:
    29.       Local(const T& obj, const P& arg)
    30.          : obj_(obj), arg_(arg) {}
    31.       virtual void Fun()
    32.       {
    33.           x = 100;
    34.          obj_.Call(arg_);
    35.       }
    36.    private:
    37.       T obj_;
    38.       P arg_;
    39.    };
    40.    return new Local(obj, arg);
    41. }

    参考：C++ 编程思想和网络文章, MSDN.
    https://www.cnblogs.com/RealOnlyme/archive/2012/06/14/2549156.html