d嵌套同级类

原文
代码如下:

import std.stdio;

class a {

public:
     this(){}
    ~this(){}

    class b {
    public:
        this.outer.c C = new this.outer.c();
         this() {
                writeln(this.C.i);
        }
        ~this() {}

    }

    class c {
    public:
         this() {}
        ~this() {}
        int i = 10;
    }

}
int main () {
    int [int][int] test;
    test[0][20] = 19;
    writeln(Test[0][20]);
    a A = new A();
    a.b B = a.new a.b();
    return 0;
}

怎样才能让b和c类互相访问,并自由创建实例呢?谢谢
忽略错别字,你可试动和静:

class a
{ //outer

 static class b
 { // inner 1

   c C;
   this()
   {
     this.C = new c;
     //writeln(this.C.i);
   }
 }

 static class c
 { // inner 2
   int i = 10;
 }
}

int main ()
{
 int[21][1] test;
 test[0][20] = 19;

 assert(test[0][20] == 19);

 auto B = new a.b;
 auto C = new a.c;

 assert(B.C.i == 10);
 assert(C.i == 10);

 return 0;
}

你好,在this()函数中移动"new c"确实可以.
请解释"静"作用?再次感谢
这里
非静态嵌套类通过包含(叫环境指针的)额外隐藏成员来工作,如果在函数中嵌套,则它是外围函数的帧指针,如果在类中嵌套,则它是外围类实例的this引用.
实例化非静态嵌套类时,调用类的构造器前赋值环境指针,因此构造器可完全访问外围变量.只有在必要环境指针信息可用时,才能实例化非静态嵌套类.
再者.用初化器声明类字段时,在编译时运行该初化器.表明即使它确实工作,每个B实例都以精确的C对象开始(不是副本,是同一个).

这与许多按构造器的一部分,(并且在初化类时运行)初化式的其他语言不同.在D中仅按默认状态复制这些位到新内存中.

因此,不应该从非静态字段中初化类引用.如果修改了叫C的对象,所有B新实例引用该修改实例!
编译器不喜欢它的原因是,因为编译时它不知道如何初化(c),因为它需要外部类的环境指针.
只要把初化移到构造器中就可修复,不需要把它们变成静态的,现在,也许不想有个带引用外部类的嵌套类,此时,应该把它变成静态的.