C++ 類中特殊的成員變量（常變量、引用、靜態）的初始化方法

有些成員變量的數據類型比較特別，它們的初始化方式也和普通數據類型的成員變量有所不同。這些特殊的類型的成員變量包括：

a.引用

b.常量

c.靜態

d.靜態常量(整型)

e.靜態常量(非整型)

    常量和引用，必須通過參數列表進行初始化。
    靜態成員變量的初始化也頗有點特別，是在類外初始化且不能再帶有static關鍵字，其本質見文末。

參考下面的代碼以及其中註釋：
#include <iostream>
using namespace std;

class BClass
{
public:
 BClass() : i(1), ci(2), ri(i){} // 對於常量型成員變量和引用型成員變量，必須通過參數化列表的方式進行初始化
                                                //普通成員變量也可以放在函數體裏，但是本質其實已不是初始化，而是一種普通的運算操作-->賦值運算，效率也低
private:
 int i;                                  // 普通成員變量
 const int ci;                           // 常量成員變量
 int &ri;                                // 引用成員變量
 static int si;                          // 靜態成員變量
 //static int si2 = 100;                 // error: 只有靜態常量成員變量，纔可以這樣初始化
 static const int csi;                   // 靜態常量成員變量
 static const int csi2 = 100;            // 靜態常量成員變量的初始化(Integral type)    (1)
 static const double csd;                // 靜態常量成員變量(non-Integral type)
 //static const double csd2 = 99.9;      // error: 只有靜態常量整型數據成員纔可以在類中初始化
};

//注意下面三行：不能再帶有static
int BClass::si = 0; // 靜態成員變量的初始化(Integral type)
const int BClass::csi = 1; // 靜態常量成員變量的初始化(Integral type)
const double BClass::csd = 99.9; // 靜態常量成員變量的初始化(non-Integral type)

// 在初始化(1)中的csi2時，根據著名大師Stanley B.Lippman的說法下面這行是必須的。
// 但在VC2003中如果有下面一行將會產生錯誤，而在VC2005中，下面這行則可有可無，這個和編譯器有關。
const int BClass::csi2;

int main()
{
     BClass b;
     return 0;
}

 

---------------------------------------------------------------------------------------------

靜態成員屬於類作用域，但不屬於類對象，和普通的static變量一樣，程序一運行就分配內存並初始化，生命週期和程序一致。
所以，在類的構造函數裏初始化static變量顯然是不合理的。

靜態成員其實和全局變量地位是一樣的，只不過編譯器把它的使用限制在類作用域內（不是類對象，它不屬於類對象成員），要在類的定義外（不是類作用域外）初始化。

C++類中各種不同類型成員根據是否static 、是否const類型的初始化方法不盡相同，寫代碼時經常搞亂，網上搜了一下資料，全部總結一下。一、例子

-----------------Test.h----------------------------

#pragma once

class Test
{
private :
      int   var1;
//    int   var11= 4; 錯誤的初始化方法
      const int   var2 ;
//    const int   var22 =22222; 錯誤的初始化方法，const成員和引用成員必須在初始化列表中初始化（因爲它們必須在定義時初始化）
      static int   var3;
//    static int   var3333=33333; 錯誤，只有靜態常量成員才能直接賦值來初始化
      static const int   var4=4444;  //正確，靜態常量整數成員（此三個條件缺一不可）可以直接初始化
      static const int   var44;
public:
      Test(void);
       ~Test(void);
};

----------Test.cpp----------------

#include ".\test.h"

int Test::var3 = 3333333; //靜態成員的 正確的初始化方法

//    int Test::var1 = 11111;; 錯誤 靜態成員才能這樣初始化
//    int Test::var2 = 22222; 錯誤
//    int Test::var44 = 44444; // 錯誤的方法，提示重定義，因爲此var44與類中聲明的var44的修飾符不相同
const int Test::var44 = 44444; //正確

Test::Test(void) :var1(11111),var2(22222)   //正確的初始化方法 ， var3(33333) 不能在這裏初始化
{
    var1 =11111; //正確, 普通變量也可以在這裏初始化
    //var2 = 222222; 錯誤，因爲const常量不能賦值，只能在 構造函數的初始化列表 那裏初始化

    var3 =33;   //經測試，（1）若已經正確定義了var3，即在類定義外部“int Test::var3;”或“int Test::var3=3333333;”，
                //則此處賦值（注意是賦值，不是初始化）是正確的 ;
                //（2）若按（1）所說的正確定義var3，則此處賦值是錯誤的，因爲var3尚未定義。
}

Test::~Test(void)

二、簡單概括
有些成員變量的數據類型比較特別，它們的初始化方式也和普通數據類型的成員變量有所不同。這些特殊的類型的成員變量包括：
    a. 常量型成員變量：如 const int temp;
    b. 引用型成員變量：如 int & temp;
    c. 靜態成員變量：如 static int temp;
    d. 整型靜態常量成員變量：如 static const int temp;
    e. 非整型靜態常量成員變量：如 static const double temp;

    對於常量型成員變量和引用型成員變量的初始化，必須通過構造函數初始化列表的方式進行。在構造函數體內給常量型成員變量和引用型成員變量賦值的方式是行不通的。
    靜態成員變量的初始化也頗有點特別。

    參考下面的代碼以及其中註釋：

// Initialization of Special Data Member
#include <iostream>
using namespace std;

class BClass
{
private:
  int i;                                  // 普通成員變量

  const int ci;                           // 常量成員變量

  int &ri;
                                                     // 引用成員變量
  static int si;                          // 靜態成員變量
  //static int si2 = 100;                 // error: 只有靜態常量成員變量，纔可以這樣初始化

  static const int csi;                   // 靜態常量成員變量
  static const int csi2 = 100;            // 靜態常量成員變量的初始化(Integral type)    (1)

  static const double csd;                // 靜態常量成員變量(non-Integral type)
  //static const double csd2 = 99.9;      // error: 只有靜態常量整型數據成員纔可以在類中初始化

public:
  BClass() : i(1), ci(2), ri(i)           // 對於常量型成員變量和引用型成員變量，必須通過
  {                                       // 參數化列表的方式進行初始化。在構造函數體內進行賦值是不行的

  }

};


    // 靜態成員變量的初始化(Integral type)
    int BClass::si = 0;

    // 靜態常量成員變量的初始化(Integral type)
    const int BClass::csi = 1;

    // 靜態常量成員變量的初始化(non-Integral type)
    const double BClass::csd = 99.9;


    // 在初始化(1)中的csi2時，根據Stanley B. Lippman的說法下面這行是必須的。
    // 但在VC2003中如果有下面一行將會產生錯誤，而在VC2005中，下面這行則可有可無，這個和編譯器有關。

    const int BClass::csi2;

    int main(void)
    {
             BClass b_class;

             return 0;
    }

三、完整總結

1、普通的變量：一般不考慮啥效率的情況下 可以在構造函數中進行賦值。考慮一下效率的可以再構造函數的初始化列表中進行。

class CA
{
public:
 int data;
 ……
public:
 CA();
 ……
};
CA::CA():data(0)//……#1……初始化列表方式
{
 //data = 0;//……#1……賦值方式
};

 

2、static 靜態變量：

static變量屬於類所有，而不屬於類的對象，因此不管類被實例化了多少個對象，該變量都只有一個。

class CA
{
public:
 static int sum;
 ……
public:
 CA();
 ……
};
int CA::sum=0;//……#……類外進行定義和初始化

3、const 常量變量：
const常量需要在聲明的時候即初始化。因此需要在變量創建的時候進行初始化。一般採用在構造函數的初始化列表中進行。

class CA
{
public:
 const int max;
 ……
public:
 CA();
 ……
};
CA::CA():max(100)
{
 ……
}

4、Reference 引用型變量：
引用型變量和const變量類似。需要在創建的時候即進行初始化。也是在初始化列表中進行。但需要注意用Reference類型。

class CA
{
public:
 int& counter;
 ……
public:
 CA(int i);
 ……
};
CA::CA(int i):counter(i)
{
 ……
}

5、const static integral 變量:
對於既是const又是static 而且還是整形變量，C++是給予特權的。可以直接在類的定義中初始化。short可以，但float的不可以哦。

class CA
{
public:
 //static const float fmin = 0.0;
 // only static const integral data members can be initialized within a class
 const static int nmin = 0;
 ……
public:
 ……
};

總結起來，可以初始化的情況有如下四個地方：
1、在類的定義中進行的，只有const 且 static 且 integral 的變量。
2、在類的構造函數初始化列表中， 包括const對象和Reference對象。
3、在類的定義之外初始化的，包括static變量。因爲它是屬於類的唯一變量。
4、普通的變量可以在構造函數的內部，通過賦值方式進行。當然這樣效率不高。

【資料來源：http://www.douban.com/note/66957147/http://blog.csdn.net/jenghau/article/details/4752735，有修改】