static 变量和static 构造函数 以及对象初始化顺序

1.静态成员变量从属于一个类而非某个具体的对象,它的值被该类的所有对象所共享。
2.public的静态成员,可以由类名（或对象名）直接通过 “.” 操作符引用。

先初始化 静态变量 然后运行静态构造函数

 

#region//类A B中都含有static变量 构造函数
    class A
    {
        public static int X;
        static A()
        {
            X = B.Y + 1;
        }
        //static void Main()
        //{
        //    Console.WriteLine("X={0},Y={1}", A.X, B.Y);//x=2,y=1
        //    Console.ReadLine();

        //}
    }
    class B
    {
        public static int Y = A.X + 1;
        static B() { }
        static void Main()
        {
            Console.WriteLine("X={0},Y={1}", A.X, B.Y);//x=1,y=2
            Console.ReadLine();

        }
    }
    #endregion

 

解释：程序入库Main()位于类B中，因此类B首先进行初始化，次序为 int Y, 在对Y的赋值中使用到了类A，所以跳转到类A中，同样类A中的成员进行初始化，自域X开始这里为0，到静态构造函数X=B.Y+1,此时B.Y=0，所以X=1;然后->public static int Y = A.X + 1; ---》 得出Y=2.

例子2.

Code
 #region//类Class1中既有 static变量和构造函数也有非 static的构造函数
    class Class1
    {
        public static int count = 0;
        static Class1()
        {
            count++;
        }
        public Class1()
        {
            count++;
        }
    }
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            Class1 c1 = new Class1();
            Class1 c2 = new Class1();

            Console.WriteLine(Class1.count);//Class1.count=3
            Console.ReadLine();

        }
    }

 

解释：在 Class1 c1 = new Class1();实例化c1的时候，到Class1中实例化成员，次序是static变量，static构造函数，最后是非static构造函数；此时count=2;

在 Class1 c2 = new Class1(); 实例化c2时，因为static的变量，构造函数不再被执行，所以只执行非静态构造函数，所以这里count++一次；count=3.

 

1using System;
2using System.Collections.Generic;
3using System.Text;
4
5namespace ConsoleApplication1 {
6    class Program {
7        static void Main(string[] args) {
8             A a = new B();
9             Console.ReadLine();
10         }
11     }
12
13    class A {
14        //调用到这个构造函数时：x=1,y=0
15        public A() {
16            //该函数在B类中被重载，因此输出 x=1,y=0
17             Console.WriteLine("在A类的构造函数中");
18             PrintFields();
19         }
20        public virtual void PrintFields() { }
21     }
22    class B : A {
23        //派生类变量/静态成员的执行顺序优于基类
24        //先变量，因此,x=1,y=0
25        int x = 1;
26        int y;
27        //后构造函数，此时，先调用基类构造函数
28        public B() {
29            //运行到这里时，A类构造函数已经执行完毕
30             y = -1;
31             Console.WriteLine("在B类的构造函数中");
32            //此时 x=1,y=-1
33             PrintFields();
34         }
35        public override void PrintFields() {
36             Console.WriteLine("x={0},y={1}", x, y);
37         }
38     }
39}

 

这里备忘一下c#对象初始化顺序及C++对象初始化顺序：

 

C#对象初始化

1.     先变量后构造函数。变量先被初始化,然后构造函数被执行

2.     先静态化后实例化。当一个类被访问时,静态变量和构造函数最先被初始化.接着是对象的实例化变量和构造函数被初始化

3.     先派生类后基类。对于变量和静态构造函数,派生对象在基对象之前被初始化.比如C类派生自B类,B类派生自A类,那么变量和静态构造函数被初始化次序是C-B-A.

4.     除了实例构造函数。对于实例构造函数,基类构造函数在派生类构造函数之前执行,实例构造函数被执行次序是A-B-C.

5.     不要假定变量的次序。Fields依据它们在源文件中的声明的顺序依次初始化.然而,自从程序员和工具可以随意安排变量的声明后,你不应该在依靠变量任何特别的次序初始化

6.     对虚方法用两个阶段的构建。避免从一个构造器调用虚方法. 如果在初始化一个对象时需要调用一些虚方法,应在完整构造该对象的地方使用两阶段的构建，并随后调用已构造对象的初始化方法。

 

C++构造函数调用顺序

1.     如果类里面有成员类，成员类的构造函数优先被调用；

2.     创建派生类的对象，基类的构造函数优先被调用（也优先于派生类里的成员类）；

3.     基类构造函数如果有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序而不是它们在成员初始化表中的顺序；

4.     成员类对象构造函数如果有多个成员类对象，则构造函数的调用顺序是对象在类中被声明的顺序而不是它们出现在成员初始化表中的顺序；

5.     派生类构造函数，作为一般规则派生类构造函数应该不能直接向一个基类数据成员赋值而是把值传递给适当的基类构造函数,否则两个类的实现变成紧耦合的（tightly coupled）将更加难于正确地修改或扩展基类的实现。（基类设计者的责任是提供一组适当的基类构造函数）

文章来源：http://hi.baidu.com/ydalbj/blog/item/c68733a8d519f6bbca130cdc.html