EC笔记：第二部分：12、复制对象时勿忘其每一个成分
1.场景
某些时候，我们不想使用编译器提供的默认拷贝函数（包括拷贝构造函数和赋值运算符），考虑以下类定义：
代码1：
class Point{
private:
double x;
double y;
public:
Point()=default;
Point(const Point &other){
x=other.x;
y=other.y;
}
const Point&
operator=(const Point &other){
x=other.x;
y=other.y;
return
*this;
}
};
Point类重写了拷贝构造函数和赋值运算符，这并没有什么问题，但是，假设现在要新增一个成员：
代码2：
class Point{
private:
double x;
double y;
double r;
//新增的成员
public:
Point()=default;
Point(const Point &other){
x=other.x;
y=other.y;
}
const Point&
operator=(const Point &other){
x=other.x;
y=other.y;
return
*this;
}
};
而且我们的程序员很不巧地忘了更新拷贝构造函数和赋值运算符，那么在复制的时候，新增的1成员r就保持原值，新得到的对象与原对象不相等，与要赋值的对象也不相等。
考虑另外一种场景：
代码3：
class Point{
private:
double x;
double y;
};
class MyPoint:public Point{
private:
double r;
public:
Point()=default;
MyPoint(const MyPoint& other){
r=other.r;
}
const MyPoint&
operator=(const MyPoint& other){
r=other.r;
return
*this;
}
};
当MyPoint继承Point类的时候，重写了拷贝构造函数和赋值运算符，但是忘了赋值基类中的成员，也会导致和前面一样的后果。
2.解决办法
为了解决上面的问题，首先，确保拷贝构造函数和赋值运算符确实将所有的成员都进行了拷贝（除非你是真的想保留一些成员）。例如，代码2中增加了成员r，那么拷贝构造函数和赋值运算符就应该对应更新：
代码4：
class Point{
private:
double x;
double y;
double r;
//新增的成员
public:
Point()=default;
Point(const Point &other){
x=other.x;
y=other.y;
r=other.r;//新增
}
const Point&
operator=(const Point &other){
x=other.x;
y=other.y;
r=other.r;//新增
return
*this;
}
};
其次，子类中重写了赋值运算符或者拷贝构造函数，一定要将父类中隐藏的成员一起复制，通常是调用父类的赋值运算符或者拷贝构造函数。代码3中可以修改为以下代码：
代码5：
class Point{
public:
Point()=default;
private:
double x;
double y;
};
class MyPoint:public Point{
private:
double r;
public:
MyPoint()=default;
MyPoint(const MyPoint& other):Point(other){
r=other.r;
}
const MyPoint&
operator=(const MyPoint& other){
Point::operator=(other);
r=other.r;
return
*this;
}
};
有些童鞋可能注意到，大多数拷贝构造函数与赋值运算符的操作类似，那么，是否可以在拷贝构造函数中调用赋值运算符呢？类似下面的代码：
代码6：
class Point{
public:
Point()=default;
private:
double x;
double y;
};
class MyPoint:public Point{
private:
double r;
public:
MyPoint()=default;
MyPoint(const MyPoint& other){
operator=(other);
}
const MyPoint&
operator=(const MyPoint& other){
Point::operator=(other);
r=other.r;
return
*this;
}
};
对此，《Effective C++》一书给出的解释是：
这段解释比较不是那么易懂，总体说来，就是在执行operator=的时候，拷贝构造函数其实已经执行结束，赋值运算符只作用于已经构造好的对象上，所以此时再使用并无意义（本质上相当于调用了默认构造函数+赋值运算符）。
反过来的话（在赋值运算符中调用拷贝构造函数），由于根本没有类似的语法，所以不做讨论。事实上，构造函数主要目的是"构造"，但是调用赋值运算符的时候，对象肯定已经构造完毕，所以，不会有这样的语法支持。
对于拷贝构造函数与赋值运算符有类似代码的场景，《Effective C++》给出的建议是，将公共代码提到一个单独的函数中，各自调用，以上代码可修改为：
代码7：
class Point{
public:
Point()=default;
private:
double x;
double y;
};
class MyPoint:public Point{
private:
double r;
void
init(const MyPoint& other){
r=other.r;
}
public:
MyPoint()=default;
MyPoint(const MyPoint& other):Point(other){
init(other);
}
const MyPoint&
operator=(const MyPoint& other){
Point::operator=(other);
init(other);
return
*this;
}
};
但是对于以上的修改方法，如果是对于这个类，我仍觉得有瑕疵。虽然拷贝构造函数中直接调用了父类的拷贝构造函数，但是在调用init函数的时候，成员r其实已经被构造，整个对象此时已经构造完毕，再对r进行复制，依然会产生额外的开销（当然，这个开销比拷贝构造函数直接调用赋值运算符小）。
所以我建议的修改方式为直接调用每个成员的拷贝构造函数，代码如下：
代码8：
class Point{
public:
Point()=default;
private:
double x;
double y;
};
class MyPoint:public Point{
private:
double r;
public:
MyPoint()=default;
MyPoint(const MyPoint& other):Point(other),r(other.r){
}
const MyPoint&
operator=(const MyPoint& other){
Point::operator=(other);
r=other.r;
return
*this;
}
};
此时Point和r都调用了各自的拷贝构造函数完成构造，比代码7的效率要好一些。
当然，这个修改只是针对这个类，《Effective C++》中指的是拷贝构造函数与赋值运算符中有相同代码部分，此处的修改已经不属于"相同代码"了，因为r=other.r已经被优化为了r(other.r)，相当于拷贝构造函数与赋值运算符中已经没有相同代码了。
针对代码7和代码8的分析，可以知道，只有当r没有提供拷贝构造函数的时候，代码7才不能优化为代码8，通常有两种情况：
- r是一个类对象，而且此对象中有些成员未提供拷贝构造函数
- r未提供拷贝构造函数
其实总的就是一句话：r无法通过拷贝构造函数构造，这时才需要用自定义代码完成r的构造。所以为了避免效率上的损失，尽量每个成员都提供拷贝构造函数（除非确实不希望成员被复制，当然，此时对象也不应该有拷贝构造函数）。
3.建议
- 确保每个成员都被复制
- 将不同copy函数中相同部分提取出来，重新封装一个函数，各自调用，两个copy函数不应该存在调用关系。