P21-c++成员初始化列表深度剖析介绍，详细的例子演示!

1. 成员初始化列表

如果 Classy是一个类,而mem1、mem2和mem3都是这个类的数据成员,则类构造函数可以使用如下的语法来初始化数据成员:

Classy::Classy(int n, int m) : mem1(n), mem2(0), mem3(n*m + 2)
{
	//..
}

上述代码将mem1初始化为n,将mem2初始化为0,将mem3初始化为 n*m+2。从概念上说,这些初始化工作是在对象创建时完成的,此时还未执行括号中的任何代码。请注意以下几点:

• 这种格式只能用于构造函数
• 必须用这种格式来初始化非静态 const数据成员(至少在C++1之前是这样的);
• 必须用这种格式来初始化引用数据成员。
  数据成员被初始化的顺序与它们出现在类声明中的顺序相同,与初始化器中的排列顺序无关。
  警告:不能将成员初始化列表语法用于构造函数之外的其他类方法。

假设有这样的Demo类，它有一个const int成员变量 iAge。
Demo.cpp 用常规的方式 来给这个const变量赋值看看行不行。

  /*
	 author:梦悦foundation
	 公众号:梦悦foundation
	 可以在公众号获得源码和详细的图文笔记
 */
 
#include <iostream>
#include <typeinfo>
#include <string>
 
using namespace std;
class Demo {
private:
	const int iAge;
	string var_name;
public:
	Demo() {
	}
	Demo(int i, const string &  name = "meng-yue") {
		this->iAge = i;
		this->var_name = name;
		cout << "Demo(int i),this(" << this->var_name << "):" << this << ", i:" << i << ", this->iAge:" << this->iAge << endl;
	}
	Demo(const Demo & d_copy) {
		cout << "Demo(const Demo &d),this(" << this->var_name << "):" << this << ", &d_copy(" << d_copy.var_name <<  "):" << &d_copy << endl;
	}
	Demo & operator=(const Demo & d_var) {
		cout << "operator=(const Demo&d_var),this(" << this->var_name << "):" << this << ", &d_var(" << d_var.var_name <<  "):" << &d_var;
		cout << ", this->iAge:" << this->iAge << ", d_var.iAge:" << d_var.iAge << endl;
		return *this;
	}
	~Demo() {
		cout << "~Demo,this(" << this->var_name << "):" << this << endl;
	}
	void Show() {
		cout << "Show(),this(" << this->var_name << "):" << this << ", this->iAge:" << this->iAge << endl;;
	}
};

int main()
{
	cout << "---------------开始--->公众号:梦悦foundation---------------" << endl;
	Demo d1(1, "d1");
	cout << "---------------结束--->公众号:梦悦foundation---------------" << endl;
	return 0;
}

运行编译结果：

book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$ g++ -o Demo Demo.cpp
Demo.cpp: In constructor ‘Demo::Demo()’:
Demo.cpp:17: error: uninitialized member ‘Demo::iAge’ with ‘const’ type ‘const int’
Demo.cpp: In constructor ‘Demo::Demo(int, const std::string&)’:
Demo.cpp:19: error: uninitialized member ‘Demo::iAge’ with ‘const’ type ‘const int’
Demo.cpp:20: error: assignment of read-only data-member ‘Demo::iAge’
Demo.cpp: In copy constructor ‘Demo::Demo(const Demo&)’:
Demo.cpp:24: error: uninitialized member ‘Demo::iAge’ with ‘const’ type ‘const int’
book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$

发现不能像平时一样初始化int一样 这个const int 变量
从概念上说,调用构造函数时, 对象将在括号中的代码执行之前被创建。因此,调用 Demo(int i, const string & name = "meng-yue")构造函数将导致程序首先给2个成员变量分配内存。然后,程序流程进入到括号中,使用常规的赋值方式将值存储到内存中。
因此,对于 const数据成员,必须在执行到构造函数体之前,即创建对象时进行初始化。
C++提供了一种特殊的语法来完成上述工作,它叫做成员初始化列表( member initializer list)。成员初始化列表由逗号分隔的初始化列表组成(前面带冒号)。
它位于参数列表的右括号之后、函数体左括号之前。如果数据成员的名称为 mdata,并需
要将它初始化为val,则初始化器为 mdata(val)。
使用这种表示法,可以这样编写 Demo的构造函数:

Demo(int i, const string &  name = "meng-yue") : iAge(i)

通常,初值可以是常量或构造函数的参数列表中的参数。这种方法并不限于初始化常量,可以将 Demo构造函数写成如下所示:

Demo(int i, const string &  name = "meng-yue") : iAge(i), var_name(name)

只有构造函数可以使用这种初始化列表语法。如上所示,对于 const类成员,必须使用这种语法。
另外,对于被声明为引用的类成员,也必须使用这种语法

class Agency{・・}i
Class Agent {
private:
	Agency & belong: //must use initializer list to initialize
}
Agent::Agent(Agency & a) : belong(a) {}

这是因为引用与 const数据类似,只能在被创建时进行初始化。对于简单数据成员,如Demo类中的 var_name使用成员初始化列表和函数体中使用赋值没有任何区别。然而,正如第14章将介绍的,对于本身就是类对象的成员来说,使用成员初始化列表的效率更高。

1. 注意事项，是不是所有的构造函数都需要这么做？

即所有的构造函数都需要使用成员初始化列表去初始化那个const int 成员变量，要不然编译通不过，下面是一个正常的例子，所有的构造函数都初始化了 const int iAge变量。
Demo1.cpp

  /*
	 author:梦悦foundation
	 公众号:梦悦foundation
	 可以在公众号获得源码和详细的图文笔记
 */
 
#include <iostream>
#include <typeinfo>
#include <string>
 
using namespace std;
class Demo {
private:
	const int iAge;
	string var_name;
public:
	Demo() : iAge(0) {}
	Demo(int i, const string &  name = "meng-yue") : iAge(i), var_name(name) {
		cout << "Demo(int i),this(" << this->var_name << "):" << this << ", i:" << i << ", this->iAge:" << this->iAge << endl;
	}
	Demo(const Demo & d_copy) : iAge(0) {
		cout << "Demo(const Demo &d),this(" << this->var_name << "):" << this << ", &d_copy(" << d_copy.var_name <<  "):" << &d_copy << endl;
	}
	Demo & operator=(const Demo & d_var) {
		cout << "operator=(const Demo&d_var),this(" << this->var_name << "):" << this << ", &d_var(" << d_var.var_name <<  "):" << &d_var;
		cout << ", this->iAge:" << this->iAge << ", d_var.iAge:" << d_var.iAge << endl;
		return *this;
	}
	~Demo() {
		cout << "~Demo,this(" << this->var_name << "):" << this << endl;
	}
	void Show() {
		cout << "Show(),this(" << this->var_name << "):" << this << ", this->iAge:" << this->iAge << endl;;
	}
};

int main()
{
	cout << "---------------开始--->公众号:梦悦foundation---------------" << endl;
	Demo d1(1, "d1");
	d1.Show();
	cout << "---------------结束--->公众号:梦悦foundation---------------" << endl;
	return 0;
}

编译运行的结果：

book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$ ./Demo1
---------------开始--->公众号:梦悦foundation---------------
Demo(int i),this(d1):0xbf9bc7a0, i:1, this->iAge:1
Show(),this(d1):0xbf9bc7a0, this->iAge:1
---------------结束--->公众号:梦悦foundation---------------
~Demo,this(d1):0xbf9bc7a0
book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$

但是这里我们假如 Demo()这个构造函数 不进行 成员初始化列表的话，效果会怎么样，我们试一下
Demo2.cpp

Demo() {}

编译运行结果：
这个地方果然报错了，因为没有对iAge进行初始化。

book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$ g++ -o Demo2 Demo2.cpp
Demo2.cpp: In constructor ‘Demo::Demo()’:
Demo2.cpp:17: error: uninitialized member ‘Demo::iAge’ with ‘const’ type ‘const int’
book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$

那这个地方是不是可以尝试在构造函数内部对 iAge 这个变量进行赋值呢？
Demo3.cpp

Demo() { iAge = 0;}

编译运行的结果：
这个地方又新增加了一个错误，不能给 iAge 赋值，因为它是read-only data-member

book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$ g++ -o Demo3 Demo3.cpp
Demo3.cpp: In constructor ‘Demo::Demo()’:
Demo3.cpp:17: error: uninitialized member ‘Demo::iAge’ with ‘const’ type ‘const int’
Demo3.cpp:17: error: assignment of read-only data-member ‘Demo::iAge’
book@book-desktop:~/meng-yue/c++/class_dynamic_memory/05$

2. 成员初始化列表使用的括号方式也可用于常规初始化

成员初始化列表使用的括号方式也可用于常规初始化。也就是说,如果愿意,可以将下述代码:

int games =162;
double talk=2.71828；

替换为:

int games(162);
double talk(2.71828);

这使得初始化内置类型就像初始化类对象一样。