【C++】string类的底层

目录
1.经典的string类问题
2 .浅拷贝 
3.深拷贝
​编辑 3.1 传统版写法的String类
3.2 现代版写法的String类
4.string类模拟实现代码参考
5.写时拷贝

---

1.经典的string类问题

上一篇博客已经对string类进行了简朴的先容，各人只要可以或许正常使用即可。在面试中，面试官总喜好让门生自己来模拟实现string类，最告急是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。各人看下以下string类的实现是否有问题？

1. // 为了和标准库区分，此处使用String
2. class String
3. {
4. public:
5.         /*String()
6.         :_str(new char[1])
7.         {*_str = '\0';}
8.         */
9.         //String(const char* str = "\0") 错误示范
10.         //String(const char* str = nullptr) 错误示范
11.         String(const char* str = "")
12.         {
13.                 // 构造String类对象时，如果传递nullptr指针，可以认为程序非
14.                 if (nullptr == str)
15.                 {
16.                         assert(false);
17.                         return;
18.                 }
19.                 _str = new char[strlen(str) + 1];
20.                 strcpy(_str, str);
21.         }
22.         ~String()
23.         {
24.                 if (_str)
25.                 {
26.                         delete[] _str;
27.                         _str = nullptr;
28.                 }
29.         }
30. private:
31.         char* _str;
32. };
33. // 测试
34. void TestString()
35. {
36.         String s1("hello bit!!!");
37.         String s2(s1);
38. }

复制代码

 

   说明：上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认
的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序瓦解，这种拷贝方式，称为浅拷贝。
  2 .浅拷贝 

   浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，末了就会导致
多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该
资源已经被释放，以为另有用，所以当继承对资源进项操纵时，就会发生发生了访问违规。
  
就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一
不想分享就你争我夺，玩具损坏。 
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父
母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。
3.深拷贝

   
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。 
  

 3.1 传统版写法的String类

1. class String
2. {
3. public:
4.         String(const char* str = "")
5.         {
6.                 // 构造String类对象时，如果传递nullptr指针，可以认为程序非
7.                 if (nullptr == str)
8.                 {
9.                         assert(false);
10.                         return;
11.                 }
12.                 _str = new char[strlen(str) + 1];
13.                 strcpy(_str, str);
14.         }
15.         String(const String& s)
16.                 : _str(new char[strlen(s._str) + 1])
17.         {
18.                 strcpy(_str, s._str);
19.         }
20.         String& operator=(const String& s)
21.         {
22.                 if (this != &s)
23.                 {
24.                         char* pStr = new char[strlen(s._str) + 1];
25.                         strcpy(pStr, s._str);
26.                         delete[] _str;
27.                         _str = pStr;
28.                 }
29.                 return *this;
30.         }
31.         ~String()
32.         {
33.                 if (_str)
34.                 {
35.                         delete[] _str;
36.                         _str = nullptr;
37.                 }
38.         }
39. private:
40.         char* _str;
41. };

复制代码

3.2 现代版写法的String类

1. class String
2. {
3. public:
4.         String(const char* str = "")
5.         {
6.                 if (nullptr == str)
7.                 {
8.                         assert(false);
9.                         return;
10.                 }
11.                 _str = new char[strlen(str) + 1];
12.                 strcpy(_str, str);
13.         }
14.         String(const String& s)
15.                 : _str(nullptr)
16.         {
17.                 String strTmp(s._str);
18.                 swap(_str, strTmp._str);
19.         }
20.         // 对比下和上面的赋值那个实现比较好？
21.         String& operator=(String s)
22.         {
23.                 swap(_str, s._str);
24.                 return *this;
25.         }
26.         /*
27.         String& operator=(const String& s)
28.         {
29.         if(this != &s)
30.         {
31.         String strTmp(s);
32.         swap(_str, strTmp._str);
33.         }
34.         return *this;
35.         }
36.         */
37.         ~String()
38.         {
39.                 if (_str)
40.                 {
41.                         delete[] _str;
42.                         _str = nullptr;
43.                 }
44.         }
45. private:
46.         char* _str;
47. };

复制代码

4.string类模拟实现代码参考

string.h

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #pragma once
3. #include<iostream>
4. #include<cstring>
5. #include<assert.h>
6. using namespace std;
8. namespace LCL
9. {
10.         class string
11.         {
12.         public:
13.                 friend         ostream& operator<<(ostream& os, const string& s);
14.                 friend istream& operator>>(istream& is, string& s);
15.                 friend istream& getline(istream& is, string& s, char delim);
17.                 using iterator = char*;
18.                 using const_iterator = const char*;
20.                 string(const char* str = "");//这里不能给空
22.                 string(const string& s);
23.                 string& operator=(const string& s);
25.                 ~string();
27.                 char& operator[](size_t i)
28.                 {
29.                         assert(i < _size);
31.                         return _str[i];
32.                 }
34.                 const char& operator[](size_t i) const
35.                 {
36.                         assert(i < _size);
38.                         return _str[i];
39.                 }
42.                 size_t size() const
43.                 {
44.                         return _size;
45.                 }
47.                 const char* c_str() const
48.                 {
49.                         return _str;
50.                 }
52.                 iterator begin()
53.                 {
54.                         return _str;
55.                 }
57.                 iterator end()
58.                 {
59.                         return _str + _size;
60.                 }
62.                 const_iterator begin() const
63.                 {
64.                         return _str;
65.                 }
67.                 const_iterator end() const
68.                 {
69.                         return _str + _size;
70.                 }
72.                 void clear()
73.                 {
74.                         _str[0] = '\0';
75.                         _size = 0;
76.                 }
78.                 void reserve(size_t n);//开空间
79.                 void push_back(char ch);
80.                 void append(const char* str);
81.                 string& operator+=(char ch);
82.                 string& operator+=(const char* str);
84.                 void insert(size_t pos, char ch);
85.                 void insert(size_t pos, const char* str);
86.                 void erase(size_t pos, size_t len=npos);
88.                 size_t find(char ch, size_t pos = 0);
89.                 size_t find(const char* str, size_t pos = 0);
91.                 string substr(size_t pos, size_t len = npos);
92.                
93.                 void swap(string& s);
97.         private:
98.                 char* _str;
99.                 size_t _size;
100.                 size_t _capacity;
102.         public:
103.                 //特殊处理 只有整形才可以
104.          /*  static const size_t npos = -1;*/
106.            static const size_t npos;
107.         };
109.         bool operator==(const string& lhs, const string& rhs);
110.         bool operator!=(const string& lhs, const string& rhs);
111.         bool operator>(const string& lhs, const string& rhs);
112.         bool operator<(const string& lhs, const string& rhs);
113.         bool operator<=(const string& lhs, const string& rhs);
114.         bool operator>=(const string& lhs, const string& rhs);
116.         ostream& operator<<(ostream& os, const string& s);
117.         istream& operator>>(istream& is, string& s);
118.         istream& getline(istream& is, string& s, char delim = '\n');
119. }

复制代码

string.c 

1. #include"string.h"
3. namespace LCL
4. {       
5.         const size_t string::npos = -1;
6.         string::string(const char* str)
7.                 :_size(strlen(str))
8.         {
9.                 _capacity = _size;
10.                 _str = new char[_size + 1];
11.                 strcpy(_str, str);
12.         }
14.         //s2(s1)
15.         //传统写法
16.         //string::string(const string& s)
17.         //{
18.         //        _str = new char[s._capacity+1];
19.         //        strcpy(_str, s._str);
20.         //        _size = s._size;
21.         //        _capacity = s._capacity;
22.         //}
24.         string::string(const string& s)
25.         {
26.                 string tmp(s._str);
27.                 swap(tmp);
28.         }
30.         string& string::operator=(const string& s)
31.         {
32.                 if (this != &s)
33.                 {
34.                         delete[] _str;
35.                         _str = new char[s._capacity + 1];
36.                         strcpy(_str, s._str);
37.                         _size = s._size;
38.                         _capacity = s._capacity;
39.                 }
41.                 return *this;//为了连续赋值必须返回自身的引用
43.         }
45.         string::~string()
46.         {
47.                 delete[] _str;
48.                 _str = nullptr;
49.                 _size = _capacity = 0;
50.         }
52.         void string::reserve(size_t n)
53.         {
54.                 if (n > _capacity)
55.                 {
56.                         char* newstr = new char[n+1];//开空间永远要多开一个给'\0'留位置
57.                         //把原来的数据拷过来
58.                         strcpy(newstr, _str);
59.                         delete[] _str;
60.                         _str = newstr;
62.                         _capacity = n;
63.                 }
65.         }
67.         void string::push_back(char ch)
68.         {
69.                 if (_size == _capacity)
70.                 {
71.                         //扩容
72.                         reserve(_capacity == 0 ? 4 : 2 * _capacity);
73.                 }
74.                 _str[_size] = ch;//插入
75.                 _size++;
76.                 _str[_size] = '\0';//防止溢出
77.         }
78.         void string::append(const char* str)
79.         {
80.                 size_t len = strlen(str);
81.                 if (_size + len > _capacity)
82.                 {
83.                         //扩容
84.                         size_t newcapacity = 2 * _capacity;
85.                         //扩2倍不够,需要多少阔多少
86.                         if (newcapacity < len+_size)
87.                         {
88.                                 newcapacity = len + _size;
89.                         }
90.                         reserve(newcapacity);
91.                 }
92.                 //插入
93.                 strcpy(_str+_size, str);
94.                 _size += len;
95.         }
96.         string& string::operator+=(char ch)
97.         {
98.                 push_back(ch);
99.                 return *this;
100.         }
101.         string& string::operator+=(const char* str)
102.         {
103.                 append(str);
104.                 return *this;
105.         }
108.         void string::insert(size_t pos, char ch)
109.         {
110.                 assert(pos <= _size);
111.                 if (_size == _capacity)
112.                 {
113.                         //扩容
114.                         reserve(_capacity == 0 ? 4 : 2 * _capacity);
115.                 }
116.                 //挪动pos后面的元素
117.                 int end = _size;
118.                 while (end >= (int)pos)
119.                 {
120.                         _str[end + 1] = _str[end];
121.                         end--;
122.                 }
123.                 _str[pos] = ch;//插入
124.                 _size++;//更新_size
125.         }
126.         void string::insert(size_t pos, const char* str)
127.         {
128.                 assert(pos <= _size);
129.                 size_t len = strlen(str);
130.                 if (_size + len > _capacity)
131.                 {
132.                         //扩容
133.                         size_t newcapacity = 2 * _capacity;
134.                         //扩2倍不够,需要多少阔多少
135.                         if (newcapacity < len + _size)
136.                         {
137.                                 newcapacity = len + _size;
138.                         }
139.                         reserve(newcapacity);
140.                 }
142.                 size_t end = _size + len;
143.                 while (end > pos+len-1)
144.                 {
145.                         _str[end] = _str[end - len];
146.                         end--;
147.                 }
148.                 for (size_t i = 0; i < len; i++)
149.                 {
150.                         _str[pos + i] = str[i];
151.                 }
152.                 _size += len;
153.         }
154.         void string::erase(size_t pos, size_t len)
155.         {
156.                 assert(pos < _size);
157.                 if (len >= _size - pos)
158.                 {
159.                         _str[pos] = '\0';
160.                         _size = pos;
161.                 }
162.                 else
163.                 {
164.                         size_t end = pos + len;
165.                         while (end<=_size)
166.                         {
167.                                 _str[end - len] = _str[end];
168.                                 end++;
169.                         }
171.                         _size -= len;
172.                 }
173.         }
175.         size_t string::find(char ch, size_t pos)
176.         {
177.                 assert(pos < _size);
179.                 for (size_t i = pos; i < _size; i++)
180.                 {
181.                         if (ch == _str[i])
182.                                 return i;
183.                 }
185.                 return npos;
186.         }
189.         size_t string::find(const char* str, size_t pos)
190.         {
191.                 assert(pos<_size);
192.                 const char* ptr = strstr(_str + pos, str);
193.                 if (ptr == nullptr)
194.                 {
195.                         return npos;
196.                 }
197.                 else
198.                 {
199.                         return ptr - _str;
200.                 }
202.         }
205.         string string::substr(size_t pos, size_t len)
206.         {
207.                 assert(pos < _size);
208.                 if (len > (_size - pos))
209.                 {
210.                         len = _size - pos;
211.                 }
212.                 string str;
213.                 reserve(len);
214.                 for (size_t i = 0; i < len; i++)
215.                 {
216.                         str += _str[pos + i];
217.                 }
219.                 return str;
220.         }
222.         bool operator==(const string& lhs, const string& rhs)
223.         {
224.                 return strcmp(lhs.c_str(), rhs.c_str()) == 0;
225.         }
227.         bool operator!=(const string& lhs, const string& rhs)
228.         {
229.                 return !(lhs == rhs);
230.         }
231.         bool operator>(const string& lhs, const string& rhs)
232.         {
233.                 return !(lhs <= rhs);
234.         }
235.         bool operator<(const string& lhs, const string& rhs)
236.         {
237.                 return strcmp(lhs.c_str(), rhs.c_str()) < 0;
238.         }
239.         bool operator<=(const string& lhs, const string& rhs)
240.         {
241.                 return lhs < rhs || lhs == rhs;
242.         }
243.         bool operator>=(const string& lhs, const string& rhs)
244.         {
245.                 return !(lhs < rhs);
246.         }
248.         ostream& operator<<(ostream& os, const string& s)
249.         {
250.                 for(size_t i = 0; i < s.size(); i++)
251.                 {
252.                         os << s[i];
253.                 }
256.                 return os;
257.         }
258.         istream& operator>>(istream& is, string& s)
259.         {
260.                 s.clear();
261.                 int i = 0;
262.                 char buffer[256];
264.                 char ch;
265.                 ch = is.get();
266.                 while (ch != ' ' && ch != '\n')
267.                 {
268.                         buffer[i++] = ch;
269.                         if (i == 255)
270.                         {
271.                                 buffer[i] = '\0';
272.                                 s += buffer;
273.                                 i = 0;
274.                         }
275.                         ch = is.get();
276.                 }
278.                 if (i > 0)
279.                 {
280.                         buffer[i] = '\0';
281.                         s += buffer;
282.                 }
285.                 return is;
286.         }
289.         istream& getline(istream& is, string& s, char delim)
290.         {
291.                 s.clear();
292.                 int i = 0;
293.                 char buffer[256];
295.                 char ch;
296.                 ch = is.get();
297.                 while (ch != delim)
298.                 {
299.                         buffer[i++] = ch;
300.                         if (i == 255)
301.                         {
302.                                 buffer[i] = '\0';
303.                                 s += buffer;
304.                                 i = 0;
305.                         }
306.                         ch = is.get();
307.                 }
309.                 if (i > 0)
310.                 {
311.                         buffer[i] = '\0';
312.                         s += buffer;
313.                 }
316.                 return is;
317.         }
319.         void string::swap(string& s)
320.         {
321.                 std::swap(_str, s._str);
322.                 std::swap(_size, s._size );
323.                 std::swap(_capacity, s._capacity);
324.         }
325. }

复制代码

测试：test.c

1. #include"string.h"
3. void testString01()
4. {
5.         LCL::string s1("hello world");
6.         cout << s1.c_str() << endl;
8.         s1 += ' ';
9.         s1 += "hello bit";
11.         cout << s1.c_str() << endl;
14.         LCL::string s2("hello world");
15.         s2.insert(0, 'a');
16.         cout << s2.c_str() << endl;
18.         LCL::string s3("hello world");
19.         cout << s3.c_str() << endl;
20.         s3.insert(0, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
21.         cout << s3.c_str() << endl;
23.         LCL::string s4("hello world");
24.         s4.erase(5);
25.         cout << s4.c_str() << endl;
26. }
28. void testString02()
29. {
30.         LCL::string s5("hello world");
31.         cout << s5.find(' ') << endl;
32.         cout << s5.find("world") << endl;
34.         LCL::string s6 = "https://legacy.cplusplus.com/reference/string/string/?kw=string";
35.         size_t pos1 = s6.find(':');
36.         size_t pos2=s6.find('/', pos1 + 3);
38.         if (pos1 != string::npos && pos2 != string::npos)
39.         {
40.                 LCL::string domain = s6.substr(pos1 + 3, pos2 - (pos1 + 3));
41.                 cout << domain.c_str() << endl;
42.         }
43. }
45. void testString03()
46. {
47.         LCL::string s1("hello world");
48.         LCL::string s2(s1);
49.         cout << s2.c_str() << endl;       
51.         cout << (s1 == s2) << endl;
52.         cout << (s1 < s2) << endl;
53.         cout << ("hello world" == s1) << endl;
54. }
56. void testString04()
57. {
58.         //LCL::string s1="hhhhh";
59.         //cin >> s1;
60.         //cout << s1 << endl;
62.         LCL::string s2;
63.         getline(cin, s2,'#');
64.         cout << s2 << endl;
65.        
67. }
69. void testString05()
70. {
71.         LCL::string s1 = "llllll";
72.         LCL::string s2 = "ccccccc";
73.        
74.         s1.swap(s2);
75.         cout << s1 << endl;
76.         cout << s2 << endl;
77. }
81. int main()
82. {
83.         //LCL::string s1("1111");
84.         //cout << s1.c_str() << endl;
86.         //LCL::string s2;
87.         //cout << s2.c_str() << endl;
90.         //LCL::string s3("1234");
91.         //cout << s3.size() << endl;
92.         //s3[0] = 'x';
93.         //cout << s3.c_str() << endl;
94.         //for (size_t i = 0; i < s3.size(); i++)
95.         //{
96.         //        cout << s3[i] << " ";
97.         //}
98.         //cout << endl;
100.         //LCL::string::iterator it1 = s3.begin();
101.         //while (it1!=s3.end())
102.         //{
103.         //        //*it1 = 'a';
104.         //        cout << *it1 << " ";
105.         //        it1++;
106.         //}
107.         //cout << endl;
108.         范围for
109.         支持迭代器就支持范围for
110.         //for (auto e : s3)
111.         //{
112.         //        cout << e << " ";
113.         //}
114.         //cout << endl;
117.         //const LCL::string s4("lllllll");
118.         //cout << s4.size() << endl;       
119.         //cout << s4[1] << endl;
120.         //LCL::string::const_iterator it2 = s4.begin();
121.         //while (it2!=s4.end())
122.         //{
123.         //        cout << *it2 << " ";
124.         //        it2++;
125.         //}
126.         //cout << endl;
127.         //for (auto a : s4)
128.         //{
129.         //        cout << a << " ";
130.         //}
131.         //cout << endl;
132.         /*LCL::string s2("2");
133.         cout << s2.c_str() << endl;*/
135.         //s2 += '1';
136.         //s2 += "33333";
138.         //cout << s2.c_str() << endl;
140.         //testString01();
141.         //testString02();
142.         //testString03();
143.         //testString04();
144.         testString05();
145.         return 0;
146. }

复制代码

5.写时拷贝

   

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记载资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再查抄是否需要释放资源，如果计数为1，说明该对象时资源的末了一个使用者，将该资源释放；否则就不能释放，因为另有其他对象在使用该资源。

1. #include <iostream>
2. #include <cstring>
3. #include <atomic>
5. class CowString {
6. public:
7.         // 默认构造函数
8.         CowString() : data(nullptr), length(0), ref_count(new std::atomic<int>(1)) {}
10.         // 构造函数，接受C风格字符串
11.         CowString(const char* str) {
12.                 if (str) {
13.                         length = std::strlen(str);
14.                         data = new char[length + 1];
15.                         std::strcpy(data, str);
16.                         ref_count = new std::atomic<int>(1);
17.                 }
18.                 else {
19.                         data = nullptr;
20.                         length = 0;
21.                         ref_count = new std::atomic<int>(1);
22.                 }
23.         }
25.         // 拷贝构造函数
26.         CowString(const CowString& other) : data(other.data), length(other.length), ref_count(other.ref_count) {
27.                 (*ref_count)++; // 增加引用计数
28.         }
30.         // 移动构造函数
31.         CowString(CowString&& other) noexcept : data(other.data), length(other.length), ref_count(other.ref_count) {
32.                 other.data = nullptr;
33.                 other.length = 0;
34.                 other.ref_count = new std::atomic<int>(1); // 重置移动后的对象为独立状态
35.         }
37.         // 析构函数
38.         ~CowString() {
39.                 if (data && --(*ref_count) == 0) { // 当引用计数为零时释放内存
40.                         delete[] data;
41.                         delete ref_count;
42.                 }
43.         }
45.         // 赋值运算符
46.         CowString& operator=(const CowString& other) {
47.                 if (this != &other) { // 防止自我赋值
48.                         CowString temp(other); // 使用拷贝构造函数创建临时对象
49.                         std::swap(data, temp.data);
50.                         std::swap(length, temp.length);
51.                         std::swap(ref_count, temp.ref_count);
52.                 }
53.                 return *this;
54.         }
56.         // 移动赋值运算符
57.         CowString& operator=(CowString&& other) noexcept {
58.                 if (this != &other) {
59.                         delete[] data; // 释放当前数据（如果存在）
60.                         data = other.data;
61.                         length = other.length;
62.                         ref_count = other.ref_count;
64.                         // 重置移动后的对象为独立状态
65.                         other.data = nullptr;
66.                         other.length = 0;
67.                         other.ref_count = new std::atomic<int>(1);
68.                 }
69.                 return *this;
70.         }
72.         // 获取C风格字符串
73.         const char* c_str() const {
74.                 return data;
75.         }
77.         // 获取字符串长度
78.         size_t size() const {
79.                 return length;
80.         }
82.         // ... 其他成员函数（如operator+，substr等）可以按需添加 ...
84. private:
85.         char* data; // 字符数据
86.         size_t length; // 字符串长度
87.         std::atomic<int>* ref_count; // 引用计数（使用原子操作以保证线程安全）
88. };
90. int main() {
91.         CowString str1("Hello, World!");
92.         CowString str2 = str1; // 使用拷贝构造函数
94.         std::cout << "str1: " << str1.c_str() << std::endl;
95.         std::cout << "str2: " << str2.c_str() << std::endl;
97.         // 在这里，str1和str2共享相同的数据
99.         // 修改str1会导致数据拷贝
100.         char* temp = new char[str1.size() + 1];
101.         std::strcpy(temp, str1.c_str());
102.         temp[5] = 'C++'; // 修改拷贝的数据以避免未定义行为（不能直接修改共享数据）
104.         // 注意：下面的操作是错误的，因为它直接修改了共享的数据，这在实际COW实现中是不允许的。
105.         // 为了演示，我们暂时这样做，但在真正的COW实现中，你应该先执行深拷贝再修改。
106.         // data[5] = 'C'; // 错误！这将直接修改str1和str2共享的数据。
108.         // 正确的做法是先深拷贝再修改（这里只是演示，所以跳过深拷贝步骤）
109.         // CowString str1_copy = str1; // 深拷贝
110.         // str1_copy.data[5] = 'C'; // 修改深拷贝后的数据
112.         // 由于我们直接修改了共享数据（上面的错误做法），下面的输出将是不确定的。
113.         // 在真正的COW实现中，你应该避免这种情况。
114.         std::cout << "After incorrect modification: " << std::endl;
115.         std::cout << "str1: " << str1.c_str() << std::endl; // 输出可能是不确定的
116.         std::cout << "str2: " << str2.c_str() << std::endl; // 输出可能是不确定的
118.         // 清理内存（在main函数结束时，所有CowString对象都会被销毁，并释放内存）
119.         delete[] temp;
121.         return 0;
122. }
124. // 注意：上面的代码包含了一个错误示例，即直接修改共享数据。
125. // 在真正的COW实现中，你应该在修改前检查引用计数，并在需要时进行深拷贝。
126. // 此外，上面的代码没有实现完整的COW字符串类，比如缺少对operator+等的支持。
127. // 这个示例仅用于教学目的，展示了COW的基本概念。

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。