【C++程序员的自我修炼】初始化列表-编程知识

一半烟火以谋生

一半诗意以谋爱

契子✨

我们之前已经讲过了构造函数的初始化：前期回顾-构造函数

但是难免会遇到连构造函数都不好解决的问题

比如：

错误示范

class A
{
public:A(int n){this->_a = n;this->_b = n;}
private:const int _a;int _b;
};

因为 const 修饰的变量具有常性，也就是只能读不能写

所以 const 修饰的变量只能在定义的时候初始化，我们可以在声明的时候给缺省值来解决这个问题

const int _a = 10;

但是铁铁们知道这么做的本质是什么吗？

接下来我将带大家介绍：

初始化列表介绍

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

以下就是我们的要传参初始化列表：

class A
{
public:A(int n):_a(n),_b(n){}
private:int _a ;int _b;
};

当然我们也可以给 缺省值 进行无参的初始化定义

class A
{
public:A(int n = 4):_a(n),_b(n){}
private:int _a ;int _b;
};

我们还可以在初始化列表中进行 malloc 的动态空间开辟操作

class A
{
public:A(int n = 4):_a(n), _b((int*)malloc(40)){memset(_b, 0, 40);}
private:int _a;int* _b;
};

注意：

初始化列表本质可以理解为每个对象中成员定义的地方
所有的成员可以在初始化列表初始化，也可以在函数体内初始化

比如：以上代码我在初始化列表中定义了 10 个 int 类型的空间，并在函数体内全部初始化为 0

我们这里规定一下：在构造函数进行初始化操作叫做在函数体内部进行初始化，在初始化列表初始化时叫做在对象定义的时候进行初始化

可能你会问：为什么要专门规定一个对象的成员变量初始化的地方呢？普通的变量不管是在函数体内部初始化还是在初始化列表初始化，都没有什么影响

但是有些特殊的成员变量，比如：

引用成员变量

const成员变量

没有默认构造函数的自定义类型成员变量

是不能在函数体内部初始化的

初始化列表的必用场景

引用成员变量✨

错误示范

class A
{
public:A(int n = 4){_a = n;}
private:int& _a ;
};

为什么呢？因为引用必须在定义的时候初始化：

定义一般变量时：

<1>声明：声明变量类型和名字

<2>定义：根据类型分配内存地址空间

<3>初始化：将初始值拷贝到变量的内存地址空间中

定义引用类型时：

将引用绑定到初始化对象

因此定义引用类型时必须有初始值对象，也就是必须在定义的时候初始化

正确写法

class A
{
public:A(int n = 4):_a(n){}
private:int& _a;
};

因为初始化列表本质可以理解为每个对象中成员定义的地方，所以用初始化列表写

const 成员变量✨

因为 const 修饰的变量具有常性，所以必须在定义的时候初始化：

class A
{
public:A(int n = 4):_a(n){}
private:const int _a;
};

自定义类型成员(且该类没有默认构造函数)✨

错误示范

class A
{
public:A(int a,int b,int c){this->_a = a;this->_b = b;this->_c = c;}
private:int _a;int _b;int _c;
};class B
{
public:B(int n = 4){_cc = n;_aa(0, 0, 0);_bb(1, 1, 1);}
private:A _aa;A _bb;int _cc;
};

在构造函数的章节我们提过：

自动生成的构造会处理自定义类型，它会去调用自定义类型的默认构造

所以自定义类型会先调自己的默认拷贝构造，而这里我们恰恰没写呢？这就是报错的原因

没事~交给我们的初始化列表即可

正确写法

class A
{
public:A(int a, int b, int c){this->_a = a;this->_b = b;this->_c = c;}
private:int _a;int _b;int _c;
};class B
{
public:B(int n = 4):_aa(0, 0, 0),_bb(1, 1, 1){_cc = n;}
private:A _aa;A _bb;int _cc;
};

这样我们就成功初始化了呢~

初始化的一些小细节

class Date
{
public:
Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:
int _year;
int _month;
int _day;
};

我们来看一下，之前写的日期类 Date ：

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

简单来说：若是没有用初始化列表，在函数内的 初始化 语句并不是真正的初始化，而是相当于初赋值，只有最后的赋值等式才会初始化生效
	Date(int year, int month, int day){_year = year;_year = 10;_month = month;_month = 20;_day = day;_day = 30;}
比如说以上代码：最后初始化成功的就是：_year = 10，_month = 20，_day = 30

如果用我们的初始化列表的话
	Date(int year, int month, int day):_year(year),_month(month),_day(day){}
以上是正确的写法，但是不能初始化两次：

错误示范
	Date(int year, int month, int day):_year(year), _year(10),_month(month),_day(day){}
但是初始化后，仍可以赋初值
	Date(int year, int month, int day):_year(year),_month(month),_day(day){this->_year = 10;}

总结

每个成员变量在初始化列表中初始化只能初始化一次

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

<1>引用成员变量

<2>const成员变量

<3>自定义类型成员(且该类没有默认构造函数时)

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，

一定会先使用初始化列表初始化

注意：初始化列表在对象定义时，自动调用初始化列表，即使不写系统也会默认生成

如果我们不显式写出初始化列表，编译器会自动生成，对于内置类型，我们会对他进行初始化，对于自定义类型，会去调用它的默认构造函数

这里跟构造函数一样~

内置类型传缺省值和初始化列表联系

回顾一下我们构造函数里讲过的给内置类型传缺省值

这里传的缺省值是给谁用的呢？

此时的你心里估计已有了明确的答案 -- 初始化列表

#include<iostream>
#include<assert.h>
#include<cstdlib>
using std::cout;
using std::endl;class A
{
public:A(): _b(5){}void Print();
private:int _a = 10;int _b = 20;
};void A::Print()
{cout << _a <<" "<<_b << endl;
}int main()
{A aa;aa.Print();system("pause");return 0;
}

看看以上的程序的结果是什么呢？

首先我们赋予了内置类型缺省值，编译器会将缺省值给初始化列表

由初始化列表初始化，也就是 ~ 10 20

但是我们的初始化列表已将 _b 初始化为 5，说明不接受 _b 的缺省值

所以正确的结果是：10 5

成员变量的顺序

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

次序无关

#include<iostream>
#include<cstdlib>
using std::cout;
using std::endl;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();system("pause");return 0;
}

看看以上的代码分析程序：