c++ 类初始化

一、   成员初始化列表的位置。

成员初始化列表的位置位于构造函数的函数体和参数表之间。构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式,初始化式可以是表达式、派生类构造函数的形参还有其余常量。

通过成员初始化表，类数据成员可以被显式初始化。成员初始化表是由逗号分隔的成员/名字实参对。例如下面的双参数构造函数的实现就使用了成员初始化表。

_name是string 型的成员类对象。

Account::Account( const char* name, double opening_bal ): _name( name ), _balance( opening_bal ) 
{   

_acct_nmbr = get_unique_acct_nmbr();   

} 

    成员初始化表跟在构造函数的原型后，由冒号开头。成员名是被指定的，后面是括在括号中的初始值，类似于函数调用的语法。如果成员是类对象则初始值变成被传递给适当的构造函数的实参。该构造函数然后被应用在成员类对象上。在我们的例子中，name被传递给应用在_name上的string构造函数。_balance 用参数opening_bal初始化。

Account::Account( const string& name, double opening_bal ) : _name( name ), _balance( opening_bal ) 
{    

_acct_nmbr = get_unique_acct_nmbr();   

}

说明：在这种情况下，string 的拷贝构造函数被调用。把成员类对象_name 初始化成string 参数name。


二、   使用初始化表和在构造函数内使用数据成员的赋值之间有什么区别？

（1）Account::Account( const char *name, double opening_bal ): _name( name ), _balance( opening_bal ) 
{     

_acct_nmbr = get_unique_acct_nmbr();   

}

（2）Account::Account( const char *name, double opening_bal ) 
{ 
       _name = name; 
       _balance = opening_bal; 
       _acct_nmbr = get_unique_acct_nmbr(); 
}

这两种实现有区别吗？

两种实现的最终结果是一样的。在两个构造函数调用的结束处三个成员都含有相同的值。区别是上面的构造函数（使用初始化列表的构造函数）显式的初始化类的成员；而没使用初始化列表的构造函数是对类的成员赋值，并没有进行显式的初始化。

我们可以认为构造函数的执行过程被分成两个阶段：隐式或显式初始化阶段以及一般的计算阶段。计算阶段由构造函数体内的所有语句构成，在计算阶段中数据成员的设置被认为是赋值而不是初始化。没有清楚地认识到这个区别是程序错误和低效的常见源泉。 
    初始化阶段可以是显式的或隐式的取决于是否存在成员初始化表。隐式初始化阶段按照声明的顺序依次调用所有基类的缺省构造函数然后是所有成员类对象的缺省构造函数。

如：

Account::Account() 
{ 
        _name = ""; 
        _balance = 0.0; 
        _acct_nmbr = 0; 
}

则初始化阶段是隐式的。在构造函数体被执行之前先调用与_name相关联的缺省string构造函数。这意味着把空串赋给_name的赋值操作是没有必要的。对于类对象，在初始化和赋值之间的区别是巨大的。成员类对象应该总是在成员初始化表中被初始化而不是在构造函数体内被赋值。 
缺省Account构造函数更正确的实现如下：

Account::Account() : _name( string() ) 
{ 
       _balance = 0.0; 
       _acct_nmbr = 0; 
}

它之所以更正确，是因为我们已经去掉了在构造函数体内不必要的对_name 的赋值。但是对于缺省构造函数的显式调用也是不必要的。下面是更紧凑但却等价的实现：

Account::Account() 
{ 
      _balance = 0.0; 
      _acct_nmbr = 0; 
}

剩下的问题是：对于两个被声明为内置类型的数据成员其初始化情况如何？例如用成员初始化表和在构造函数体内初始化_balance是否等价？回答是不。对于非类数据成员的初始化或赋值除了两个例外，两者在结果和性能上都是等价的。即更受欢迎的实现是用成员初始化表：

// 更受欢迎的初始化风格 
Account:: Account(): _balanae( 0.0 ), _acct_nmbr( 0 ) { }

两个例外是：指任何类型的const 和引用数据成员。const 和引用数据成员也必须是在成员初始化表中被初始化，否则就会产生编译时刻错误。

例如下列构造函数的实现将导致编译 ：


class ConstRef 
{ 
public: 
       ConstRef( int ii ); 
private: 
       int i; 
       const int ci; 
       int &ri; 
};

ConstRef:: ConstRef( int ii ) 
{ // 赋值 
      i = ii; // ok 
      ci = ii; // 错误: 不能给一个 const 赋值 
      ri = i; // 错误：ri 没有被初始化 
}

当构造函数体开始执行时，所有const和引用的初始化必须都已经发生。只有将它们在成员初始化表中指定，这才有可能。正确的实现如下：

ConstRef::ConstRef( int ii ):ci( ii ), ri( i ) 
{ i = ii; }

每个成员在成员初始化表中只能出现一次，初始化的顺序不是由名字在初始化表中的顺序决定而是由成员在类中被声明的顺序决定的。

例：

class Account 
{ 
public: 
// ... 
private: 
    unsigned int _acct_nmbr; 
    double _balance; 
    string _name; 
};

下面是该类的缺省构造函数:

Account::Account(): _name( string() ), _balance( 0.0 ), _acct_nmbr( 0 ) {}

的初始化顺序为acct_nmbr ，_balance 然后是_name 。(由类体内声明的次序决定的。)但是在初始化表中出现或者在被隐式初始化的成员类对象中的成员，总是在构造函数体内成员的赋值之前被初始化。例如：

Account::Account( const char *name, double bal ) : _name( name ), _balance( bal )
{ 
       _acct_nmbr = get_unique_acct_nmbr(); 
}

初始化的顺序是_balance ， _name 然后是_acct_nmbr。 
(为什么？因为_balance 在类体内的声明在 _name之前，_acct_nmbr的声明虽然在他们之前,但是因为他没有出现在成员初始化表中，所以。。) 


由于这种实际的初始化顺序与初始化表内的顺序之间的明显不一致有可能导致以下难于发现的错误。当用一个类成员初始化另一个时：

class X 
{ 
          int i; 
          int j; 
public: 
                        // 喔! 你看到问题了吗? 
          X( int val ):j( val ), i( j ) 
              {} 
// ... 
};

尽管看起来j 好像是用val 初始化的，而且发生在它被用来初始化i 之前，但实际上是i 先被初始化的。因此它是用一个还没有被初始化的j 初始化的。

我们的建议是把用一个成员对另一个成员进行初始化的代码放到构造函数体内。X::X( int val ) : i( val ) { j = i; }