关于++i与i++以及静态成员变量与非静态成员变量新手疑惑的地方

1。++i与i++的编译时区别

          先看一个例子：i++先运算再取值

                               public static void main（string []args）{

                                                             int x= 5;

                                                               console.writeline((x++)+(x++)+(x++));

                                                                int y =(x++)+(x++)+(x++)

                                                               console.writeline(y);

}

运行结果为  18

                       27

                  其实编译的过程是这样的，编译器先对整个表达式进行扫描，先把x的原值取出来，先对表达式求解后，在对每个x进行++操作

                   ++i先取值再运算

                                              public static void main（string []args）{

                                                             int x= 5;

                                                              int y = x++;

                                                             console.writeline(y);

                                                            y=++x;

                                                          console.writeline(y); 

}

输出结果 5

                 7

2。静态域与非静态域

  若将一个域声明为静态的，无论建立多少个该类的实例，内存中只存在一个静态的数据拷贝当这个类的第一个实例建立时，域被初始化，以后再进行类的实例化时不再对其进行初始化，所有属于这个类的实例共享这个副本，与之相反非静态域在类的每次实例化时，每个实例都拥有单独的拷贝

   class Program
    {

                    public class Count{
                                           static int count;
                                           int number;
                                           public Count() {
                                                       count= count + 1;
                                                       number = count;
                                    }
                                         public void show() {
                                                        Console.WriteLine("ob{0}:count={1}",number,count);
        }
        static void Main(string[] args)
        {
                        Count a = new Count();

                        //Count被实例化count =1；number =1；
                         a.show();

                        Console.WriteLine();

                        Count  b = new Count();

                         //Count再次实例化后 count =2，当调用a.show（）,因为count 为静态域所以他们共享一个内存副本，

                    // 所以此时a.show()里的count值也变为2所以输出为number=1，count=2而b.show（）此时输出number =2 count =2

                        a.show();

                        b.show();
                       Console.WriteLine();

                       Count c = new Count();

              // 同上分析
                       a.show();
                       b.show();
                       c.show();
                       Console.ReadKey();
        }
    }
}

输出运行的结果是：//第一次实例Count时

                                    ob1:count =1 

                                     //第二次实例Count时

                                     ob1 :count =2;

                                     ob2:count=2

                                    //第三次实例Count时

                                      ob1:count=3

                                      ob2:count =3

                                       ob3:count =3

上面例子类Count中域count被声明为静态的，为所有类的实例所共享类每进行一次实例化，它的值就加1，因而可以对系统中类的实例数进行计数

域number用来存放当前实例的编号，当类被实例后在构造函数中对编号进行赋值，从而可以看出实例化的顺序