4. 三五法则1
需积分: 0 114 浏览量
2022-08-03
16:27:47
上传
评论
收藏 556KB PDF 举报
三五
法
则
三
/
五
法
则
在
C++98
中
，
由
于
没
有
移
动
语
义
的
存
在
，
所
以
我
们
只
会
定
义
3
个
成
员
函
数
来
控
制
对
象
在
销
毁
、
拷
⻉
和
赋
值
时
做
什
么
操
作
，
这
些
函
数
分别
为
析构
函
数
、
拷
⻉
构
造
函
数
和
拷
⻉
赋
值
函
数
。
此
时
的
拷
⻉
控
制
称
之为
C++
三
法
则
⽽
在
C++11
中
，
额
外
的
添
加
了
移
动
语
义
，
使
得
程
序
可
以
通过
转
移
对
象
控
制
权
的
⽅
式
实
现
对
象
的
移
动
，
也
就
是
移
动
构
造
函
数
和
移
动
赋
值
函
数
。
加
上
这
两个
函
数
以
后
，
能
够
影
响
对
象
拷
⻉
控
制
的
函
数
增
加
⾄
5
个
所
以
也
称
之为
C++
五
法
则
后
⾯
为了
统
⼀
，
⼲
脆
称
为
“
三
/
五
法
则
”
，
指
的
其
实
就
是
析构
函
数
，
拷
⻉
构
造
函
数
，
拷
⻉
赋
值
函
数
，
移
动
构
造
函
数
以
及
移
动
赋
值
函
数
拷
⻉
控
制
需
要
析构
函
数
的
类
必
须
定
义
拷
⻉
和
赋
值
函
数
当
⼀个
类
需
要
析构
函
数
时
，
⼀
定
是
因
为
其
在
实
例
化
对
象
时
申
请
了
系
统
资
源
，
并
且
这
些
资
源
必
须
在
对
象
被
销
毁
时
归
还
给
系
统
。
最
典
型
的
资
源
莫
过
于
动
态
分
配
的
内
存
，
打
开
的
⽂
件
描
述
符
，
⼀个
TCP
连
接
这
些
资
源
如
果
依
赖
于
系
统
所
默
认
的
拷
⻉
控
制
操
作
，
那
么
在
程
序
运
⾏
过
程
中
就
会
埋
下
巨
⼤
的
隐
患
⽐
如如
果
⼀个
类
中
持
有
malloc
所
分
配
的
堆
内
存
，
并
使
⽤
成
员
指
针
进
⾏
管
理
。
由
于
系
统
默
认
的
拷
⻉
操
作
只
会
拷
⻉
指
针
的
地
址
，
那
么
执
⾏
拷
⻉
操
作
后
将
会
有
两个
对
象
指
向同
⼀
块
堆
内
存
。
当
两个
对
象
先
后
析构
时
，
就
会
对
同
⼀
块
堆
内
存
释
放
两
次
，
这
是
系
统
所
不
允
许
的
class Fuz {
private:
int *arr;
public:
Fuz() : arr(new int){}
~Fuz() {delete arr;}
};
int main() {
Fuz f1;
Fuz f2 = f1;
}
Fuz
类
虽
然
定
义了
析构
函
数
，
但
是
拷
⻉
构
造
/
赋
值
却
使
⽤
了
系
统
提
供
的
默
认
实
现
在
DUBUG
模
式
下
我
们
可
以
⾮
常
清
晰
的
看
到
f1.arr
和
f2.arr
指
向
的
是
同
⼀个
内
存
地址
当
我
们
对
同
⼀
块
堆
内
存
释
放
两
次
时
，
底
层
将
直
接
调
⽤
abort()
终
⽌
进
程
因
此
，
当
⼀个
类
需
要
析构
函
数
时
，
并
且
该
类
确
实
是
应
该
可
以
被
拷
⻉
的
，
那
么
应
正
确
的
实
现
拷
⻉
构
造
和
拷
⻉
赋
值
函
数
。
否
则
，
应
禁
⽤
这
两个
函
数
，
显
式
地
标
注
为
= delete
如
果
可
能
的
话
，
尽
量
定
义
移
动
构
造
函
数
在
移
动
构
造
中
，
我
们
提
到
了
如
果某
个
类
的
移
动
构
造
被
声
明
为
noexcept
的
话
，
那
么
容
器
在
扩
容
进
⾏
元
素
迁
移
时
，
将
调
⽤
该
类
的
移
动
构
造
函
数
，
从
⽽
提
⾼
系
统
运
⾏
效
率
在
⼀
般
的
拷
⻉
构
造
函
数
中
，
我
们
通
常
会
需
要
重
新
申
请
动
态
内
存
，
每
⼀
次
的
malloc/free
都
是
有
代价
的
。
尽
管
STL
使
⽤
内
存
池
进
⾏
了
优
化
，
但
是
相
⽐
于
移
动
的
⽅
式
，
拷
⻉
的
代价仍
然
要
更
⼤
⼀些
class Fuz {
public:
Fuz() {puts("ctor");}
Fuz(const Fuz& other) {puts("copy ctor");}
Fuz(Fuz&& other) noexcept {puts("move ctor");}
};
int main() {
vector<Fuz> fuzes;
fuzes.reserve(1);
fuzes.emplace_back();
fuzes.emplace_back();
}
扩
容
时
将
调
⽤
移
动
构
造
函
数
需
要
拷
⻉
的
类
也
需
要
赋
值
，
移
动
语
义
同
理
通
常
来
说
，
当
⼀个
类
定
义了
拷
⻉
构
造
函
数
，
那
么
就
应
该
要
有
拷
⻉
赋
值
函
数
，
否
则
这
个
类
的
功
能
是
不
完
整
的
。
移
动
构
造
和
移
动
赋
值
也
是
⼀
样
的
，
很
少
有
⼀个
类
只
需
要
拷
⻉
⽽
不
需
要
赋
值
也
就
是
说
，
拷
⻉
和
赋
值
这
两个
兄
弟
应
该
是
成
对
出
现
的
，
不
应
该
落
下
其
中
任
何
⼀个
评论0
最新资源