C++那些细节--拷贝构造函数

心已赠人 2022-08-02 12:00 212阅读 0赞

关于C++拷贝构造函数，一直不是很明白，于是强迫症又发作，一定要搞懂它！！

另外附上参考的文章（这位大神写得实在太棒了，让我瞬间搞懂了这个纠结了很久的问题）：

[http://blog.csdn.net/lwbeyond/article/details/6202256/][http_blog.csdn.net_lwbeyond_article_details_6202256]

## 一.简介： ##

拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。

## 二.自动生成拷贝构造函数： ##

结果如下：

Construct!  
t1 1  
请按任意键继续. . .

Q&A

1.咦？这里木有写那个传说中的拷贝构造函数啊！为什么还是实现了拷贝呢？

原因是如果我们不写，编译器会为我们自动生成一个拷贝构造函数（类似构造函数和析构函数，如果不写，编译器也会为我们自动生成）。

2.那既然会为我们生成，我们为什么还要写拷贝构造函数呢？

因为自动生成的拷贝构造函数只能实现浅拷贝，不能进行深拷贝。关于浅拷贝和深拷贝在下面具体写。简单的说，就是系统自带的一些数据类型可以实现拷贝，而一些复杂的，指针等，不能进行拷贝，这样自动生成的拷贝构造函数肯定不能满足我们的要求，所以我们就要自己写一个拷贝构造函数啦！

## 三.我们自己的拷贝构造函数： ##

免费不一定适合我们，所以我们还是要自己写一个拷贝构造函数，才能更好的实现需要的功能。看一下，真正的拷贝构造函数是什么样子的东东：

结果：

Construct!  
Copy Construct!  
t1 1  
请按任意键继续. . .

可见，系统调用了我们写的拷贝构造函数。

关于拷贝构造函数的几点注意事项：

1.拷贝构造函数是一种特殊的构造函数，函数名必须与类型名一样，参数必须为一个本类型的引用（添加点其他的东东之后，发现系统就不调这个函数了）。

2.我们一般把这个参数引用写成常量引用，因为我们不希望在拷贝的时候，把原对象改动了...不过，const不是强制的，比如加个计数变量神马功能的时候，还是可能需要改动的。

## 四.什么时候会调用拷贝构造函数 ##

这也是个很关键的问题，我们只是写了拷贝构造函数，但是我们并没有直接调这个函数，一般都是我们在进行几个操作的时候，自动调用拷贝构造函数的。

一共有三种情况：1.对象通过另一个对象进行初始化时 2.通过传值方式传递参数时 3.通过传值方式返回值时。下面分别来看三种情况：

**1.对象通过另一个对象进行初始化时**

这个是最好理解的一种方式，直接复制另一个对象的各种属性，来达到创建一个对象的目的。这个从字面上理解我们也会想到会调用拷贝构造函数。

例如：

CopyTest t2 = t1;
    //或者CopyTest t2(t1);

通过=赋值时，或者直接按照拷贝构造函数的定义方式来调用，将一个对象的引用传递给拷贝构造函数，就可以通过拷贝的方式生成一个新对象。

**2.第二种是通过值传递的方式，将对象作为参数传入函数时，会调用拷贝构造函数**

例如：

// C++Test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    
    class CopyTest
    {
    private:
    	string name;
    	int id;
    public:
    	CopyTest(int i, string n):id(i),name(n)
    	{
    		cout<<"Construct!"<<endl;
    	}
    
    	~CopyTest()
    	{
    		cout<<"Destruct!"<<endl;
    	}
    
    	//拷贝构造函数
    	CopyTest(CopyTest& e)
    	{
    		name = e.name;
    		id = e.id;
    		cout<<"Copy Construct!"<<endl;
    	}
    
    	void Display()
    	{
    		cout<<name<<" "<<id<<endl;
    	}
    };
    
    
    //值传递方式传递参数的函数
    void PassByValue(CopyTest e)
    {
    	cout<<"Function is called!"<<endl;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	CopyTest t1(1, "t1");
    	PassByValue(t1);
    
    	system("pause");
    	return 0;
    }

结果：

Construct!  
Copy Construct!  
Function is called!  
Destruct!  
请按任意键继续. . .

可见，我们并没有明显的对象赋值操作，但是仍然调用了拷贝构造函数。而且，在这个里面，我们并没有使用我们传递进来的参数，但是拷贝构造函数仍然调用了，即生成了一个临时的对象，并且，这个临时对象在函数调用完成后，被析构掉了。

我们来分析一下这个过程，对象以值传递的时候，在函数中的操作都不会影响到原对象，这就说明值传递过程中，函数中操作的对象和传递进来的对象不是同一个对象！而是通过拷贝构造函数生成的一个对象。这个过程类似于：CopyTest t2(t1);，我们传递进来的参数为t1,而根据拷贝构造函数生成了对象t2，与t1属性字段均相同，但不是同一个对象。在操作完成后，会销毁这个临时对象。

**3.对象以值传递的方式返回时**

当我们从函数中返回一个对象，并且是用值传递的方式时，会调用拷贝构造函数：

例如：

// C++Test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    
    class CopyTest
    {
    private:
    	string name;
    	int id;
    public:
    	CopyTest(int i, string n):id(i),name(n)
    	{
    		cout<<"Construct!"<<endl;
    	}
    
    	~CopyTest()
    	{
    		cout<<"No"<<id<<" "<<"Destruct!"<<endl;
    	}
    
    	//拷贝构造函数
    	CopyTest(CopyTest& e)
    	{
    		name = e.name;
    		//为了更好的分辨出哪个是原对象哪个是拷贝出来的对象，这里做了一点小手脚，拷贝时id会+1
    		id = e.id + 1;
    		cout<<"Copy Construct!"<<endl;
    	}
    
    	void Display()
    	{
    		cout<<name<<" "<<id<<endl;
    	}
    };
    
    //值传递方式从函数中返回
    CopyTest ReturnByValue()
    {
    	CopyTest t(1, "test");
    	return t;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	 ReturnByValue();
    
    	system("pause");
    	return 0;
    }

结果：

Construct!  
Copy Construct!  
No1 Destruct!  
No2 Destruct!  
请按任意键继续. . .

（注意：这里为了能够分辨出哪个是拷贝出来的，哪个是原来的，将拷贝构造函数做了一点手脚，拷贝之后，拷贝出来的对象id+1）

简单分析一下这个过程:

创建一个临时对象t，id为1，然后要返回这个对象，调用拷贝构造函数，生成一个临时对象，t1，类似CopyTest t1(t)，生成的对象为t1，id为2。在出了函数作用域时，我们发现，竟然 是先析构的原来的对象id为1的，然后才析构的拷贝构造函数生成的临时对象t1。

## 五.右值引用与转移语义： ##

如果我们声明一个对象，然后直接后面跟这个函数，那么这个临时对象的析构函数不会调用。这里发生了什么呢？就是传说中的右值引用与转移语义。所谓右值就是临时对象，即将被销毁的对象，如果我们不使用右值的话，就要重新创建一个对象，调用拷贝构造函数等一大堆东西，然后还要销毁这个临时的对象，但是我们通过右值，直接使用转移语义，一是不用重新创建对象，也不用销毁原来的对象，直接相当于把新的对象指针指向原来的那个要被销毁的对象，这样，大大的提高了效率。

而分割线下面，则是非声明的情况，函数返回值赋值给一个已经存在的对象。可见这里临时对象被销毁了。这个 就没有发生转移，因为是赋值，而不是初始化对象。

// C++Test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    
    class CopyTest
    {
    private:
    	string name;
    	int id;
    public:
    	CopyTest(int i, string n):id(i),name(n)
    	{
    		cout<<"Construct!"<<endl;
    	}
    
    	~CopyTest()
    	{
    		cout<<"No"<<id<<" "<<"Destruct!"<<endl;
    	}
    
    	//拷贝构造函数
    	CopyTest(CopyTest& e)
    	{
    		name = e.name;
    		id = e.id + 1;//为了更好的分辨出哪个是原对象，这里做了一点小手脚，拷贝出来的对象id+1
    		cout<<"Copy Construct!"<<endl;
    	}
    
    	void Display()
    	{
    		cout<<name<<" "<<id<<endl;
    	}
    };
    
    
    //值传递方式传递参数的函数
    void PassByValue(CopyTest e)
    {
    	cout<<"Function is called!"<<endl;
    }
    
    //值传递方式从函数中返回
    CopyTest ReturnByValue()
    {
    	CopyTest t(1, "test");
    	return t;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	
    	CopyTest t = ReturnByValue();
    	cout<<"--------------------------------------"<<endl;
    	 t = ReturnByValue();
    
    
    	system("pause");
    	return 0;
    }

Construct!  
Copy Construct!  
No1 Destruct!  
\--------------------------------------  
Construct!  
Copy Construct!  
No1 Destruct!  
No2 Destruct!  
请按任意键继续. . .

##    六.深拷贝和浅拷贝 ##

**1.浅拷贝**

先看个例子，上面我们说过，自动生成的拷贝构造函数不一定能用，这个例子就是最好的印证：

结果：

恩，崩了...

![Center][]

为啥会崩了呢？我们分析一下：

编译器为我们生成的拷贝构造函数只能进行浅拷贝，所谓浅拷贝，就是只是对对象的数据成员进行简单的赋值，而当对象中包含有动态生成的成员时，我们还是一味的赋值就不正确了。

![Center 1][]

上面的程序进行浅拷贝时，指针也是简单的赋值了一下pointer = e.pointer，而指针所指向的位置是相同的！！！那么，第一个对象销毁时，指针所指向的位置内存被释放了，第二个对象pointer所指向的位置与第一个相同，那么第二个对象使用该指针时就会出现问题！！！这里面，我们再次delete该对象，所以就崩了...

**2.深拷贝**

我们想要的不是这种，而是下面这张图的效果：

![Center 2][]

这张图就是我们想要的深拷贝，那么要想这样，我们就需要重新申请一块内存，然后让拷贝出来的对象的pointer指向该位置，并且将该位置的值赋成与原对象相同即可。

// C++Test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    
    
    class CopyTest
    {
    private:
    	string name;
    	int id;
    	int* pointer;
    public:
    	CopyTest(int i, string n):id(i),name(n)
    	{
    		pointer = new int(1);
    		cout<<"Construct!"<<endl;
    	}
    
    	~CopyTest()
    	{
    		delete pointer;
    		cout<<"No"<<id<<" "<<"Destruct!"<<endl;
    	}
    
    	//拷贝构造函数
    	CopyTest(CopyTest& e)
    	{
    		name = e.name;
    		id = e.id + 1;//为了便于区分，这里把拷贝构造函数做了一点手脚，拷贝出来的东东id+1
    		pointer = new int();//重新分配一块内存
    		*pointer = *(e.pointer);//给该内存赋值，与原对象值相同
    		cout<<"Copy Construct!"<<endl;
    	}
    
    	void Display()
    	{
    		cout<<name<<" "<<id<<endl;
    	}
    };
    
    void TestFunc()
    {
    	//函数执行完后，会进行析构操作
    	CopyTest t1(1, "test");
    	CopyTest t2(t1);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	TestFunc();
    	system("pause");
    	return 0;
    }

结果：

Construct!  
Copy Construct!  
No2 Destruct!  
No1 Destruct!  
请按任意键继续. . .

恩,这样就不崩了！我们实现了深拷贝！

总结一下：

所谓浅拷贝就是无脑的将对象中的值拷贝过来，如果对象中存在指针等动态成员，那么浅拷贝就会出现问题。

深拷贝则不然，深拷贝在遇到指针时，会另外申请一块内存，用指针指向，这样就不会出现问题。

## 七.防止按值传递 ##

通过上面的分析，我们发现如果是按值传递参数或者返回时，调用拷贝构造函数。那么，我们换个角度想一下，如果想要不让按值传递发生，即限制按值传参的发生，即限制拷贝构造函数即可。如果我们不写，系统会给我们生成一个拷贝构造函数，那么我们写一个，把它定义成私有的，不就可以了嘛！！！我靠！太机智了！！！

// C++Test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    
    
    class CopyTest
    {
    private:
    	string name;
    	int id;
    	int* pointer;
    	//私有的拷贝构造函数
    	CopyTest(CopyTest& e);
    public:
    	CopyTest(int i, string n):id(i),name(n)
    	{
    		pointer = new int(1);
    		cout<<"Construct!"<<endl;
    	}
    
    	~CopyTest()
    	{
    		delete pointer;
    		cout<<"No"<<id<<" "<<"Destruct!"<<endl;
    	}
    
    	void Display()
    	{
    		cout<<name<<" "<<id<<endl;
    	}
    };
    
    void TestFunc()
    {
    	//函数执行完后，会进行析构操作
    	CopyTest t1(1, "test");
    	CopyTest t2(t1);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	TestFunc();
    	system("pause");
    	return 0;
    }

这样，我们编译一下：

![Center 3][]

恩，编译的时候出现的错误是最容易发现的，比运行时再调试方便多了....

## 八.几个注意的地方： ##

1. 以下函数哪个是拷贝构造函数,为什么?

X::X(const X&);      
    X::X(X);      
    X::X(X&, int a=1);      
    X::X(X&, int a=1, int b=2);

解答：对于一个类X, 如果一个构造函数的第一个参数是下列之一:  
a) X&  
b) const X&  
c) volatile X&  
d) const volatile X&  
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.

X::X(const X&);  //是拷贝构造函数      
    X::X(X&, int=1); //是拷贝构造函数     
    X::X(X&, int a=1, int b=2); //当然也是拷贝构造函数

2. 一个类中可以存在多于一个的拷贝构造函数吗?  
解答：类中可以存在超过一个拷贝构造函数。

class X {   
    public:         
      X(const X&);      // const 的拷贝构造  
      X(X&);            // 非const的拷贝构造  
    };

注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.

class X {      
    public:  
      X();      
      X(X&);  
    };      
      
    const X cx;      
    X x = cx;    // error

如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。  
这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。

[http_blog.csdn.net_lwbeyond_article_details_6202256]: http://http://blog.csdn.net/lwbeyond/article/details/6202256/
[Center]: /images/20220731/079dff6b67cb42528f8eadf14eced050.png
[Center 1]: /images/20220731/2a0cca4384484e43941f1a84817c5ac4.png
[Center 2]: /images/20220731/eb52bef5be984892bbd3450e3677c981.png
[Center 3]: /images/20220731/75a0c6a377c94125ae3732fdebf6c79a.png