c/c++整理--复制构造函数和深复制及浅复制

た入场券 2022-06-13 11:37 192阅读 0赞

# 一、复制构造函数是什么？什么是深复制和浅复制？ #

## 什么是复制构造函数 ##

先来说明什么是复制构造函数，以及它被调用的场合。

复制构造函数是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构件及初始化。

如果在类中没有显示地声明一个复制构造函数，那么编译器会私下里制定一个函数来进行对象之间的位复制。这个隐含的复制构造函数简单地关联了所有的类成员。

在c++中，下面是3种对象需要复制的情况。因此，复制构造函数将会被调用。

（1）一个对象以值传递的方式传入函数体。

（2）一个对象以值传递的方式从函数返回。

（3）一个对象需要通过另外一个对象进行初始化。

下面的程序代码说明了上述三种情况。

#include <iostream>
    
    using namespace std;
    
    class Test
    {
    public:
    	int a;
    	Test() { }
    	Test(int x)
    	{
    		a = x;
    	}
    	Test(Test& test)							//复制构造函数
    	{
    		cout<<"copy constructor"<<endl;
    		a = test.a;
    	}
    };
    
    void fun1(Test test)							//值传递传入函数体
    {
    	cout<<"fun1()..."<<endl;
    }
    
    Test fun2()										//值传递从函数返回	
    {
    	Test t(2);
    	cout<<"fun2()..."<<endl;
    	return t;
    }
    
    int main()
    {
    	Test t1(1);
    	Test t2 = t1;								//用t1对t2进行初始化
    	cout<<"before fun1()..."<<endl;
    	fun1(t1);
    	
    	Test t3;
    	t3 = fun2();
    	cout<<"after fun2()..."<<endl;
    
        return 0;
    }

运行结果：

copy constructor
    before fun1()...
    copy constructor
    fun1()...
    fun2()...
    after fun2()...

fun1、fun2以及代码第36行分别对应了上面三种调用复制构造函数的情况。

## 深复制与浅复制    ##

既然系统会自动提供一个默认的构造函数来处理复制，那么为什么要去自定义复制构造函数呢？下面的程序说明了这个问题。

#include <iostream>
    #include <string.h>
    using namespace std;
    
    class Test
    {
    public:
    	char *buf;
    	Test(void)									//不带参数构造函数
    	{
    		buf = NULL;
    	}
    	Test(const char* str)						//带参数构造函数
    	{
    		buf = new char[strlen(str)+1];			//分配堆内存
    		strcpy(buf, str);						//复制字符串
    	}
    	~Test()
    	{
    		if(buf != NULL)
    		{
    			delete buf;							//释放buf指向的堆内存
    			buf = NULL;
    		}
    	}
    };
    
    int main()
    {
    	Test t1("hello");
    	Test t2 = t1;								//调用默认的复制构造函数
    	
    	cout<< "(t1.buf == t2.buf) ? " <<(t1.buf == t2.buf ? "yes" : "no") <<endl;
    	
        return 0;
    }

这里Test类的buf成员是一个字符指针，在带参数的构造函数中为之分配了一块堆内存来存放字符串，然后在析构函数中又将堆内存释放。在main函数（代码第31行）使用了对象复制，因此会调用默认的复制构造函数。程序执行结果：

(t1.buf == t2.buf) ? yes
    程序崩溃

这里程序崩溃发生在main函数退出对象析构的时候。由前两行的打印结果可以看出，默认复制构造函数只是简单的把两个对象的指针做复制运算，它们指向的是同一个地址。当产生两次析构，释放同一块内存时发生崩溃。可以在Test类里通过添加一个自定义的复制构造函数解决两次析构问题。

Test(Test& test)
    	{
    		buf = new char[strlen(test.buf)+1];			
    		strcpy(buf, test.buf);		
    	}

程序结果如下：

(t1.buf == t2.buf) ? no

由于此时buf又分配了一块堆内存来保存字符串，t1的buf和t2的buf分别指向不同的堆内存，析构时就不会发生程序崩溃。

总结：

**如果复制的对象中引用了某个外部的内容（例如分配在堆上的数据），那么在复制这个对象的时候，让新旧两个对象指向同一个内容，就是浅复制；如果在复制这个对象的时候，为新对象制作了外部对象的独立复制，那么就是深复制。**

复制构造函数是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构件及初始化。

浅复制是指让新旧两个对象指向同一个外部内容，二深复制就是指为新对象制作了外部对象的独立复制。

# 二、编译器与默认的copy constructor #

什么时候编译器会生成默认的copy constructor呢？如果已经写了一个构造函数，编译器还会生成copy constructor吗？

答案：

如果用户没有自定义复制构造函数，并且在代码中用到了复制构造函数，那么编译器就会生成默认的复制构造函数；但如果用户定义了复制构造函数，那么编译器就不会再生成复制构造函数。

如果用户定义了一个构造函数，且不是复制构造函数，而此时在代码中用到了复制构造函数，那么编译器也还会生成默认的复制构造函数；如果没有使用，则编译器就不会生成默认的复制构造函数。

# 三、写一个继承类的复制构造函数 #

当然，如果基类中没有私有成员，即所有成员都能被派生类访问，则派生类的复制构造函数可以很容易写。但是如果基类有私有成员，并且这些私有成员必须在调用派生类的复制构造函数时被初始化，在这种情况下该怎么做？

编写继承类的复制函数有一个原则：使用基类的复制构造函数。这个原则其实就是解决上述问题的方案。

#include <iostream>
    
    using namespace std;
    
    class Base
    {
    	int i;
    public:
    	Base():i(0) { cout<< "Base()"<<endl; }				//默认普通构造函数
    	Base(int n):i(n) { cout<< "Base(int)"<<endl; }		//普通构造函数
    	Base(const Base& b) : i(b.i)						//复制构造函数
    	{
    		cout<<"Base(Base&)"<<endl;
    	}
    };
    
    class Deriverd : public Base
    {
    	int j;
    public:
    	Deriverd():Base(0), j(0) { cout<< "Deriverd()"<< endl; }
    	Deriverd(int m, int n):Base(m), j(n) { cout<< "Deriverd(int)" <<endl; }
    	Deriverd(Deriverd &obj):Base(obj), j(obj.j)
    	{
    		cout<<"Deriverd(Deriverd&)"<<endl;
    	}
    };
    
    int main()
    {
    	Base b(1);
    	Deriverd obj(2, 3);
    	cout<<"——————————————————"<<endl;
    	Deriverd d = obj;
    	cout<<"——————————————————"<<endl;	
    
        return 0;
    }

Derived类继承自Base类，因此在Derived类内不能使用obj.i或Base::i的方式访问Base的私有成员i。很明显，其复制构造函数只能使用Base（obj）的方式调用其基类的复制构造函数类给基类的私有生源i初始化。

# 三、复制构造函数与赋值函数有什么区别？    #

3个方面：

（1）复制构造函数是一个对象来初始化一块内存区域，这块内存就是新对象的内存区。

class A;
    A a;
    A b = a;              //复制构造函数调用
    
    A b(a);               //复制构造函数调用

而赋值函数是对于一个已经被初始化的对象来进行operator=操作。

class A;
    A a;
    A b;
    b = a;      //赋值函数调用

（2）一般来说是在数据成员包含指针对象的时候，应付两种不同的处理需求：一种是复制指针对象，一种是引用指针对象。复制构造函数在大多数情况下是复制，赋值函数则是引用对象。

（3）实现不一样。复制构造函数首先是一个构造函数，它调用的时候是通过参数传进来的那个对象来初始化产生一个对象。赋值函数是把一个对象赋给一个原有对象，所以如果原来的对象中有内存分配，要先把内存释放掉，而且还要检查一下两个对象是不是同一个对象，如果是的话，就不做任何操作。