构造函数提升篇

• 1. 再谈构造函数
• • 1.1. 引入
  • • 1.1.1问题引入
    • 1.1.2 const引入
  • 1.2 正篇
  • • 1.2.1 构造函数体赋值
    • 1.2.2 初始化列表
    • • 1.2.3.1 浅浅认识
      • 1.2.3.2 构造函数的 `行走顺序`
      • 1.2.3.3 引用修饰成员变量
      • 1.2.3.4 没有默认构造的自定义类型
    • 1.2.3初始化列表的 `’坑’`
    • 1.2.4 谈谈初始化列表 和 构造函数
    • 1.3 explicit关键字
    • • 1.3.1 引入
      • 1.3.2 正篇
      • • 1.3.2.1 赋值的含义
        • 1.3.2.2 探寻 `’隐式类型转换’` 的真相
        • 1.3.2.3 explicit关键字

1. 再谈构造函数

1.1. 引入

1.1.1问题引入

class Date{public:private:int _year;int _month;int _day;};

通过前面所学的知识, 我们知道了_year, _month, _day这三个变量都是一些声明, 并没有开辟空间, 不是定义.

Date d1;

这一个操作就是给 d1这个对象整体定义, 但是对象整体定义,并不代表着里面的三个成员变量定义了.

️那么问题来了: 成员变量是在什么时候定义的??

1.1.2 const引入

class Date{public:private:int _year;const int _month;int _day;};int main(){Date d1;return 0;}

当我们用const 来修饰一下其中的一个成员变量, 那么会怎么样了?

️这样的报错是什么意思” /> 其实我们可以发现一些端倪: 就是const 修饰的变量有一个特点就是 定义的时候一定要初始化, 那么有些老铁就会说 在里面给 const修饰的变量一个缺省值试一试

️这些不是声明嘛, 给一个缺省值为什么就可以了” /> 其实, 初始化列表可以看成成员变量定义的地方. 而我们给的缺省值也是给初始化列表用的. 缺省, 缺省, 说实话就是一个备胎, 如果我们在初始化列表中给了这个变量的值⇒ 那么就不会用这个缺省值了, 而去用我们在初始化列表中的值.

1.2 正篇

在构造函数中,初始化成员变量有两种方式: 构造函数体赋值 和 初始化列表
其实, 这两种方式是有所不同的, 通过下面的一些比较就能看出他们的不同

1.2.1 构造函数体赋值

class Date{public:Date(int year, int month, int day){_year = year;_year = 2022;_month = month;_month = 5;_day = day;_day = 20;}private:int _year;int _month;int _day;};int main(){Date d1(2023, 5, 16);return 0;}

️延续上面的问题, 这个是不是初始化?

• 其实答案很明显, 这个是并不是初始化. 因为每一个变量只有一次初始化, 但是可以有多次赋值. 通过上面的代码, 我们可以发现: 在构造函数内部可以进行多次的赋值, 而初始化只有一次, => 构造函数不是成员变量初始化的地方

1.2.2 初始化列表

1.2.3.1 浅浅认识

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

class Date{public:// 构造函数Date() // 此部分是 初始化列表:_year(2023)// 此部分是 构造函数体赋值{_month = 5;_day = 16;}private:const int _year; // const 修饰的成员变量int _month;int _day;};int main(){Date d1;return 0;}

• 注意:
  1. 每个成员变量在初始化列表中 最多出现一次(因为只能初始化一次)
  2. 类中包含以下的成员时, 必须放在初始化列表中进行初始化:
  • const 修饰的成员变量
  • 引用修饰的成员变量
  • 没有默认构造函数的自定义类型

1.2.3.2 构造函数的 行走顺序

构造函数初始化成员变量有两种形式: 构造函数体赋值 和 初始化列表
一个是 赋值, 一个是 初始化 ⇒ 由此不难看出, 编译器先走的是 初始化列表然后才是构造函数体赋值

️如果没有初始化列表, 编译器会走初始化列表这一步吗?

• 猛一看, 感觉这个问题是不是有问题; 仔细一想, 其实这个问题问的很有深度~~. 换一句话说, 其实这个问题是想问 ⇒ 初始化列表是构造函数必走的一步吗?
  通过下面的代码, 验证一番:

class Date{public:Date(){_month = 5;_day = 16;}void Print(){cout << _year << " " << _month << " " << _day << endl;}private:const int _year = 5;int _month;int _day;};int main(){Date d1;d1.Print(); // 5 5 16return 0;}

class Date{public:Date():_year(2023){_month = 5;_day = 16;}void Print(){cout << _year << " " << _month << " " << _day << endl;}private:const int _year = 5;int _month;int _day;};int main(){Date d1;d1.Print(); //2023 5 16return 0;}

通过上面的两个例子:

1. 补丁 — — 成员变量给个缺省值, 这个缺省值其实传给初始化列表的. 如果初始化列表没有对此变量进行操作, 那么就会使用那个缺省值
2. 初始化列表是构造函数必走的一步 — — 因为初始化列表是成员变量定义的地方

1.2.3.3 引用修饰成员变量

class A{public:A(int a, int& b){_a1 = a;_a2 = b;}private:int _a1;int& _a2;};int main(){int n = 10;A a(10, n);return 0;}*****error C2530: “A::_a2”: 必须初始化引用*****

️有一些老铁, 就会有一些疑问: 为什么这里的传引用不能传递一个常量⇒ 就比如 A a(10, 10);

• 首先这样写会有报错的:
  
  在这里, 我们只需要看一下红色的报错(蓝色的报错是这一类 的错误 — — 不能用构造函数体赋值来初始化 用引用修饰的成员变量):
  因为 _a2 是 b的引用, b 是 10的引用 ⇒ _a2 是 10的引用, 由于 10是一个常量, 所以引用都要用常量引用来接收, 否则就是引用的权限放大造成错误!!!
  如果我们这样修改的话, 就必须把成员变量里面也用 const来修饰此变量才可以. 不过这样多不方便⇒ 传一个常量, 一直用, 还不能改变⇒ 这不符合我们的需求啊~
  

通过上面的例子, 我们发现: 使用构造函数体赋值这种方式是不行的!!

那么, 我们就采用初始化列表:

• _a2 = 10 — — _a2 是 b的引用, b 是 n的引用 ⇒ _a2 是 n的引用. 因为初始化列表是成员变量定义的地方, 所以可以在此处进行对 引用修饰的_a2 进行初始化
• _a1 是一个随机值 — — 发现传参的 10没用⇒ 想告诉各位读者的是, 我们传参是有自己的目的性 和 选择性; 如果我们不用, 对于内置类型成员变量(当然也没有缺省值)就会被初始化为随机值.

1.2.3.4 没有默认构造的自定义类型

class B{public:// 无参调用 ==> 默认构造B(){}private:int _b;int _tem;};class A{public:private:int _a;B bb;};int main(){A a1;return 0;}

上面的代码是正确的, 因为A 类中有一个自定义类型的成语变量 bb. 构造函数是完成成员变量的初始化的, 对于 A类来说, 要完成 对 _a 和 bb( _b _tem) 的初始化. 而要完成对 bb的初始化, 就需要 B类的默认构造. 如果 B类存在默认构造, 那么就会对 bb 进行初始化, 如果 B类不存在默认构造, 那么就不会对 bb进行初始化.

class B{public:// 有参 ==> 就不存在默认构造B(int x, int y){_b = x;_tem = y;}private:int _b;int _tem;};class A{public:private:int _a;B bb;};int main(){A a1;return 0;}

上面, 我们故意对 B类的构造函数写成了有参调用⇒ 那么 B类就会失去默认构造=> B(_b _ tem) 就会是随机值, 就不能完成对 B(_b _ tem) 的初始化了=> A类中就不能完成初始化

• 那我们试一试初始化列表

• 对自定义类型成员变量的初始化总结:
  

1.2.3初始化列表的 '坑'

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

class A{public:A(int a):_a1(a),_a2(_a1){}private:int _a2;int _a1;};int main(){A a(1);}

️上面代码的运行结果是什么” /> _a2 是随机值, _a1 = 1
因为声明中的顺序是 _a2 _a1, 那么编译器在初始化列表初始化的时候就会 先初始化 _a2, 再初始化_a1 ⇒
初始化 _a2 的时候: _a2( _a1), 这时候_a1还没有被初始化, 所以是一个随机值; 初始化 _a1的时候: _a1(1), 那么 _a1就是 1喽

建议— — 尽量按照声明的顺序来安排初始化列表中变量的初始化顺序

初始化列表中, 每一个成员变量最多只能出现一次

class A{public:A():_a1(5),_a2(10),_a1(8){}private:int _a2;int _a1;};int main(){A a;return 0;}

• 初始化列表是每个成员变量定义的地方, 也是初始化的地方

1.2.4 谈谈初始化列表 和 构造函数

其实, 每一个初学者在这个地方都会停留一段时间.
初始化列表 和 构造函数, 一不留神就会混淆了概念和作用

总的来说, 初始化列表是构造函数的一部分.构造函数的功能就是完成对成员变量的初始化工作, 对自定义类型会调用它的默认构造, 而对于内置类型, 就不会进行处理.
完成这一个初始化工作, 有两个方式: 初始化列表 和 构造函数体赋值. 见名知义: 一个是初始化, 一个是赋值.
如果成员变量中 没有 const修饰, 引用修饰 或者 没有默认构造的自定义类型, 写不写初始化列表都是ok的, 只要有其中的一个存在, 就要写一下初始化列表. 其实const修饰的成员变量也可以不用写初始化列表(上面有例子, 不清楚的上去看看)
比较来说, 初始化列表可以完成的工作 > 构造函数体赋值 ⇒ 我们一般建议使用初始化列表. 当然有些工作时需要构造函数体赋值, 也是要写构造函数体赋值的.

1.3 explicit关键字

1.3.1 引入

前面C语言的学习, 我们知道存在一种 类型转换. 由于C++能够兼容C语言, 我们就大胆实验

class A{public:A(int a):_a(a){}private:int _a;};int main(){A a = 23;return 0;}

上面的代码是可行的.
️为什么可以直接从一个 int类型直接转换成 A类的对象a呢” /> 构造函数不仅可以构造与初始化对象, 对于单个参数或者第一个参数无默认值其余有默认值的构造函数, 还具有类型转换的作用

1.3.2 正篇

1.3.2.1 赋值的含义

️先有一个问题: 在C语言的学习中, 以int a = 10; double b = a; 为例子, 讲述一下 类型转换的过程

• 类型转换不是直接就 把 a 的值 赋值给 b. 会生成一个 类型为 double的临时变量, 记作 tem , 然后把tem 赋值给 b . 这里多说一句, 后面就出现了引用 &, 就不会有临时对象的生成.

那么延续上面的思路, 我们就会知道上面代码的一个原理:
用 23去构造了一个 类型为A的临时对象, 记作tem, 然后把 tem 拷贝构造给 a
️为啥换到这里就是 构造 和 拷贝构造了??

• 生成一个类型是 A的临时对象 tem, 用 23去初始化tem — — 构造
  用一个已知的对象tem 去初始化另一个对象 a — — 拷贝构造

1.3.2.2 探寻 '隐式类型转换' 的真相

我们已经知道隐式类型转换的一个原理, 那么用代码来验证一番:

class A{public:A(int a):_a(a){cout << "调用了构造函数" << endl;}A(const A& x){cout << "调用了拷贝构造函数" << endl;}private:int _a;};int main(){A a = 23;return 0;}*****调用了构造函数*****

️嗯??, 跟我们想的不一样, 难道我们想错了??

• 其实不然, 这里编译器把它给优化了.
  我们知道: 构造 和 拷贝构造 的功能都是 初始化, 如果在同一行, 我们同时调用 构造 + 拷贝构造 ⇒ 编译器就只会调用一个构造函数, 直接完成赋值~~

️老陈, 你空口无凭, 给我们看一下证据??

• ok, 这就安排
  由于,临时对象具有常性, 所以我们想到了用 引用 &来进行验证 <== 因为权限可以缩小 或 平移, 但是不能放大
  先看下面的代码

class A{public:A(int a):_a(a){cout << "调用了构造函数" << endl;}A(const A& x){cout << "调用了拷贝构造函数" << endl;}private:int _a;};int main(){A& a = 23;return 0;}*****error C2440: “初始化”: 无法从“int”转换为“A &”*****

class A{public:A(int a):_a(a){cout << "调用了构造函数" << endl;}A(const A& x){cout << "调用了拷贝构造函数" << endl;}private:int _a;};int main(){const A& a = 23;return 0;}*****调用了构造函数*****

这里就变相地证明了: 上面的隐式类型转换 是经历过了构造 + 拷贝构造, 不过是编译器有优化而已
注意: 不同的编译器有不同的优化, 所以看到不同的结果不必大惊小怪的~~

1.3.2.3 explicit关键字

在一些场景下, 隐式类型转换会很方便(后面会学到的 string, STL… …),
但在另一些场景下, 我们又不希望隐式类型转换的出现(后面会学到的 智能指针… …)
那我们如何不让 隐式类型转换 发生呢?? — — 答案就是explicit关键字
把explicit 放在 构造函数的前面就会不让 隐式类型转换发生

class A{public:explicit A(int a):_a(a){cout << "调用了构造函数" << endl;}A(const A& x){cout << "调用了拷贝构造函数" << endl;}private:int _a;};int main(){A a = 23;return 0;}*****error C2440: “初始化”: 无法从“int”转换为“A”message : class“A”的构造函数声明为“explicit”*****

大鹏一日同风起，扶摇直上九万里