C++ is on the way 8: 类初始化列表的分析总结

Author:gnuhpc
WebSite:blog.csdn.net/gnuhpc

1.在子类构造时完成父类（没有默认构造函数）的初始化参数传入：

#include <iostream>
class Foo
{
        public:
        Foo( int x ) 
        {
                std::cout << "Foo's constructor " 
                          << "called with " 
                          << x 
                          << std::endl; 
        }
};
class Bar : public Foo
{
        public:
        Bar() : Foo( 10 )  // construct the Foo part of Bar
        { 
                std::cout << "Bar's constructor" << std::endl; 
        }
};
int main()
{
        Bar stool;
}

2.初始化const成员和reference成员

#include <iostream>
using namespace std;
class const_field
{
        public:
                const_field(int ii) : _constant( 1 ),ref( i ) { i=ii; }
                int geti(){return i;}
                int getref(){return ref;}
        private:
                const int _constant;
                int &ref;
                int i;
};
int main()
{
        const_field cos(100);
        cout << cos.geti() <<" " << cos.getref()<<endl;
}

注：初始化列表在构造函数函数体运行之前完成，在构造函数函数体运行中，数据成员的设置是赋值，而不是初始化。初始化阶段可以是显式或隐式的，这要取决于类成员的类型，对于built-in成员其实都一样，但是对于类成员，是否存在成员初始化表则有所不同：若不存在则是隐式初始化，按照声明的顺序依次调用所有类成员函数所属基类的默认构造函数（见后边的练习），在函数体内有赋值动作调用赋值构造函数。若存在则属于显式初始化，类成员使用复制构造函数完成初始化，这也就是我们有时会说在初始化列表中初始化开销会小些的原因（因为若在函数体内再赋值，那么类成员函数的默认构造函数执行所做的工作都是无用功），例如：

Account(){

_name = “”:

_balance=0.0;

}

这里面的string型的_name在赋值前已经被初始化阶段隐式初始为空串（调用了string的默认构造函数），所以在函数体中的赋值是完全没有意义的。

总之，建议使用初始化列表（注意是按照成员声明顺序，而不是列表顺序）来做对象创建时初始化工作。

初始化顺序为：

1. 基类
2. 成员数据成员（初始化列表）
3. 构造函数函数体

附：练习

#include <iostream>
using namespace std;
class Test
{
public:
 Test()
 {
  ctor_count++;
  cout<<"ctor "<<ctor_count<<endl;
 }
 Test(const Test & r)
 {
  ctor_count++;
  cout<<"copy ctor "<<ctor_count<<endl;
 }
 Test & operator= (const Test& r)
 {
  ctor_count++;
  cout<<"assignment op "<<ctor_count<<endl;
  return *this;
 }
private:
 static int ctor_count; //only a declaration
};
int Test::ctor_count=0; // definition + initialization
class Task
{
private:
 int pid;
 Test name; // type changed from string to Test
public:
 Task (int num, const Test & n) {pid=num; name=n;}
};
int main(void)
{
 Test t;
 Task task(1, t);
 return 0;
}

运行结果：

[root@localhost ~]# ./a.out
ctor 1
ctor 2
assignment op 3

解释：static int是为了更好的说明问题，不要被这个类型所迷惑。第一行表示程序在构造t。第二行表示默认初始化时调用默认构造函数，第三行是构造task时的赋值。

将程序的初始化修改：

Task (int num, const Test & n):pid(num),name(n) {}

运行结果是：

ctor 1
copy ctor 2

下边的这个程序也可以说明问题，如果还不理解上例的话：

#include <iostream>
using namespace std;
class Bar
{
public:
  Bar();
  Bar(int x);
  Bar & operator=(const Bar& bar)
  {
      cout <<"Assignment Bar constructed." <<endl;
  }
  Bar(const Bar &bar)
  {
      cout <<"Copy Bar constructed." <<endl;
  }
private:
  int x;
};
Bar::Bar()
{
  std::cout << "Bar default-constructed." << std::endl;
}
Bar::Bar(int x) : x(x)
{
  std::cout << "Bar constructed." << std::endl;
}
class Foo
{
public:
  Foo(Bar bar);
private:
  Bar bar;
};
Foo::Foo(Bar bar)
{
  this->bar = bar;
}
//Foo::Foo(Bar bar):bar(bar){}
int main()
{
    Foo foo(Bar(3));
    return 0;
}