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 来修饰一下其中的一个成员变量, 那么会怎么样了?![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-1.png)
🗨️这样的报错是什么意思? — 具有未初始化的常量限定数据成员
-
其实我们可以发现一些端倪: 就是const 修饰的变量有一个特点就是 定义的时候一定要初始化, 那么有些老铁就会说 在里面给 const修饰的变量一个缺省值试一试
![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-2.png)
🗨️这些不是声明嘛, 给一个缺省值为什么就可以了? 原理是什么啊? 还有就是传一个缺省值是传给谁啊? - 其实, 初始化列表可以看成成员变量定义的地方. 而我们给的缺省值也是给初始化列表用的. 缺省, 缺省, 说实话就是一个备胎, 如果我们在初始化列表中给了这个变量的值⇒ 那么就不会用这个缺省值了, 而去用我们在初始化列表中的值.
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;
}
- 注意:
- 每个成员变量在初始化列表中
最多出现一次(因为只能初始化一次) - 类中包含以下的成员时, 必须放在初始化列表中进行初始化:
- 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 16
return 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 16
return 0;
}
通过上面的两个例子:
- 补丁 — — 成员变量给个缺省值, 这个缺省值其实传给初始化列表的. 如果初始化列表没有对此变量进行操作, 那么就会使用那个缺省值
- 初始化列表是构造函数必走的一步 — — 因为初始化列表是成员变量定义的地方
![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-3.png)
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);
-
首先这样写会有报错的:
![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-4.png)
在这里, 我们只需要看一下红色的报错(蓝色的报错是这一类 的错误 — — 不能用构造函数体赋值来初始化 用引用修饰的成员变量):
因为 _a2 是 b的引用, b 是 10的引用 ⇒ _a2 是 10的引用, 由于 10是一个常量, 所以引用都要用常量引用来接收, 否则就是引用的权限放大造成错误!!!
如果我们这样修改的话, 就必须把成员变量里面也用 const来修饰此变量才可以. 不过这样多不方便⇒ 传一个常量, 一直用, 还不能改变⇒ 这不符合我们的需求啊~![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-5.png)
通过上面的例子, 我们发现: 使用构造函数体赋值这种方式是不行的!!
那么, 我们就采用初始化列表:![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-6.png)
- _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;
}
![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-7.png)
上面, 我们故意对 B类的构造函数写成了有参调用⇒ 那么 B类就会失去默认构造=> B(_b _ tem) 就会是随机值, 就不能完成对 B(_b _ tem) 的初始化了=> A类中就不能完成初始化
- 那我们试一试初始化列表👇👇👇
![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-8.png)
- 对
自定义类型成员变量的初始化总结:![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-9.png)
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;
}
![C嘎嘎~~[构造函数提升篇]](https://imgs.yssmx.com/Uploads/2023/06/470098-10.png)
- 初始化列表是每个成员变量定义的地方, 也是初始化的地方
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 放在 构造函数的前面就会不让 隐式类型转换发生文章来源：https://www.toymoban.com/news/detail-470098.html
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”
*****
大鹏一日同风起，扶摇直上九万里文章来源地址https://www.toymoban.com/news/detail-470098.html
到了这里，关于C嘎嘎~~[构造函数提升篇]的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
