C++变量的初始化方式

1. C++变量的初始化方式

首先把需要初始化的成员变量分为几类： ?  一般变量(int)
?  静态成员变量(static int)
?  常量(const int )
?  静态常量(static const int)
 对应的初始化方式是： ?  一般变量可以在初始化列表里或者构造函数里初始化，不能直接初始化或者类外初始化 ?  静态成员变量必须在类外初始化 ?  常量必须在初始化列表里初始化 ?  静态常量必须只能在定义的时候初始化(定义时直接初始化)  
举一个简单的例子： [cpp] view plaincopyprint? #include <iostream>    
#include <string>    
using namespace std;   
class Test   
{   
private:   
    int a;   
    static int b;   
    const int c;   
    static const int d=4;   
public:   
    Test():c(3)     //a(1)或者在初始化列表里初始化    
    {   
        a=1;   
    }   
};   
int Test::b=2;  
void main()   
{   
    Test t;   
}  

#include <iostream>   #include <string>   using namespace std;   class Test   {   private:       int a;       static int b;       const int c;       static const int d=4;   public:       Test():c(3)     //a(1)或者在初始化列表里初始化       {           a=1;       }   };   int Test::b=2;  void main()   {       Test t;   }

   

2. 类成员变量初始化顺序

C++

有如下几条：
1构造函数初始化列表的变量优先于构造函数（至少明显的写在前面）  (若都在初始化列表中初始化，则按声明顺序初始化，与初始化列表中的顺序无关) 2静态成员变量先于实例变量 3父类成员变量先于子类成员变量 4父类构造函数先于子类构造函数  举一个例子： [cpp] view plaincopyprint? #include <iostream>   
#include <string>   
using namespace std;  
class Test  
{  
public:  
    Test(string n)  
    {  
        cout<<n<<endl;  
    }  
};  
class Base  
{  
public:  
    static Test* a;  
    Test* b;  
    Test* c;  
    Base():b(new Test("b"))  
    {  
        c=new Test("c");  
    }  
    virtual ~Base()  
    {  
        if(a) delete a;//似乎是很欠妥的做法   
        if(b) delete b;  
        if(c) delete c;  
    }  
};  
Test* Base::a=new Test("a");  
class Derived:Base  
{  
public:  
    static Test* da;  
    Test* db;  
    Test* dc;  
    Derived():db(new Test("db"))  
    {  
        dc=new Test("dc");  
    }  
    ~Derived()  
    {  
        if(da) delete da;//似乎是很欠妥的做法   
        if(db) delete db;  
        if(dc) delete dc;  
    }  
};  
Test* Derived::da=new Test("da");  
  
void main()  
{  
    Derived d;  
}  

#include <iostream>  #include <string>  using namespace std;  class Test  {  public:   Test(string n)   {    cout<<n<<endl;   }  };  class Base  {  public:   static Test* a;   Test* b;   Test* c;   Base():b(new Test("b"))   {    c=new Test("c");   }   virtual ~Base()   {    if(a) delete a;//似乎是很欠妥的做法    if(b) delete b;    if(c) delete c;   }  };  Test* Base::a=new Test("a");  class Derived:Base  {  public:   static Test* da;   Test* db;   Test* dc;   Derived():db(new Test("db"))   {    dc=new Test("dc");   }   ~Derived()   {    if(da) delete da;//似乎是很欠妥的做法    if(db) delete db;    if(dc) delete dc;   }  };  Test* Derived::da=new Test("da");    void main()  {   Derived d;  }

结果是：

a
da
b
c
db
dc

 

java和C#语言

1   类成员变量初始化先于类的构造函数
2   静态成员变量先于实例变量
3   父类成员变量先于子类成员变量 （C#相反）
4   父类构造函数先于子类构造函数

举一个java的例子:

[java] view plaincopyprint? class Base  
{  
    public static Test a=new Test("a");  
    public static Test b;  
    public Test c=new Test("c");  
    public Test d;  
    static  
    {  
        b=new Test("b");  
    }  
    public Base()  
    {  
        d=new Test("d");  
    }  
    public static void main(String[] args) {  
        new Derived();  
    }  
}  
class Derived extends Base  
{  
    public static Test da=new Test("da");  
    public static Test db;  
    public Test dc=new Test("dc");  
    public Test dd;  
    static  
    {  
        db=new Test("db");  
    }  
    public Derived()  
    {  
        dd=new Test("dd");  
    }  
}  
  
class Test  
{  
    public Test (String name) {  
        System.out.println(name);  
    }  
}  

class Base  {   public static Test a=new Test("a");   public static Test b;   public Test c=new Test("c");   public Test d;   static   {    b=new Test("b");   }   public Base()   {    d=new Test("d");   }   public static void main(String[] args) {    new Derived();   }  }  class Derived extends Base  {   public static Test da=new Test("da");   public static Test db;   public Test dc=new Test("dc");   public Test dd;   static   {    db=new Test("db");   }   public Derived()   {    dd=new Test("dd");   }  }    class Test  {   public Test (String name) {    System.out.println(name);   }  }

运行结果是：

a

b
da
db
c
d
dc
dd