【C++】类与对象 （四）初始化列表 static成员 友元 内部类 匿名对象 拷贝对象时的一些编译器优化（1）

一、 再谈构造函数

虽然在类与对象（二）中我们已经详细介绍了构造函数，但是我们在这里还是要继续谈论构造函数，因为构造函数实在是太复杂了（C++之父最开始没有设计好，后面又多次打补丁导致构造函数相当复杂），不过这次再谈论构造函数并没有像以前的那么难，我们这次谈论的是构造函数的一些碎片化知识。

我们还是先看代码再思考：

#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year=10, int month=10, int day=10)
  {
    _year = year;
    _month = month;
    _day = day;
    _a = 10; //编译失败，const修饰的变量不能改变
  }
private:
  int _year;
  int _month;
  int _day;
  const int _a;//编译失败，const 变量未初始化
};

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值，虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

你可能觉得这样抠细节是不是有些太钻牛角尖了，其实不是那样的，有些变量非常看重初始化，如const 修饰的变量只能初始化一次并且不能被赋值，这就要求我们必须仔细分清初始化与赋值。

我们对上面代码的成员变量加一个const修饰的变量看看会发生什么？

我们发现编译失败，难到类里面不能定义这种const修饰的变量吗？不是的，其实我们可以按照类与对象（二）中讲的缺省值给const变量赋值，但是缺省值是C++更新之后才出现的，那C++更新之前版本我们C++又是怎么解决的呢？

答案就是初始化列表！

1、 初始化列表

首先我们先思考一个问题对象定义时，对象中的成员是具体在哪里定义的呢？解决了这个问题上面的const修饰的变量不能定义的问题也就解决了，因为const修饰的变量在定义时必须初始化，即定义与初始化在一起。

答案是对象中的成员是具体定义是在初始化列表，那么下面就让我们一起了解一下初始化列表吧

a.定义

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

实例代码：

#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year , int month , int day)
    :_year(year)//初始化列表，也是成员变量定义的地方，这里才是真正的初始化
    ,_month(month)
    ,_day(day)
    ,_a(10)
  {
  }
private:
  int _year;
  int _month;
  int _day;
  const int _a;
};
int main()
{
  Date d1(10,10,10);
  return 0;
}

b.特性

①每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

②类中包含以下成员，必须放在初始化列表位置进行初始化：

• 引用成员变量 （定义时必须初始化）
• const成员变量 （定义时必须初始化）
• 自定义类型成员且该类没有默认构造函数时（没有默认构造意味这初始化时必须传参）

1. 我们先看自定义类型成员且该类没有默认构造函数时，我们不在初始化列表进行初始化

2.我们看自定义类型成员且该类有默认构造函数时，我们不在初始化列表进行初始化。

结论是：在初始化列表，如果我们什么都不写，编译器对内置类型不作处理，对自定义类型去调用它的默认构造。

建议：尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

③成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

思考以下代码的结果：

#include<iostream>
using namespace std;
class A
{
public:
  A(int a)
    :_a1(a)
    , _a2(_a1)
  {}
  void Print() {
    cout << _a1 << " " << _a2 << endl;
  }
private:
  int _a2;
  int _a1;
};
int main() {
  A aa(1);
  aa.Print();
}

可能结果让你大吃一惊，我们仔细分析一下

2. explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

注意：根据定义知这里的构造函数必须传参

我们看下面一段代码

#include<iostream>
using namespace std;
class A
{
public:
  A(int a)
    :_a1(a)
    , _a2(_a1)
  {}
private:
  int _a1;
  int _a2;
};
int main() {
  A aa1(1);  
  A aa2 = 1;//这里不是拷贝构造（拷贝构造是用一个对象初始化一个对象），
           //这里也不是赋值重载（赋值重载是用一个已经初始化的对象赋值给另一个已经初始化过的对象）
           //是否可以编译通过？
  return 0;
}

答案是可以编译通过并且通过监视我们可以看到它的值

那为什么这里能够通过编译呢？答案是隐式类型转化！

我们在讲解引用时曾经讲过之所以下面的代码能通过，是因为 i 会隐式类型转换为一个double类型的临时变量，且临时变量具有常性，d 引用的就是这个double类型的临时变量！

int i = 10;
const double&d = i;

同理这里也是，具体过程如下：

明白了单参数的类型转化赋值的原理后我们看看多个参数怎么做？

#include<iostream>
using namespace std;
class A
{
public:
  A(int a,int b)
    :_a1(a)
    , _a2(b)
  {}
private:
  int _a1;
  int _a2;
};
int main() {
  A aa1(1,2);  //调用构造函数
  A aa2 = {1,2}; //多个参数类型转化
  return 0;
}

这里我们可以看到多个参数是我们是用{ }来给值的

注意，单个参数转换是C++98支持的，多个参数转化是C++11支持的

但是有时候我们却不想让这种事情发生，这是就需要我们用explicit修饰构造函数，将会禁止构造函数的隐式转换。

同样的代码我们加上explicit

到这里我们总算是将构造函数讲完了…之后还要多多复习啊！