C++中各种类型的成员变量的初始化方法

一、例子

-----------------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:
 ……
};

  6、const  + static 变量:

 

//----------**.h------------
class MyDialog
{
private:
    static const float b;
};
//const myDialog::b = 3.6; //ERROR:   (fatal error LNK1169: 找到一个或多个多重定义的符号)

//---------------------**.cpp
const myDialog::b = 3.6;//放在cpp文件中实现，放在xx.h中会出错。

 

总结起来，可以初始化的情况有如下四个地方：

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

主要来自：http://blog.csdn.net/yockie/article/details/7868068，稍作了补充。