深浅拷贝~
- 深浅拷贝初识
- 浅拷贝存在的意义？
- 深浅拷贝与类
- 一个应用写时拷贝的简单例子
深浅拷贝初识
先吃一个栗子：
#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;
}又水了一篇！针不戳！
