深浅拷贝初识

先吃一个栗子：

#include <iostream>
#include <string.h>
#pragma warning(disable:4996)
using namespace std;

char* ShallowCopy(char* src) { 
	char* dst = src;
	return dst;
}
char* DeepCopy(char* src) {
	char* dst = new char[strlen(src) + 1];
	strcpy(dst, src);
	return dst;
}

int main() {
	char str[] = "foreb has a sword!";
	char* s1 = ShallowCopy(str);
	char* s2 = DeepCopy(str);
	cout << "original string：" << str << endl;
	cout << "    shallowcopy：" << s1 << endl;
	cout << "       deepcopy：" << s2 << endl;
	return 0;
}

在main()里，我们定义了一个字符数组，里面存储了一串字符，现在我们有一个需求——将字符数组里的数据拷贝一份，以作它用。

现在我们有两个拷贝函数ShallowCopy()与DeepCopy()，均可实现拷贝的功能。如下：

str中的数据现在s1也有了，s2也有了。
现在突然str数组数据因业务需求有变！str数组内容需要全部置为*。那么是s1与s2会发生改变吗？

我们可以发现，浅拷贝函数拷贝得到的s1发生变化，与str内容保持一致！而深拷贝函数拷贝得到的s2并没有变化，仍是以前的数据。

既然改变str，s1会变化，那么改动s1，str会变化吗？

可以发现，s1发生变化，str内容也会发生改变，与s1内容保持一致！s2仍然没有变化，仍是以前的数据。

那么改动s2，str与s1变化吗？

事实证明，s2改变，并不影响str与s1 。

原因何在？
看这里：
shallowcopy()仅仅将str的地址给复制了一下，而DeepCopy()则是自己申请空间，将str里的内容复制了过来。用图解释一下，如下：

实际上，str与s1完全等价，二者指向同一地址，一旦其中任何一个发生变动，都会引起另一个的变化。
这就是浅拷贝，仅仅是将拷贝对象的地址复制了一下。一旦拷贝对象是一个非内置类型数据，那么将会引起改动一个，其他都改变的现象。

而深拷贝是真正意义上的拷贝，它自己申请空间，将内容复制过来，与原数据完全独立，互不干扰。

浅拷贝存在的意义？

既然浅拷贝会导致牵一发而动全身的现象，那么它为什么还会存在呢？

存在即合理，我们不能光看到它的弊端，也要看到浅拷贝的优势。

假设这样一个场景，现在有一群人，都想看《c++ primer》，但这本书售价高达10000$，他们只能凑出一本书的钱，买了之后轮流观看。无论谁吃饭时掉了油渍，或者做了笔记，其他人看到的书都会有油渍与笔记。

而另一群人同样的问题，每个人买了一本，无论谁在自己的书上干啥，都不会影响其他人的书。

那么很明显，第一群人都学到了知识，仅仅花了一本书的钱，但随之而来的问题是谁对书有操作，其他人会得到操作后的书。

第二群人也学到了知识，哪怕烧了自己的书，都不影响别人的书，但问题在于花了好多好多钱啊。

就是这个道理，浅拷贝节省系统资源，而深拷贝的每个数据互不影响。

深浅拷贝均有自己适合的应用场景，抛开场景谈技术谁优谁劣都是耍流氓。

既然两个都有自己的适合场景，那么必然会有两个交差使用的场景啦！
深浅拷贝交差使用时，会存在一个写时拷贝的技术。

顾名思义，写即改动，在不要求改变数据实现拷贝时，使用浅拷贝即可，一旦我们发现浅拷贝的数据要发生改变，立马将其进行深拷贝的切换，使其与原数据独立起来，而后改动。这个由浅切深的拷贝即称为写时拷贝。

深浅拷贝与类

众所周知，生活在蓝星的C++学习者，都会掌握类的构造与析构函数，而构造函数下辖一个拷贝构造函数。深浅拷贝在拷贝构造函数里应用的不好，就会使类的析构出现问题。

如，浅拷贝了10个对象（非内置类型），算上被拷贝的对象，我们现在有11个对象，在析构函数执行释放空间的任务时，如果不慎忘记了浅拷贝仅仅是将地址拿来拷贝一份，将导致析构第一个对象后，再无空间可以释放，再想析构，便会产生错误！因为我们企图再次释放已经释放过的空间！此前文章里提到过，仅仅nullptr释放多次是无害的，其他空间不能被多次释放，因为导致的结果不可预知！故而报错！

一个应用写时拷贝的简单例子

#include <iostream>
#include <string.h>
#include <time.h>
#pragma warning(disable:4996)
using namespace std;

class String;

class String_cnt {
	friend class String;
public:
	String_cnt(const char* str = "") :m_cnt(0) {
		m_data = new char[strlen(str) + 1];
		strcpy(m_data, str);
	}
	String_cnt(const String_cnt& s) {
		m_data = s.m_data;
	}
	String_cnt& operator=(const String_cnt& s) {
		if (this != &s) //浅拷贝
			m_data = s.m_data;
		return *this;
	}
	~String_cnt() {
		delete[]m_data;
		m_data = nullptr;
	}
	void Increase() { ++m_cnt; }
	void Decrease() {
		--m_cnt;
		if (!m_cnt)
			delete this;
	}
	char* GetData() const { return m_data; }

private:
	char* m_data;
	int m_cnt;
};

class String {
	friend ostream& operator<<(ostream& out, const String& s);
public:
	explicit String(const char* str = "") :pn(new String_cnt(str)) {
		pn->Increase();//构造函数，串计数器+1
	}
	String(const String& s) :pn(s.pn) { pn->Increase(); }//拷贝构造，浅拷贝，新串计数器+1
	String& operator=(const String& s) {
		if (this != &s) {
			pn->Decrease();//原串计数器-1
			pn = s.pn;//浅拷贝指向新串
			pn->Increase();//新串计数器+1
		}
		return *this;
	}
	~String() { pn->Decrease(); }//析构函数，只需将串的计数器减1
	void ToUpper() {
		DepthCopy();//写时拷贝
		char* str = pn->m_data;//拿到深拷贝的串地址
		while (*str) {//小写转大写
			if (*str >= 'a' && *str <= 'z')
				*str -= 32;
			str++;
		}
	}
	void ToLower() {
		DepthCopy();//写时拷贝
		char* str = pn->m_data;//拿到深拷贝的串地址
		while (*str) {//大写转小写
			if (*str >= 'A' && *str <= 'Z')
				*str += 32;
			str++;
		}
	}	
	int Size()const {
		int length = 0;
		char* p = pn->m_data;
		while (*p)
			++length, ++p;
		return length;
	}
	bool IsEmpty() { return this->Size() == 0; }
protected:
	void DepthCopy() {//深拷贝——仅供写实拷贝使用，保护方法，外部不可访问
		String_cnt* tmp = new String_cnt(pn->m_data);
		pn->Decrease();//先将原串的计数器-1
		pn = tmp;//获得新串的地址
		pn->Increase();//新串计数器+1
	}
private:
	String_cnt* pn;
};

ostream& operator<<(ostream& out, const String& s) {
	out << s.pn->GetData();
	return out;
}
int main()
{
	String s1("adutsdutfsogfsif");
	String s2("31231");
	cout << s1.Size() << endl;
	cout << s2.Size() << endl;

	return 0;
}

又水了一篇！针不戳！