c++嵌套类

Ex:

class A
{
public:  
    static int a;
    class A1
    {
        void output()
        {
          cout<<a<<endl; //instead of A::a;
        }
    };
  
};
int A::a;

可见，类 A1 嵌入A后访问A的静态变量不写外围域没有任何问题，从编译的角度看，此时位于A::的作用域内，在符号表中是可以找到a的(注意，a必须为static的)。这一点，与分开写的两个类明显不同

还有一个特殊之处，见如下代码：

Ex:

class A
{
private:
    int a;
    class A1
    {
        void output(A aObject)
        {
          cout<<aObject.a<<endl; //instead of A::a;
        }
    };
  
};

这段代码在VC中不能编译通过，但在DEV－C++是可以的，也就是不同的编译对于嵌套类是否能访问外围类的私有成员的定义是不一致的。

嵌套类的不同作用域同名问题

class A
{
public:  
    static int a;
    class A1
    {
        static int a;
        int    void output()
        {
          cout<<a<<endl; //instead of A::a;
        }
    };
  
};
int A::a=3;
int A::A1::a=4;

输出内部的a没有问题，如果要访问外部的,使用A::a指明作用域就可以,而且在嵌套类中，可以定义静态的成员。
用类似A::A1::a就可以访问.
先看一下Java的情况
Ex：

// this is a Java class 
class A
{
    private int c=2;
    class A1
    {
        int c=3;
        void output()
        {
            System.out.println(this.c);
            System.out.println(A.this.c);
        }
    }
}

由定义就可看出，Java的定义是动态定义的，是基于this指针的,因此，嵌套类不只在语法上，在语义上也有隶属关系，外围类的成员，包含私有成员，对于内部类也是可见的。因此内部非Static的类不能有Static成员，且这样的内部类只有在外层的对象建立后才能对建立，所以你可以这么建立对象：
Ex：

 A a = new A();
 A.A1 aa = a.new A1();

或者:
Ex:
 

A.A1 aa = new A().new A1(); //使用匿名对象

如果是静态嵌套类
Ex：

 

// this is a Java class 
class A
{
    private int c=2; //(1)
    static class A1
    {
      static int c=3;
        void output()
        {
            //System.out.println(this.c); //work well <--> A.A1.c; 这个结果由编译静态成生和动态加载相对地址理论轻松解释
            //System.out.println(A.this.c);// (can't work) ，很明显要求外围对象存在，把(1)改成static 的可以通过
            System.out.println(c);  //work well 
        }
    }
}

对比上面Java的定义,可见C++中的黓认行为和Java中的静态类相似，由此，可以猜出C++中的类是做静态存储的。因此，可以轻松的得出如下语句也是可以的：

Ex:
//C++
A::A1 * a = new A::A1();