一、拷贝构造函数的基本概念
- 拷贝构造函数是一种特殊的构造函数。其形参是本类对象的引用。
- 拷贝构造函数的作用：在建立一个新对象时，使用一个已经存在的对象去初始化这个新对象。例如：
Point p2(p1);
其作用是，在建立新对象p2时，用已经存在的对象p1去初始化新对象p2，在这个过程中就要调用拷贝构造函数。
- 拷贝构造函数的特点：
1、因为该函数也是一种构造函数，所以其函数名与类名相同，并且该函数也没有返回值类型。
2、该函数只有一个参数，并且是同类对象的引用。
3、每个类都必须有一个拷贝构造函数。
可以自定义拷贝构造函数，用于按照需要初始化新对象；如果程序员没有定义类的拷贝构造函数，系统就会自动产生一个默认拷贝构造函数，用于复制出数据成员值完全相同的新对象。
二、自定义拷贝构造函数
自定义拷贝构造函数（见例 1）
类名::类名（const 类名 &对象名）
{
//拷贝构造函数的函数体
}
三、调用拷贝构造函数的3种情况（见例 2）：
普通的构造函数是在对象创建时被调用，而拷贝构造函数在以下3中情况下都会被调用：
1、当用类的一个对象去初始化该类的另一个对象时。
有 代入法 和 赋值法 两种方法调用拷贝构造函数。
代入法：
类名 对象2(对象1)
例如：Point p1(p2);
赋值法：
类名 对象2=对象1；
例如：Point p2=p1;
在这里要注意 “ 赋值法调用拷贝构造函数 ” 和 “ 对象赋值语句 ” 的区别，对象赋值语句不会调用拷贝构造函数，它是通过默认运算符函数实现的。
这里的对象赋值是指对其中的数据成员赋值，而不对成员函数赋值。
2、当函数的形参是类的对象，在调用函数进行形参和实参结合时。
例如：
void fun1(Point p) //形参是类Point的对象
{
p.print();
}
int main(){
Point p1(10,20);
fun1(p1); //调用函数fun1时，实参p1是类Point的对象。将调用拷贝构造函数，初始化形参对象p
return 0;
}
如果类Point中有自定义的拷贝构造函数，就调用这个自定义的拷贝构造函数，否则就调用系统自动生成的默认拷贝构造函数。
3、当函数的返回值是类的对象，在函数调用完毕将返回值（对象）带回函数调用处时，此时就会调用拷贝构造函数，将此对象复制给一个临时对象并传到该函数的调用处。
例如：
Point fun2() //函数fun2的返回值类型是Point类类型
{
Point p1(10,30);
return p1;
}
int main(){
Point p2;
p2=fun2(); //函数执行完成，返回调用者时，调用拷贝构造函数
return 0;
}
在上例中，对象p1是在函数fun2中定义的，在调用函数fun2结束时，p1的生命周期结束了，因此在函数fun2结束前，执行语句“return p1;”时，将会调用拷贝构造函数将p1的值复制到一个临时对象中，这个临时对象时编译系统在主程序中临时创建的。函数运行结束时，对象p1消失，但临时对象将会通过语句“p2=fun2( )”将它的值赋给对象p2。执行完成这个语句后，临时对象的使命也就完成了，该临时对象便自动消失了。
四、例子
例 1： 自定义拷贝构造函数的使用。
#include<iostream>
using namespace std;
class Point{
public:
Point(int a,int b){ //普通构造函数
x=a;
y=b;
}
Point(const Point &p){
x=2*p.x;
y=2*p.y;
}
void print(){
cout<<x<<" "<<y<<endl;
}
private:
int x,y;
};
int main(){
Point p1(30,40); //定义对象p1，调用了普通的构造函数
Point p2(p1); //用代入法调用拷贝构造函数，用对象p1初始化对象p2
Point p3=p1; //用赋值法调用拷贝构造函数，用对象p1初始化对象p3
Point p4(0,0);
p4=p1; //对象赋值
p1.print();
p2.print();
p3.print();
p4.print();
return 0;
}
执行结果：
例 2： 调用拷贝构造函数的3种情况。
#include<iostream>
using namespace std;
class Point{
public:
Point(int a=0,int b=0); //声明构造函数
Point(const Point &p); //声明拷贝构造函数
void print();
private:
int x,y;
};
Point::Point(int a,int b){ //定义构造函数
x=a;
y=b;
cout<<"Using normal constructor\n";
}
Point::Point(const Point &p){ //定义拷贝构造函数
x=2*p.x;
y=2*p.y;
cout<<"using copy constructor\n";
}
void Point::print(){
cout<<x<<" "<<y<<endl;
}
void fun1(Point p){ //函数fun1的形参是类对象
p.print();
}
Point fun2(){ //函数fun2的返回值是类对象
Point p4(10,30); //定义对象p4时，要调用普通的构造函数
return p4;
}
int main(){
//第一种
Point p1(30,20); //定义对象p1,第 1 次调用普通的构造函数
p1.print();
Point p2(p1); //建立新对象p2时，第 1 次调用拷贝构造函数
p2.print();
Point p3=p1; //建立新对象p3时，第 2 次调用拷贝构造函数
p3.print();
//第二种
fun1(p1); //第 3 次调用拷贝构造函数，调用fun1时实参与形参结合
//第三种
p2=fun2(); //fun2函数中第 2 次调用普通的构造函数 ，第 4 次调用拷贝构造函数
p2.print();
return 0;
}
执行结果：
按说，第三种情况的应该也会调用拷贝构造函数，但是显示的结果却意味着没有调用。这是由于RVO优化。
RVO优化：
return value optimistic，指当一个函数返回一个值类型而非引用类型时，可以绕过拷贝/移动构造函数，直接在调用函数的地方构造返回值。
那怎么去除RVO优化呢？
参考文章：https://blog.csdn.net/XiyouLinux_Kangyijie/article/details/78939291
https://blog.csdn.net/aaqian1/article/details/84205668
可以看到正确的执行结果了！！！
例 3： 拷贝构造函数练习-1
#include<iostream>
using namespace std;
class Point3d {
private:
int m_x;
int m_y;
int m_z;
public:
Point3d(int x,int y,int z):m_x(x),m_y(y),m_z(z) {
cout << "constructor"<<endl;
}
~Point3d() {
cout << "deconstructor"<<endl;
}
Point3d(const Point3d &other) {
this->m_x = other.m_x;
this->m_y = other.m_y;
this->m_z = other.m_z;
cout << "copy constructor"<<endl;
}
Point3d &operator=(const Point3d &other) {
if(this != &other) {
this->m_x = other.m_x;
this->m_y = other.m_y;
this->m_z = other.m_z;
}
cout << "operator="<<endl;
return *this;
}
};
Point3d factory() {
Point3d po(1,2,3); //第 1 次调用构造函数
return po; //第 1 次调用拷贝构造函数 ；
//第 1 次调用析构函数，析构掉局部对象po
}
int main() {
Point3d p = factory(); //第 2 次调用拷贝构造函数；
//第 2 次调用析构函数，析构掉临时对象_temp
//第 3 次调用析构函数，main函数结束，析构对象p
return 1;
}
执行结果：
例 4 ：拷贝构造函数练习-2
代码来自：https://blog.csdn.net/XiyouLinux_Kangyijie/article/details/78939291
#include<iostream>
using namespace std;
class A{
public:
A() = default;
A(const A &a):str(a.str){
cout<<"copy"<<endl;
}
A(const string &d):str(d){ //构造函数，形参为常量引用
cout<<"str"<<endl;
}
string str;
};
void func(A a){
cout<<a.str<<endl;
}
int main(){
func(string("hello world"));//调用std::string 的构造函数，通过一个字符串常量，构造了一个std::string对象
//这个对象是个临时值，也就是说是个右值，我们叫它为string_temp。
return 0;
}
执行结果：
首先调用std::string 的构造函数，通过一个字符串常量，构造了一个std::string对象，这个对象是个临时值，也就是说是个右值，我们叫它为string_temp。
在函数调用过程中，具有非引用类型的参数要进行拷贝初始化。这里只能通过const string &的构造函数先构造出一个临时A类型对象，再用该对象执行拷贝初始化。
String_temp和A类型并不相等，这里进行了隐式转换，单参数的隐式转换static_cast(String_temp)等同于A(String_temp)，根据String_temp的类型决议使用const std::string &类型的构造函数。
然后由于func的参数是一个A类型的对象，并且A有一个参数为const string &的构造函数，并且它没有explicit修饰，也就支持通过std::string隐式转换为A。那么在这里，便通过string_temp构造出了一个A类型对象，同样是临时值（右值），我们叫它A_temp。
但是因为func的参数是一个A类型的对象，并不是一个引用，所以应该调用拷贝构造函数将A_temp拷贝到a。
这里发生了1次string的构造（string_temp），1次A的构造(A_temp)，1次A的拷贝构造(a)。