深浅拷贝——利用模拟实现basic_string深入理解

一、深浅拷贝的基本概念

深拷贝和浅拷贝都是指在对象复制时，复制对象的内存空间的方式。

1.1 深浅拷贝的不同之处

浅拷贝是指将一个对象的所有成员变量都直接拷贝给另一个对象，包括指针成员变量，两个对象共享同一块内存空间。

深拷贝是指在对象复制时，分配一块新的内存空间，将原对象的成员变量复制到新的内存空间中。

1.2 适用场景及优缺点

浅拷贝通常用于类的复制操作，可以在一定程度上提高性能，但是如果一个对象的成员变量指向的是堆内存空间，那么当其中一个对象释放了这块内存空间后，另一个对象仍然指向这块内存空间，容易出现问题。

浅拷贝适用于对象的成员变量是基本数据类型，或指向栈空间的指针的情况。因为这些数据类型的内存是在栈上分配的，所以可以直接拷贝，共享同一块内存空间也不会带来问题。

深拷贝可以避免两个对象共享同一块内存空间带来的问题，但是也会增加内存空间的消耗，以及复制成员变量的时间消耗。

深拷贝适用于对象的成员变量是指向堆内存空间的指针，或者成员变量是对象的情况。因为这些情况下，如果采用浅拷贝的方式，两个对象共享同一块内存空间，可能会导致一个对象释放了内存空间，另一个对象还在使用这块内存空间，造成不可预料的错误。

二、basic_string的模拟实现

2.1 中规中矩的传统写法

#include<iostream>;
#include<string.h>;using namespace std;//深浅拷贝——利用模拟实现basic_string深入理解
namespace yfy
{class string{public:string(const char* str):_str(new char[strlen(str) + 1])	//若此处不在堆上开空间，而是将str作为参数赋值给_str，就是浅拷贝，其后果是无法修改常量字符串{strcpy(_str, str);}string(const string& s):_str(new char[strlen(s._str) + 1])		//自定义拷贝构造函数，深拷贝————开辟同样大小空间，并将数据拷贝{strcpy(_str, s._str);}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){return _str[pos];}string& operator=(const string& s)		//不管左值右值谁长，直接将左值释放，开辟和右值同样大小空间，再拷贝右值{if (this != &s)		//防止自己给自己赋值{char* tmp = new char[strlen(s._str) + 1];	//如果先释放_str，new失败了会导致赔了夫人又折兵，new如果失败会抛异常，所以先不要释放_str，new成功后再释放delete[] _str;									_str = tmp;strcpy(_str, s._str);}return *this;}private:char* _str;};void test_string1(){string s1("hello");s1[0] = 'x';string s2(s1);//若是编译器默认实现的拷贝构造，则为浅拷贝————导致：1、同一块空间析构两次 2、一个对象修改值，另一个随之改变string s3("hello world");s1 = s3;}
}int main()
{yfy::test_string1();return 0;
}

2.2 富有"资本主义"的现代写法

//拷贝构造string(const string& s):_str(nullptr)			//若不置空，tmp作为临时变量，在生命结束时调用析构，此时tmp为一个随机值，会出问题{string tmp(s._str);		//调用构造函数为tmp开空间swap(_str, tmp._str);}//赋值string& operator=(string s){swap(_str, s._str);return *this;}

3.3 basic_string模拟汇总

#include<iostream>
#include<string.h>
#include<assert.h>using namespace std;//深浅拷贝——利用模拟实现basic_string深入理解
namespace yfy
{class string{public:typedef char* iterator;			//string 中的迭代器就是原生指针typedef const char* const_iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}const_iterator begin() const{return _str;}const_iterator end() const{return _str + _size;}/*string()						//默认构造函数:_str(new char[1]), _size(0), _capacity(0){*_str = '\\0';//初始化}*/string(const char* str = "")	//给一个空串作为缺省值即可替代上面的默认构造函数:_size(strlen(str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}void swap(string& s){::swap(_str, s._str);		//swap前加作用域限定符代表调用全局域中的swap函数，若不加，编译器无法区分::swap(_size, s._size);::swap(_capacity, s._capacity);}string(const string& s):_str(nullptr)			//若不置空，tmp作为临时变量，在生命结束时调用析构，此时tmp为一个随机值，会出问题{string tmp(s._str);		//调用构造函数为tmp开空间this->swap(tmp);}~string(){delete[] _str;_str = nullptr;}//可读可写char& operator[](size_t pos){assert(pos < _size);return _str[pos];}//只读const char& operator[](size_t pos) const{assert(pos < _size);return _str[pos];}string& operator=(string s){this->swap(s);return *this;}void reserve(size_t n)		//重新开辟空间{if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void resize(size_t n, char ch = '\\0'){if (n <= _size){_size = n;_str[_size] = '\\0';}else{if (n > _capacity){reserve(n);}for (size_t i = _size; i < n; i++){_str[i] = ch;}_size = n;_str[_size] = '\\0';}}void push_back(char ch){//if (_size >= _capacity)//{//	size_t newcapactiy = _capacity == 0 ? 4 : _capacity * 2;//	reserve(newcapactiy);//}//_str[_size] = ch;//++_size;//_str[_size] = '\\0';insert(_size, ch);}void append(const char* str){//size_t len = strlen(str);//if (_size + len > _capacity)//{//	reserve(_size + len);//}//strcpy(_str + _size, str);//_size += len;insert(_size, str);}string& operator+=(char ch){push_back(ch);return *this;}string& operator+=(const char* str){append(str);return *this;}string& operator+=(const string& s){*this += s._str;return *this;}size_t size() const{return _size;}size_t capacity() const{return _capacity;}string& insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}int end = _size;						//进行头插时，此处的end会变为负数，在与pos比较时会整型提升到无符号数，从而导致死循环while (end >= (int)pos)						//解决方案：将比较时的pos强转为int或控制end不能为负数{_str[end + 1] = _str[end];end--;}_str[pos] = ch;_size++;return *this;}string& insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (len == 0)				//插入空串{return *this;}if (_size + len > _capacity){reserve(_size + len);}size_t end = _size + len;while (end >= pos + len)			//字符移位{_str[end] = _str[end - len];end--;}											for (int i = 0; i < len; i++)		//字符填充{_str[pos + i] = str[i];}_size += len;return* this;}string& erase(size_t pos, size_t len = npos){assert(pos < _size);if (len == npos || pos + len >= _size)			//删除的长度大于剩余的长度{_str[pos] = '\\0';_size = pos;}else                                            //删除的长度小于剩余长度，需要把遗留字符移花接木 {strcpy(_str + pos, _str + pos + len);_size -= len;}return *this;}const char* c_str(){return _str;}void clear(){_str[0] = '\\0';_size = 0;}size_t find(char ch, size_t pos = 0){for (size_t i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;}size_t find(const char* sub, size_t pos = 0){const char* p = strstr(_str + pos, sub);if (p == nullptr){return npos;}else{return p - _str;}}private:char* _str;size_t _size;size_t _capacity;static const size_t npos;};const size_t string::npos = -1;ostream& operator<<(ostream& out, const string& s){for (size_t i = 0; i < s.size(); i++){out << s[i];}return out;}istream& operator>>(istream& in, string& s){s.clear();char ch;//in >> ch;                    //如此写会自动忽略换行和空格，导致死循环ch = in.get();while (ch != ' ' && ch != '\\n'){s += ch;ch = in.get();}return in;}istream& getline(istream& in, string& s){s.clear();char ch;ch = in.get();while (ch != '\\n')			//区别在于读到空格不结束{s += ch;ch = in.get();}return in;}void print(const string& s1)					//输入时用于清空字符串{for (int i = 0; i < s1.size(); i++){cout << s1[i] << " ";					//s1不可修改，所以[]需要有两个版本}cout << endl;string::const_iterator it = s1.begin();			//s1不可修改，所以定义const迭代器和重载begin和endwhile (it != s1.end()){cout << *it << " ";it++;}cout << endl;}bool operator>(const string& s1, const string& s2){size_t i1 = 0, i2 = 0;while (i1 < s1.size() && i2 < s2.size()){if (s1[i1] > s2[i2]){return true;}else if (s1[i1] < s2[i2]){return false;}else{i1++;i2++;}}//abc abc	false//abcd abc	true//abc abcd	falseif (i1 == s1.size()){return false;}else{return true;}}bool operator==(const string& s1, const string& s2){size_t i1 = 0, i2 = 0;while (i1 != s1.size() && i2 != s2.size()){if (s1[i1] != s2[i2]){return false;}else{i1++;i2++;}}if (i1 == s1.size() && i2 == s2.size()){return true;}else{return false;}}bool operator!=(const string& s1, const string& s2){return !(s1 == s2);}bool operator>=(const string& s1, const string& s2){return (s1 > s2 || s1 == s2);}bool operator<(const string& s1, const string& s2){return !(s1 >= s2);}bool operator<=(const string& s1, const string& s2){return !(s1 > s2);}string operator+(const string& s1, const char* str){string ret = s1;										//存在深拷贝对象，尽量少用ret += str;return ret;}void test_string1(){string s1("hello");s1[0] = 'x';string s2(s1);//若是编译器默认实现的拷贝构造，则为浅拷贝————导致：1、同一块空间析构两次 2、一个对象修改值，另一个随之改变string s3("hello world");s1 = s3;s1.push_back(' ');s1.append("by");s1 += ' ';s1 += "cplusplus";}void test_string2(){string s1;string s2(s1);//s1 += 'x';s1 += "hello";s1.resize(2);s1.resize(8, 'x');}void test_string3(){string s1("hello world");//遍历字符串————三种方式：普通for循环、迭代器、范围forfor (int i = 0; i < s1.size(); i++){cout << s1[i] << " ";}cout << endl;string::iterator it = s1.begin();			//指定iterator在string类域中，而不在全局中while (it != s1.end()){cout << *it << " ";it++;}cout << endl;for (auto e : s1)			//语法上支持迭代器、迭代器命名规范即可使用范围for--本质上是替换为迭代器{cout << e << " ";}cout << endl;print(s1);}void test_string4(){string s1("hello world");s1.insert(5, 'x');s1.push_back('!');s1.insert(0, ' ');s1.insert(0, "hehe");s1.erase(0, 5);cout << s1.c_str() << endl;}void test_string5(){string s1("hello world");s1.resize(20);s1[18] = 'x';cout << s1 << endl;						//区别在于输出了_size个字符cout << s1.c_str() << endl;				//遇到\\0就终止string s2("hehe");cin >> s2;cout << s2 << endl;}void test_string6(){string s1;//cin >> s1;			//输入带空格的字符//cout << s1 << endl;getline(cin, s1);cout << s1 << endl;}
}int main()
{//yfy::test_string1();//yfy::test_string2();//yfy::test_string3();//yfy::test_string4();//yfy::test_string5();yfy::test_string6();return 0;
}

三、关于string对象的大小

在 Visual Studio 2019 中，当 basic_string 的长度小于等于 15 个字符时，标准库会将字符串的字符数组存储在 basic_string 对象内部的一个名为 buf 的字符数组中，而不是动态分配内存。这个 buf 数组的大小是 16 个字节，其中包括 15 个字符和一个用于存储字符串结尾的 null 字符的位置。

因此，如果你在 VS2019 的 32 位环境下创建一个 basic_string 对象，它的大小可能是 28 个字节。其中，16 个字节用于存储 buf 数组，4 个字节用于存储指向 buf 数组的指针，4 个字节用于存储 size_，4 个字节用于存储 capacity_。但需要注意的是，这个大小可能因为编译器版本、编译器选项等因素而有所不同。

四、 浅拷贝缺陷的解决方案

下面我们再来回顾一下浅拷贝：

C++中浅拷贝是指当对象被复制时，只复制指向数据的指针，而不是数据本身。这意味着当一个对象的内容发生更改时，所有指向该对象的指针都会受到影响，从而导致潜在的内存泄漏和程序错误，例如对象的生命周期结束时，多次调用析构函数。

4.0 浅拷贝改深拷贝

浅拷贝的缺陷示例：

class MyClass {
public:MyClass(int size) {m_data = new int[size];m_size = size;}~MyClass() {delete[] m_data;}
private:int* m_data;int m_size;
};MyClass obj1(10);
MyClass obj2 = obj1;

在这个例子中，当obj2被复制为obj1时，m_data指针也被复制，这意味着两个对象都指向相同的内存地址。如果一个对象更改了其内部数据，另一个对象也会受到影响。

要解决这个问题，可以使用深拷贝来复制对象。深拷贝不仅复制指针，而且复制指针所指向的数据本身，因此每个对象都有其自己的内存空间。

以下是深拷贝的示例实现：

class MyClass {
public:MyClass(int size) {m_data = new int[size];m_size = size;}~MyClass() {delete[] m_data;}// 拷贝构造函数MyClass(const MyClass& other) {m_size = other.m_size;m_data = new int[m_size];memcpy(m_data, other.m_data, m_size * sizeof(int));}// 赋值操作符MyClass& operator=(const MyClass& other) {if (this != &other) {delete[] m_data;m_size = other.m_size;m_data = new int[m_size];memcpy(m_data, other.m_data, m_size * sizeof(int));}return *this;}
private:int* m_data;int m_size;
};MyClass obj1(10);
MyClass obj2 = obj1; // 使用拷贝构造函数进行深拷贝
MyClass obj3(5);
obj3 = obj1; // 使用赋值操作符进行深拷贝

4.1 引用计数

引用计数是一种内存管理技术，它通过跟踪对象被引用的次数来决定何时释放内存。当对象被创建时，引用计数被初始化为1。每当对象被复制时，引用计数也会增加1。当对象不再被使用时，引用计数会减少1。当引用计数为0时，内存被释放。

class MyClass {
public:MyClass(int size) {m_data = new int[size];m_size = size;m_refCount = new int(1);}~MyClass() {if (--(*m_refCount) == 0) {delete[] m_data;delete m_refCount;}}// 拷贝构造函数MyClass(const MyClass& other) {m_data = other.m_data;m_size = other.m_size;m_refCount = other.m_refCount;++(*m_refCount);}// 赋值操作符MyClass& operator=(const MyClass& other) {if (this != &other) {if (--(*m_refCount) == 0) {delete[] m_data;delete m_refCount;}m_data = other.m_data;m_size = other.m_size;m_refCount = other.m_refCount;++(*m_refCount);}return *this;}
private:int* m_data;int m_size;int* m_refCount;
};MyClass obj1(10);
MyClass obj2 = obj1;
MyClass obj3(5);
obj3 = obj1;

在这个例子中，引用计数被实现为一个指向整数的指针，它被存储在对象中。每当对象被复制时，引用计数都会增加1。当对象不再被使用时，引用计数会减少1。当引用计数为0时，内存被释放。这种方法可以避免浅拷贝的问题，并且在对象被复制时不需要进行大量的数据复制。但是，引用计数需要额外的内存空间来存储计数器，而且在多线程环境下，需要进行额外的同步和保护。

引用计数指针不能直接写成int类型，因为这样会导致内存管理出现问题。

如果我们将引用计数实现为一个普通的int类型，那么当对象被复制时，每个副本都将拥有一个独立的引用计数。这意味着，如果其中一个副本被销毁，它的引用计数会减少，但是其它副本的引用计数并不会减少，这会导致内存泄漏。

使用一个指向int的指针可以解决这个问题。每个副本都可以共享同一个引用计数，这样当其中一个副本被销毁时，它的引用计数会减少，而其它副本的引用计数也会随之减少，从而避免了内存泄漏的问题。

4.2 写时拷贝

写时拷贝（Copy on Write，简称COW）是一种内存管理技术，它允许多个对象共享同一块内存，在对象被修改时才进行复制，从而减少内存的消耗。

在COW中，当一个对象被拷贝时，只有指向原始对象的引用被复制，而不是整个对象。在拷贝对象被修改时，COW会将原始对象复制到一个新的内存地址，并且将引用指向新的内存地址。这个过程是透明的，使用者无需关心内部实现。

COW实现：

#include <iostream>
#include <string.h>class MyString {
public:MyString(const char* str) {m_data = new char[strlen(str) + 1];strcpy(m_data, str);m_refCount = new int(1);}~MyString() {if (--(*m_refCount) == 0) {delete[] m_data;delete m_refCount;}}// 拷贝构造函数MyString(const MyString& other) {m_data = other.m_data;m_refCount = other.m_refCount;++(*m_refCount);}// 赋值操作符MyString& operator=(const MyString& other) {if (this != &other) {if (--(*m_refCount) == 0) {delete[] m_data;delete m_refCount;}m_data = other.m_data;m_refCount = other.m_refCount;++(*m_refCount);}return *this;}// 修改字符串时进行复制void ModifyString() {if (*m_refCount > 1) {char* newData = new char[strlen(m_data) + 1];strcpy(newData, m_data);--(*m_refCount);m_data = newData;m_refCount = new int(1);}}
private:char* m_data;int* m_refCount;
};int main() {MyString str1("hello");MyString str2 = str1;std::cout << "str1: " << str1 << std::endl;std::cout << "str2: " << str2 << std::endl;str2.ModifyString();std::cout << "str1: " << str1 << std::endl;std::cout << "str2: " << str2 << std::endl;return 0;
}

在这个例子中，MyString类中的m_data指向一个包含字符串的内存块，m_refCount存储引用计数。在拷贝对象时，只有指向m_data的指针被复制，m_refCount也被增加。当对象被修改时，如果引用计数大于1，则表示有多个对象共享同一块内存，此时MyString类会将原始数据复制到一个新的内存地址，并将指针指向新的内存地址。这个过程是透明的，使用者无需关心内部实现。

在上述示例代码中，ModifyString()函数模拟了对字符串进行修改的操作，如果对象被多个引用共享，则会将数据复制到一个新的内存地址，并将引用指向新的内存地址。这样，其他对象的数据不会被修改，也就避免了浅拷贝带来的问题。

COW技术的缺点是它会增加额外的开销，因为每次修改对象时，都需要检查引用计数并复制数据。因此，COW适用于多读少写的场景，在写操作比较频繁的场景中可能会带来性能问题。