C++中各种类型的成员变量的初始化方法（mark-好）

刚才编程遇到这样一个问题:

class CA

{

public:

//正确

       static const int rate = 6;

//错误，const double类型成员不能包含类内初始值设定项,int就可以

       static const double rate = 6.5;

 

};

遂找到此篇文章，转载阅读之：

http://blog.csdn.net/yockie/article/details/7868068

C++类中各种不同类型成员根据是否static 、是否const类型的初始化方法不尽相同，写代码时经常搞乱，网上搜了一下资料，全部总结一下。

一、例子

[cpp]  view plain

1. -----------------Test.h----------------------------  
2.   
3. #pragma once  
4.   
5. class Test  
6. {  
7. private :  
8.       int   var1;  
9. //    int   var11= 4; 错误的初始化方法  
10.       const int   var2 ;  
11. //    const int   var22 =22222; 错误的初始化方法，const成员和引用成员必须在初始化列表中初始化（因为它们必须在定义时初始化）  
12.       static int   var3;  
13. //    static int   var3333=33333; 错误，只有静态常量成员才能直接赋值来初始化  
14.       static const int   var4=4444;  //正确，静态常量整数成员（此三个条件缺一不可）可以直接初始化  
15.       static const int   var44;  
16. public:  
17.       Test(void);  
18.        ~Test(void);  
19. };  

[cpp]  view plain

1. ----------Test.cpp----------------  
2.   
3. #include ".\test.h"  
4.   
5. int Test::var3 = 3333333; //静态成员的 正确的初始化方法  
6.   
7. //    int Test::var1 = 11111;; 错误 静态成员才能这样初始化  
8. //    int Test::var2 = 22222; 错误  
9. //    int Test::var44 = 44444; // 错误的方法，提示重定义，因为此var44与类中声明的var44的修饰符不相同  
10. const int Test::var44 = 44444; //正确  
11.   
12. Test::Test(void) :var1(11111),var2(22222)   //正确的初始化方法 ， var3(33333) 不能在这里初始化  
13. {  
14.     var1 =11111; //正确, 普通变量也可以在这里初始化  
15.     //var2 = 222222; 错误，因为const常量不能赋值，只能在 构造函数的初始化列表 那里初始化  
16.             
17.     var3 =33;   //经测试，（1）若已经正确定义了var3，即在类定义外部“int Test::var3;”或“int Test::var3=3333333;”，  
18.                 //则此处赋值（注意是赋值，不是初始化）是正确的 ;  
19.                 //（2）若按（1）所说的正确定义var3，则此处赋值是错误的，因为var3尚未定义。  
20. }  
21.   
22. Test::~Test(void)  

二、简单概括
有些成员变量的数据类型比较特别，它们的初始化方式也和普通数据类型的成员变量有所不同。这些特殊的类型的成员变量包括：
    a. 常量型成员变量：如 const int temp;
    b. 引用型成员变量：如 int & temp;
    c. 静态成员变量：如 static int temp;
    d. 整型静态常量成员变量：如 static const int temp;
    e. 非整型静态常量成员变量：如 static const double temp;

    对于常量型成员变量和引用型成员变量的初始化，必须通过构造函数初始化列表的方式进行。在构造函数体内给常量型成员变量

和引用型成员变量赋值的方式是行不通的。
    静态成员变量的初始化也颇有点特别。

    参考下面的代码以及其中注释：

[cpp]  view plain

1. // Initialization of Special Data Member  
2. #include <iostream>  
3. using namespace std;  
4.        
5. class BClass  
6. {  
7. private:  
8.   int i;                                  // 普通成员变量  
9.   
10.   const int ci;                           // 常量成员变量  
11.   
12.   int &ri;    
13.                                                      // 引用成员变量  
14.   static int si;                          // 静态成员变量  
15.   //static int si2 = 100;                 // error: 只有静态常量成员变量，才可以这样初始化  
16.   
17.   static const int csi;                   // 静态常量成员变量  
18.   static const int csi2 = 100;            // 静态常量成员变量的初始化(Integral type)    (1)  
19.   
20.   static const double csd;                // 静态常量成员变量(non-Integral type)  
21.   //static const double csd2 = 99.9;      // error: 只有静态常量整型数据成员才可以在类中初始化  
22.   
23. public:  
24.   BClass() : i(1), ci(2), ri(i)           // 对于常量型成员变量和引用型成员变量，必须通过  
25.   {                                       // 参数化列表的方式进行初始化。在构造函数体内进行赋值是不行的  
26.   
27.   }                                         
28.   
29. };  
30.        
31.   
32.     // 静态成员变量的初始化(Integral type)  
33.     int BClass::si = 0;  
34.   
35.     // 静态常量成员变量的初始化(Integral type)  
36.     const int BClass::csi = 1;  
37.   
38.     // 静态常量成员变量的初始化(non-Integral type)  
39.     const double BClass::csd = 99.9;  
40.      
41.   
42.     // 在初始化(1)中的csi2时，根据Stanley B. Lippman的说法下面这行是必须的。  
43.     // 但在VC2003中如果有下面一行将会产生错误，而在VC2005中，下面这行则可有可无，这个和编译器有关。  
44.   
45.     const int BClass::csi2;    
46.   
47.     int main(void)  
48.     {  
49.              BClass b_class;  
50.   
51.              return 0;  
52.     }  

三、完整总结

1、普通的变量：一般不考虑啥效率的情况下 可以在构造函数中进行赋值。考虑一下效率的可以再构造函数的初始化列表中进行。

[cpp]  view plain

1. class CA  
2. {  
3. public:  
4.  int data;  
5.  ……  
6. public:  
7.  CA();  
8.  ……  
9. };  
10. CA::CA():data(0)//……#1……初始化列表方式  
11. {  
12.  //data = 0;//……#1……赋值方式  
13. };  

 

2、static 静态变量：

static变量属于类所有，而不属于类的对象，因此不管类被实例化了多少个对象，该变量都只有一个。

[cpp]  view plain

1. class CA  
2. {  
3. public:  
4.  static int sum;  
5.  ……  
6. public:  
7.  CA();  
8.  ……  
9. };  
10. int CA::sum=0;//……#……类外进行定义和初始化  

3、const 常量变量：
const常量需要在声明的时候即初始化。因此需要在变量创建的时候进行初始化。一般采用在构造函数的初始化列表中进行。

[cpp]  view plain

1. class CA  
2. {  
3. public:  
4.  const int max;  
5.  ……  
6. public:  
7.  CA();  
8.  ……  
9. };  
10. CA::CA():max(100)  
11. {  
12.  ……  
13. }  

4、Reference 引用型变量：
引用型变量和const变量类似。需要在创建的时候即进行初始化。也是在初始化列表中进行。但需要注意用Reference类型。

[cpp]  view plain

1. class CA  
2. {  
3. public:  
4.  int& counter;   
5.  ……  
6. public:  
7.  CA(int i);  
8.  ……  
9. };  
10. CA::CA(int i):counter(i)  
11. {  
12.  ……  
13. }  

5、const static integral 变量:
对于既是const又是static 而且还是整形变量，C++是给予特权的。可以直接在类的定义中初始化。short可以，但float的不可以哦。

[cpp]  view plain

1. class CA  
2. {  
3. public:  
4.  //static const float fmin = 0.0;   
5.  // only static const integral data members can be initialized within a class  
6.  const static int nmin = 0;  
7.  ……  
8. public:  
9.  ……  
10. };  

总结起来，可以初始化的情况有如下四个地方：
1、在类的定义中进行的，只有const 且 static 且 integral 的变量。
2、在类的构造函数初始化列表中， 包括const对象和Reference对象。
3、在类的定义之外初始化的，包括static变量。因为它是属于类的唯一变量。
4、普通的变量可以在构造函数的内部，通过赋值方式进行。当然这样效率不高。