【C++】-- STL之String模拟实现（三）

1.  istream& operator>>(istream& in, string& s)
2.  {
3.    s.clear();
4.    char ch;
5.    ch = in.get();
6.    while (ch != ' ' && ch != '\0')
7.    {
8.      s += ch;
9.      ch = in.get();
10.     }
11.     return in;
12.   }

1. #pragma  once  
2. #define  _CRT_SECURE_NO_WARNINGS
3. #include<iostream>
4. #include<assert.h>
5. #include<stdlib.h>
6. 
7. using namespace std;
8. //定义一个新的命名空间，和全局命名空间隔离开
9. namespace delia
10. {
11.   class string
12.   {
13.   public:
14. 
15.     typedef char* iterator;
16. 
17.     //迭代器
18.     iterator begin()
19.     {
20.       return _str;
21.     }
22. 
23.     //迭代器
24.     iterator end()
25.     {
26.       return _str + _size;
27.     }
28. 
29.     //const迭代器
30.     iterator begin() const 
31.     {
32.       return _str;
33.     }
34. 
35.     //const迭代器
36.     iterator end() const
37.     {
38.       return _str + _size;
39.     }
40. 
41.     //构造函数
42.     string(const char* str = "")
43.     {
44.       _str = new char[strlen(str) + 1];//1是留给'/0'的，_size最大为申请字节数-1，_capacity也为申请字节数-1
45.       strcpy(_str, str);
46. 
47.       _size = strlen(str);
48.       _capacity = _size;
49.     }
50. 
51.     //现代拷贝构造
52.     string(const string& s)
53.       :_str(nullptr)
54.       , _size(0)
55.       , _capacity(0)
56.     {
57.       string tmp(s._str);
58.       swap(tmp);
59.     }
60. 
61.     //赋值运算符重载
62.     string& operator=(string s)
63.     {
64.       swap(s);
65.       return *this;
66.     }
67. 
68.     //析构函数
69.     ~string()
70.     {
71.       delete[] _str;
72.       _str = nullptr;
73.       _size = 0;
74.       _capacity = 0;
75.     }
76. 
77.     //实现交换函数
78.     void swap(string& s)
79.     {
80.       ::swap(_str, s._str);//用::指定调用全局的swap函数即库里的swap函数
81.       ::swap(_size, s._size);
82.       ::swap(_capacity, s._capacity);
83.     }
84. 
85.     //const string对象遍历，只读
86.     char& operator[](size_t i)  const//char要加&，如果不加，那么return就是传值返回，返回的是_str[i]的拷贝，临时对象，而临时对象具有常性，不能被修改，只能读
87.                      //如果要对_str进行修改的话，char要加&，用传引用返回
88.     {
89.       assert(i < _size);
90.       return _str[i];
91.     }
92. 
93.     //非const string对象遍历，可读可写
94.     char& operator[](size_t i)
95.     {
96.       assert(i < _size);
97.       return _str[i];
98.     }
99. 
100.    //求string对象大小
101.    size_t size() const
102.    {
103.      return strlen(_str);
104.    }
105. 
106.    //获取c形式字符串，将 const string* 类型 转化为 const char* 类型
107.    const char* c_str()
108.    {
109.      return _str;
110.    }
111. 
112.    //开空间，扩展_capacity，_size不变
113.    void reserve(size_t n)
114.    {
115.      //1.申请新空间
116.      //2.拷贝字符串
117.      //3.释放旧空间
118.      //4.指向新空间
119.      //5.更新容量
120.      if (n > _capacity)
121.      {
122.        char* tmp = new char[n + 1];//1.申请新空间，多开的那一个空间，存放\0
123.        strncpy(tmp, _str, _size + 1);//2.将字符串包含\0在内都拷贝到新空间
124.        delete[] _str;//3.释放旧空间
125. 
126.        _str = tmp;//4.指向新空间
127.        _capacity = n;//5.更新容量
128.      }
129.    }
130. 
131.    //开空间+初始化，扩展_capacity，_size也要修改
132.    void resize(size_t n, char val = '\0')//如果没有显式给出val，val为\0
133.    {
134.      //1.当n<_size，无需增容
135.      if (n < _size)
136.      {
137.        _size = n;//直接更新_size
138.        _str[_size] = '\0';//将_size位置置为\0
139.      }
140.      //2.当n>_size，分两种情况
141.      //（1）_size < n <_capacity，无需增容，直接将_size到n位置置为val
142.      //（2）n >_capacity，需增容，并将_size到n位置置为val
143.      //这两种情况只有是否增容的区别，其他没有区别
144.      else
145.      {
146.        if (n > _capacity)
147.        {
148.          reserve(n);
149.        }
150. 
151.        for (size_t i = _size; i < n; i++)
152.        {
153.          _str[i] = val;
154.        }
155. 
156.        _str[n] = '\0';//将n的位置置\0
157.        _size = n;//更新_size
158.      }
159.    }
160. 
161.    //尾插一个字符
162.    void push_back(char ch)
163.    {
164.      //字符个数已经达到容量时，重新开空间
165.      if (_size == _capacity)
166.      {
167.        reserve(_capacity == 0 ? 4 : _capacity * 2);//如果是第一次开空间，就开4个字节，如果不是第一次开空间，就开成原来的2倍容量
168.      }
169. 
170.      _str[_size] = ch;//将字符ch缀到字符串末尾
171.      _str[_size + 1] = '\0';//字符ch后面加\0，表明字符串结束
172.      _size++;//字符串大小+1
173.    }
174. 
175.    //追加字符串
176.    void append(const char* str)
177.    {
178.      size_t len = _size + strlen(str);//函数执行完毕后字符串的大小
179. 
180.      if (len > _capacity)
181.      {
182.        reserve(len);//空间不够，增容
183.      }
184. 
185.      strcpy(_str + _size, str);//将str内容拷贝至_str末尾
186.      _size = len;//更新_size
187.    }
188. 
189.    //+= 1个字符
190.    string& operator+= (char c)
191.    {
192.      push_back(c);//尾插字符
193.      return *this;
194.    }
195. 
196.    //+= 字符串
197.    string& operator+= (const char* str)
198.    {
199.      append(str);//拼接字符串
200.      return *this;
201.    }
202. 
203.    //insert插入一个字符
204.    string& insert(size_t pos, const char ch)
205.    {
206.      assert(pos <= _size);//pos必须小于等于字符串长度
207. 
208.      if (_size == _capacity)
209.      {
210.        reserve(2 * _capacity);//如果满了就增容
211.      }
212. 
213.      size_t end = _size + 1;
214.      while (end > pos)//将pos至_size之间的字符依次向后挪动一个位置，来腾出pos位置
215.      {
216.        _str[end] = _str[end - 1];
217.        end--;//end为0时，因此end类型应为int，那么end--就为-1，pos为无符号数，不满足循环条件，退出循环
218.            //但如果end类型为size_t，那么end为0时，end--就为-1，在内存中存储为无符号数(-1补码全1)，满足循环条件，永远无法退出循环
219.      }
220. 
221.      _str[pos] = ch;//pos位置插入ch
222.      _size++;//更新_size
223. 
224.      return *this;
225.    }
226. 
227.    //erase 删除字符
228.    string& erase(size_t pos, size_t len = npos)
229.    {
230.      assert(pos < _size);
231. 
232.      size_t leftLen = _size - pos;//从pos位置到字符串结束的字符长度
233.      if (leftLen < len)//1.pos之后的字符全部删掉
234.      {
235.        _str[pos] = '\0';
236.        _size = pos;
237.      }
238.      else//2.pos之后的字符删掉一部分，没删完的部分要挪到pos位置
239.      {
240.        strcpy(_str + pos, _str + pos + len);
241.        _size -= len;
242.      }
243.      return *this;
244.    }
245. 
246.    //查找字符
247.    size_t find(char ch, size_t pos = 0)
248.    {
249.      assert(pos < _size);
250.      for (size_t i = 0; i < _size; i++)
251.      {
252.        if (_str[i] == ch)
253.        {
254.          return i;//找到就返回字符所在位置
255.        }
256.      }
257.      return npos;//没找到就返回-1
258.    }
259. 
260.    //查找字符串(子串)
261.    size_t find(const char* str, size_t pos = 0)
262.    {
263.      assert(pos < _size);
264.      const char* ret  = strstr(_str + pos, str);
265. 
266.      if (ret)
267.      {
268.        return ret - _str;//计算str与_str的偏移量，即str在_str中的下标
269.      }
270.      else
271.      {
272.        return npos;//没找到就返回-1
273.      }
274.    }
275. 
276. 
277.    //字符串比较，只需要实现>和==
278.    bool operator>(const string& s)
279.    {
280.      return strcmp(_str, s._str) < 0;
281.    }
282. 
283.    bool operator==(const string& s)
284.    {
285.      return strcmp(_str, s._str) == 0;
286.    }
287. 
288.    // 其它4个运算符都可以对>和==这两个运算符进行重载
289.    bool operator>=(const string& s)
290.    {
291.      return (*this > s) || (*this == s);
292.    }
293. 
294.    bool operator<(const string& s)
295.    {
296.      return !(*this >= s);
297.    }
298. 
299.    bool operator<=(const string& s)
300.    {
301.      return !(*this > s);
302.    }
303. 
304.    bool operator!=(const string& s)
305.    {
306.      return !(*this == s);
307.    }
308. 
309.    void clear()
310.    {
311.      _size = 0;
312.      _str[0] = '\0';
313.    }
314. 
315.  private:
316.    char* _str;
317.    size_t _size;
318.    size_t _capacity;
319. 
320.    static const size_t npos;
321.  };
322. 
323.  const size_t string::npos = -1;//npos初始化
324. 
325.  //输出重载<<让string直接输出打印，像内置类型一样，用范围for就可以实现
326.  ostream& operator<<(ostream& out, const string& s)
327.  {
328.    for (auto ch: s)
329.    {
330.      out << s;
331.    }
332.    return out;
333.  }
334. 
335.  //输入重载>>让string直接输入，像内置类型一样；从标准输入流读取字符，遇到' '或'\0'就停止
336.  istream& operator>>(istream& in, string& s)
337.  {
338.    s.clear();
339.    char ch;
340.    ch = in.get();
341.    while (ch != ' ' && ch != '\0')
342.    {
343.      s += ch;
344.      ch = in.get();
345.    }
346.    return in;
347.  }
348. 
349.  void f(const string& s)
350.  {
351.    for (size_t i = 0; i < s.size(); i++)
352.    {
353.      cout << s[i] << " ";
354.    }
355.    cout << endl;
356.  }
357. 
358.  void test_string1()
359.  {
360.    string s1("hello world");
361.    string s2(s1);
362. 
363.    string s3("cplusplus.com");
364.    std::swap(s1, s3);//调用库里的swap函数，3次深拷贝，再把原来的空间释放掉，再开一样大的空间，代价大
365.    s1.swap(s3);//调用delia::string类里面的成员函数swap，仅仅只是成员变量的交换，s3指向了s1的空间，s1指向了s3的空间
366. 
367.    string s4 = s1.c_str();
368.    s1[2] = 'w';
369.    f(s1);//h e w l o   w o r l d
370. 
371.    for (size_t i = 0; i < s1.size(); i++)
372.    {
373.      cout << s1[i] << " ";
374.    }
375.    cout << endl;//h e w l o   w o r l d
376.  }
377. 
378.  void test_string2()
379.  {
380.    string s1("hello world");
381. 
382.    //使用迭代器遍历
383.    string::iterator it = s1.begin();
384.    while (it != s1.end())
385.    {
386.      cout << *it << " ";
387.      it++;
388.    }
389.    cout << endl;//h e l l o   w o r l d
390. 
391.    //使用范围for遍历,范围for会被编译器替换成迭代器形式,如果把17-26行屏蔽，会发现编译不过
392.    for (auto ch : s1)
393.    {
394.      cout << *it << " ";
395.    }
396.    cout << endl;//h e l l o   w o r l d
397.  }
398. 
399.  void test_string3()
400.  {
401.    string s1("hello world");
402.    s1 += "abc";
403.    for (auto& ch : s1)
404.    {
405.      cout << ch << " ";
406.    }
407.    cout << endl;//h e l l o   w o r l d a b c
408. 
409.    s1 += "xyz";
410.    for (auto& ch : s1)
411.    {
412.      cout << ch << " ";
413.    }
414.    cout << endl;//h e l l o   w o r l d a b c x y z
415.  }
416. 
417.  void test_string4()
418.  {
419.    string s1("hello world");
420.    s1 += '#';
421.    for (auto ch : s1)
422.    {
423.      cout << ch << " ";
424.    }
425.    cout << endl;//hello world#
426. 
427.    s1 += "xyz";
428.    for (auto ch : s1)
429.    {
430.      cout << ch << " ";
431.    }
432.    cout << endl;//hello world#xyz
433. 
434.    s1 += "!!!!!!!!!!!!!!!!!!!!";
435.    for (auto ch : s1)
436.    {
437.      cout << ch << " ";
438.    }
439.    cout << endl;//hello world#xyz!!!!!!!!!!!!!!!!!!!!
440.  }
441. 
442.  void test_string5()
443.  {
444.    string s1("hello world");
445.    s1.resize(3);
446.    cout << s1.c_str() << endl;//hel
447.  }
448. 
449.  void test_string6()
450.  {
451.    string s1("hello");
452.    s1.resize(6, 'a');
453.    cout << s1.c_str() << endl;//helloa
454.  }
455. 
456.  void test_string7()
457.  {
458.    string s1("hello");
459.    s1.resize(9, 'o');
460.    cout << s1.c_str() << endl;//helloooo
461.  }
462. 
463.  void test_string8()
464.  {
465.    string s1("hello");
466.    s1.insert(0, 'u');
467.    cout << s1.c_str() << endl;//uhello
468.  }
469. 
470.  void test_string9()
471.  {
472.    string s1("hello");
473.    s1.erase(0, 2);
474.    cout << s1.c_str() << endl;//llo
475. 
476.    string s2("world");
477.    s2.erase(1);//如果不给len，那么npos=-1，无符号数为4294967295，删除从位置为1-4294967295的字符，把后面的字符全部删除了
478.    cout << s2.c_str() << endl;//w
479.  }
480. 
481. 
482.  void test_string10()
483.  {
484.    string s1("hello world");
485.    cout << s1.find("rl",6) << endl;//8,从s1中的第6个位置开始查找"rl"字符串
486.  }
487. 
488.  void test_string11()
489.  {
490.    std::string s("hello");
491.    cin >> s;
492.    cout << s << endl;
493.  }
494. }
495. 
496. 
497. int main()
498. {
499.  //delia::test_string1();
500.  //delia::test_string2();
501.  //delia::test_string3();
502.  //delia::test_string4();
503.  //delia::test_string5();
504.  //delia::test_string6();
505.  //delia::test_string7();
506.  //delia::test_string8();
507.  //delia::test_string9();
508.  //delia::test_string10();
509.  delia::test_string11();
510.  return 0;
511. }

1. class Solution {
2. public:
3.     string replaceSpace(string s) {
4. 
5.         //1.计算空格数
6.         size_t spaceCount = 0;
7.         for(auto ch:s)
8.         {
9.             if(ch == ' ')
10.             {
11.                 spaceCount++;
12.             }
13.         }
14.       
15.         //2.声明新串
16.         string ret;
17. 
18.         //3.为新串分配空间：从空格变为%20,长度增加2
19.         ret.reserve(s.size()+2*spaceCount);
20. 
21.         //4.将空格替换为%20
22.         for(auto ch:s)
23.         {
24.             if(ch != ' ')
25.             {
26.                 ret += ch;
27.             }
28.             else
29.             {
30.                 ret += "%20";
31.             }
32.         }
33. 
34.         return ret;
35.     }
36. };