c++深拷贝、浅拷贝、写时拷贝

 【简要回忆一下c++中的拷贝构造函数】c++拷贝构造函数是c++6大默认成员函数之一

创建对象时使用同类对象来进行初始化，这时所用的构造函数称为拷贝构造函数（Copy Constructor），拷贝构造函数是特殊的构造函数。特征：1. 拷贝构造函数其实是一个构造函数的重载。2. 拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。（思考为什么？）3. 若未显示定义，系统会默认缺省的拷贝构造函数。缺省的拷贝构造函数会，依次拷贝类成员进行初始化。

【浅拷贝】（也叫值拷贝）

1.所谓浅拷贝就是指，在调用拷贝函数时，只是对数据成员进行了值拷贝，其中默认构造函数也是浅拷贝。大多数情况下，使用浅拷贝是没有问题的，但是当出现动态成员，就会出现问题。

#include<iostream>
using namespace std;
//浅拷贝
class String
{
public:
	//构造函数
	String(int a)
		:_a(a)
	{}
	//拷贝构造函数
	String(const Test& x)
	{
		_a = x._a;
	}

private:
	int _a;
};
int main()
{
	Test b(10);
	Test c(b);
	return 0;
}

2.缺陷：  浅拷贝对于指针成员不可行。多个对象共用同一块空间，同一内存地址，但是在调用析构函数释放空间的时候，多次调用析构函数，这块空间被释放了多次，此时程序就会崩溃。

【深拷贝】（也叫址拷贝）

1.采取在堆中申请新的空间来存取数据，这样数据之间相互独立。址拷贝。

2.以String类为例

//传统深拷贝
class String
{
public:
	String(char *str = "")
	{
		_str = new char[strlen(str)+1];
		strcpy(_str,str);
	}
	//s1(s)
	String(const String& s)
	{
		_str = new char[strlen(s._str)+1];
		strcpy(_str,s._str);
	}
	String& operator=(const String& s)
	{
		if(this!=&s)
		{
			_str = new char[strlen(s._str)+1];
			strcpy(_str,s._str);		
		}

		return *this;
	}
	~String()
	{
		delete[] _str;
	}
	char* GetStr()
	{
		return _str;
	}
private:
	char* _str;
};

//现代深拷贝
class String
{
public:
	String(char *str = "")
	{
		_size = strlen(str);
		_capacity = _size;
		_str = (char*)malloc(strlen(str)+1);
		strcpy(_str,str);
	}
	void Swap(String& s)
	{
		swap(_str,s._str);
		swap(_size,s._size);
		swap(_capacity,s._capacity);
	}
	//s1(s)
	String(String& s)
		:_str(NULL)
	{
		String tmp(s._str);
		Swap(s);
	}
	String& operator=(String s)
	{
		Swap(s);
		return *this;
	}
	~String()
	{
		free(_str);
	}
	char* GetStr()
	{
		return _str;
	}

private:
	char* _str;

};

大家可看到，传统深拷贝和现代深拷贝都进行开辟空间，但现代深拷贝更好一些，因为复用了之前的代码，在使用和修改时更加方便。

【写时拷贝】

在我们简单了解了深浅拷贝的时候，我们这样想，浅拷贝在数据成员有指针时，析构会出现问题，而深拷贝虽然解决了这个问题，然而在不需要对该内容进行修改或者没有指针对象要用时，深拷贝必然会进行开辟空间，这又多此一举，那么我们能不能实现一种拷贝，在该需要浅拷贝时就浅拷贝，该需要开辟空间时就开辟空间，这时写时拷贝应用而生。

1、概念：但是当其中一个对象改变它的值时，其他对象的值就会随之改变，所以此时我们采取这样一种做法，就是写时拷贝。

2、核心思想：

（写入时拷贝）如果有多个调用者同时要求相同资源（如内存或磁盘上的数据存储），它们会共同获取相同的指针指向的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程中对其他调用者都是透明的。做法的优点：如果调用者没有修改该资源，就不会有副本被创建，因此多个调用者只是读取操作时可以共享同一份资源

（写时拷贝）指用浅拷贝的方法拷贝其他对象，多个指针指向同一块空间，只有当对其中一个对象修改时，才会开辟一个新的空间给这个对象，和它原来指向同一空间的对象不会收到影响。

3、做法：给要改变值的那个对象重新new出一块内存，然后先把之前的引用的字符数据复制到新的字符数组中，这就是写时拷贝。注意，同时还要把之前指向的内存的引用计数减1（因为它指向了新的堆中的字符数组），并在堆中重新new一个块内存，用于保存新的引用计数，同时把新的字符数组的引用计数置为1。因为此时只有一个对象（就是改变值的对象）在使用这个内存。

4.代码实现

class String
{
public:
	String(char *str = "")
	{
		_str = new char[strlen(str)+5];
		GetCount() = 1;
		_str = _str+4;
		strcpy(_str,str);
	}
	String(String& s)
		:_str(s._str)
	{
		++(s.GetCount());
	}
	~String()
	{
		Release();
	}
	String& operator=(String& s)
	{
		if(this!=&s)
		{
			Release();
			_str = s._str;
			++GetCount();
		}
		return *this;
	}
public:
	char& operator[](size_t pos)
	{
		if(GetCount()==1)
		{
			return _str[pos];
		}
		--GetCount();
		char *tmp = _str;
		_str = new char[strlen(tmp)+5];
		_str += 4;
		strcpy(_str,tmp);
		GetCount() = 1;
		return _str[pos];
	}
	char* GetStr()
	{
		return _str;
	}
private:
	int& GetCount()
	{
		return *((int*)(_str-4));
	}

	void Release()
	{
		if(--GetCount()==0)
		{
			cout<<"delete"<<endl;
			delete[] (_str-4);
			_str = NULL;
		}
	}
private:
	char *_str;
};

void Test()
{
	String s1("hello");
	cout<<s1.GetStr()<<endl;
	String s2(s1);
	cout<<s2.GetStr()<<endl;
	s2[0] = 'w';
	cout<<s2.GetStr()<<endl;
}

【注意】：因为不止一个对象使用这一块内存，当修改自己的时，也等于修改了他人的。在向这块存储单元写之前，应该确信没有其他人使用它。如果引用计数大于1，在写之前必须拷贝这块存储单元，这样就不会影响他人了。