string类详解（下）

用户云卷云舒  金牌会员 | 昨天 06:15 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 896|帖子 896|积分 2688

4. string类的模仿实现

首先，我们先补充一下关于编码的知识：
  1. int main()
  2. {
  3.         char buff1[] = "abcd";
  4.         char buff2[] = "比特";
  5.        
  6.         cout << sizeof(buff1) << endl;
  7.         cout << sizeof(buff2) << endl;
  9.         cout << buff1 << endl;
  10.         cout << buff2 << endl;
  12.         return 0;
  13. }
复制代码


假如严格按照标准的话，我们应该要实现成 basic_string ，但是这样难度太大，要思量各种编码的拷贝，以是我们就实现的轻微简单一些，不要实现成模板了。
4.1 构造 + 析构

  1. //string::string()
  2. //{
  3. //        _str = new char[1]{ '\0' };
  4. //        _size = 0;
  5. //        _capacity = 0;
  6. //}
  8. string::string(const char* str)
  9.         :_size(strlen(str))
  10. {
  11.         _str = new char[_size + 1];
  12.         _capacity = _size;
  13.         strcpy(_str, str);
  14. }
  16. //s2(s1)
  17. string::string(const string& s)
  18. {
  19.         _str = new char[s._capacity + 1];
  20.         strcpy(_str, s._str);
  21.         _size = s._size;
  22.         _capacity = s._capacity;
  23. }
  25. string::~string()
  26. {
  27.         delete[] _str;
  28.         _str = nullptr;
  29.         _size = _capacity = 0;
  30. }
复制代码
4.2 c_str

  1. const char* string::c_str() const
  2. {
  3.         return _str;
  4. }
复制代码
4.3 下标遍历

  1. size_t string::size() const
  2. {
  3.         return _size;
  4. }
  6. char& string::operator[](size_t pos)
  7. {
  8.         assert(pos < _size);
  9.         return _str[pos];
  10. }
复制代码
  1. const char& string::operator[](size_t pos) const
  2. {
  3.         assert(pos < _size);
  4.         return _str[pos];
  5. }
复制代码
4.4 迭代器

  1. string::iterator string::begin()
  2. {
  3.         return _str;
  4. }
  6. string::iterator string::end()
  7. {
  8.         return _str + _size;
  9. }
复制代码

  1. string::const_iterator string::begin() const
  2. {
  3.         return _str;
  4. }
  6. string::const_iterator string::end() const
  7. {
  8.         return _str + _size;
  9. }
复制代码
4.5 插入

  1. void string::reserve(size_t n)
  2. {
  3.         if (n > _capacity)
  4.         {
  5.                 char* tmp = new char[n + 1];
  6.                 strcpy(tmp, _str);
  7.                 delete[] _str;
  9.                 _str = tmp;
  10.                 _capacity = n;
  11.         }
  12. }
  14. void string::push_back(char ch)
  15. {
  16.         if (_size == _capacity)
  17.         {
  18.                 size_t newcapacity = 0 == _capacity ? 4 : _capacity * 2;
  19.                 reserve(newcapacity);
  20.         }
  22.         _str[_size] = ch;
  23.         _str[_size + 1] = '\0';
  24.         ++_size;
  25. }
  27. //"hello"  "xxxxxxxxxxxxx"
  28. void string::append(const char* str)
  29. {
  30.         size_t len = strlen(str);
  31.         if (_size + len > _capacity)
  32.         {
  33.                 reserve(_size + len);
  34.         }
  36.         strcpy(_str + _size, str);
  37.         _size += len;
  38. }
  40. string& string::operator+=(char ch)
  41. {
  42.         push_back(ch);
  43.         return *this;
  44. }
  45. string& string::operator+=(const char* str)
  46. {
  47.         append(str);
  48.         return *this;
  49. }
复制代码

  1. void string::insert(size_t pos, char ch)
  2. {
  3.         assert(pos <= _size);
  5.         if (_size == _capacity)
  6.         {
  7.                 size_t newcapacity = 0 == _capacity ? 4 : _capacity * 2;
  8.                 reserve(newcapacity);
  9.         }
  11.         /*int end = _size;
  12.         while (end >= (int)pos)
  13.         {
  14.                 _str[end + 1] = _str[end];
  15.                 --end;
  16.         }*/
  18.         size_t end = _size + 1;
  19.         while (end > pos)
  20.         {
  21.                 _str[end] = _str[end - 1];
  22.                 --end;
  23.         }
  25.         _str[pos] = ch;
  26.         ++_size;
  27. }
复制代码

  1. void string::insert(size_t pos, const char* str)
  2. {
  3.         assert(pos <= _size);
  5.         size_t len = strlen(str);
  6.         if (_size + len > _capacity)
  7.         {
  8.                 reserve(_size + len);
  9.         }
  11.         /*int end = _size;
  12.         while (end >= (int)pos)
  13.         {
  14.                 _str[end + len] = _str[end];
  15.                 --end;
  16.         }*/
  18.         size_t end = _size + len;
  19.         while (end > pos + len - 1)
  20.         {
  21.                 _str[end] = _str[end - len];
  22.                 --end;
  23.         }
  25.         memcpy(_str + pos, str, len);
  26.         _size += len;
  27. }
复制代码
4.6 删除


  1. const size_t string::npos = -1;
  3. void string::erase(size_t pos, size_t len)
  4. {
  5.         assert(pos < _size);
  7.         //len 大于等于后面字符个数时，有多少删多少
  8.         if (len >= _size - pos)
  9.         {
  10.                 _str[pos] = '\0';
  11.                 _size = pos;
  12.         }
  13.         else
  14.         {
  15.                 strcpy(_str + pos, _str + pos + len);
  16.                 _size -= len;
  17.         }
  18. }
复制代码
4.7 查找

  1. size_t string::find(char ch, size_t pos)
  2. {
  3.         for (size_t i = pos; i < _size; i++)
  4.         {
  5.                 if (_str[i] == ch)
  6.                 {
  7.                         return i;
  8.                 }
  9.         }
  11.         return npos;
  12. }
  14. size_t string::find(const char* str, size_t pos)
  15. {
  16.         char* p = strstr(_str + pos, str);
  17.         return p - _str;
  18. }
复制代码
4.8 赋值


  1. //s1 = s3
  2. //s1 = s1
  3. string& string::operator=(const string& s)
  4. {
  5.         if (this != &s)
  6.         {
  7.                 char* tmp = new char[s._capacity + 1];
  8.                 strcpy(tmp, s._str);
  9.                 delete[] _str;
  10.                 _str = tmp;
  11.                 _size = s._size;
  12.                 _capacity = s._capacity;
  13.         }
  15.         return *this;
  16. }
复制代码
4.9 交换


  1. //s1.swap(s3)
  2. void string::swap(string& s)
  3. {
  4.         std::swap(_str, s._str);
  5.         std::swap(_size, s._size);
  6.         std::swap(_capacity, s._capacity);
  7. }
复制代码
4.10 提取子串


  1. string string::substr(size_t pos, size_t len)
  2. {
  3.         //len大于后面剩余字符，有多少取多少
  4.         if (len > _size - pos)
  5.         {
  6.                 string sub(_str + pos);
  7.                 return sub;
  8.         }
  9.         else
  10.         {
  11.                 string sub;
  12.                 sub.reserve(len);
  13.                 for (size_t i = 0; i < len; i++)
  14.                 {
  15.                         sub += _str[pos + i];
  16.                 }
  18.                 return sub;
  19.         }
  20. }
复制代码
4.11 比力巨细

  1. bool string::operator<(const string& s) const
  2. {
  3.         return strcmp(_str, s._str) < 0;
  4. }
  6. bool string::operator>(const string& s) const
  7. {
  8.         return !(*this <= s);
  9. }
  11. bool string::operator<=(const string& s) const
  12. {
  13.         return *this < s || *this == s;
  14. }
  16. bool string::operator>=(const string& s) const
  17. {
  18.         return !(*this < s);
  19. }
  21. bool string::operator==(const string& s) const
  22. {
  23.         return strcmp(_str, s._str) == 0;
  24. }
  26. bool string::operator!=(const string& s) const
  27. {
  28.         return !(*this == s);
  29. }
复制代码
4.12 流插入 && 流提取

  1. void string::clear()
  2. {
  3.         _str[0] = '\0';
  4.         _size = 0;
  5. }
  7. //一个字符一个字符放入str里，会有很多次扩容，可以优化
  8. //istream& operator>> (istream& is, string& str)
  9. //{
  10. //        str.clear();
  12. //        //流提取（>>）提取不了空格和换行，istream里的函数get()可以
  13. //        char ch = is.get();
  14. //        while (ch != ' ' && ch != '\n')
  15. //        {
  16. //                str += ch;
  17. //                ch = is.get();
  18. //        }
  20. //        return is;
  21. //}
  23. istream& operator>> (istream& is, string& str)
  24. {
  25.         str.clear();
  27.         char buff[128];
  28.         int i = 0;
  29.         char ch = is.get();
  30.         while (ch != ' ' && ch != '\n')
  31.         {
  32.                 buff[i++] = ch;
  34.                 // 0 - 126
  35.                 if (i == 127)
  36.                 {
  37.                         buff[i] = '\0';
  38.                         str += buff;
  39.                         i = 0;
  40.                 }
  42.                 ch = is.get();
  43.         }
  45.         if (i != 0)
  46.         {
  47.                 buff[i] = '\0';
  48.                 str += buff;
  49.         }
  51.         return is;
  52. }
  54. ostream& operator<< (ostream& os, const string& str)
  55. {
  56.         for (size_t i = 0; i < str.size(); i++)
  57.         {
  58.                 os << str[i];
  59.         }
  61.         return os;
  62. }
复制代码
5. 现代版写法的String类

我们之前写的拷贝构造和赋值运算符重载是传统写法，其实另有现代写法：

  1. //现代写法（让别人干活，交换）
  2. //s2(s1)
  3. string::string(const string& s)
  4. {
  5.         string tmp(s._str);
  6.         /*std::swap(tmp._str, _str);
  7.         std::swap(tmp._size, _size);
  8.         std::swap(tmp._capacity, _capacity);*/
  9.        
  10.         //这个是我们写的string类里的交换函数
  11.         swap(tmp);
  12. }
复制代码

  1. /*string& string::operator=(const string& s)
  2. {
  3.         if (this != &s)
  4.         {
  5.                 string tmp(s._str);
  6.                 swap(tmp);
  7.         }
  9.         return *this;
  10. }*/
  12. //s1 = s3
  13. string& string::operator=(string tmp)
  14. {
  15.         swap(tmp);
  17.         return *this;
  18. }
复制代码
5.1 完整代码

  1. //string.h
  3. #include <iostream>
  4. #include <assert.h>
  5. using namespace std;
  7. namespace bit
  8. {
  9.         class string
  10.         {
  11.         public:
  12.                 typedef char* iterator;
  13.                 typedef const char* const_iterator;
  15.                 iterator begin();
  16.                 iterator end();
  18.                 const_iterator begin() const;
  19.                 const_iterator end() const;
  21.                 //string();
  22.                 string(const char* str = "");
  23.                 string(const string& s);
  24.                 //string& operator=(const string& s);
  25.                 string& operator=(string tmp);
  26.                 ~string();
  27.                
  28.                 const char* c_str() const;
  29.                
  30.                 size_t size() const;
  31.                 char& operator[](size_t pos);
  32.                 const char& operator[](size_t pos) const;
  34.                 void reserve(size_t n);
  36.                 void push_back(char ch);
  37.                 void append(const char* str);
  39.                 string& operator+=(char ch);
  40.                 string& operator+=(const char* str);
  42.                 void insert(size_t pos, char ch);
  43.                 void insert(size_t pos, const char* str);
  44.                 void erase(size_t pos = 0, size_t len = npos);
  46.                 size_t find(char ch, size_t pos = 0);
  47.                 size_t find(const char* str, size_t pos =  0);
  49.                 void swap(string& s);
  50.                 string substr(size_t pos = 0, size_t len = npos);
  52.                 bool operator<(const string& s) const;
  53.                 bool operator>(const string& s) const;
  54.                 bool operator<=(const string& s) const;
  55.                 bool operator>=(const string& s) const;
  56.                 bool operator==(const string& s) const;
  57.                 bool operator!=(const string& s) const;
  58.                 void clear();
  60.         private:
  61.                 //char _buff[16];
  63.                 char* _str = nullptr;
  64.                 size_t _size = 0;
  65.                 size_t _capacity = 0;
  67.                 const static size_t npos;
  68.                
  69.                 //特例，const静态成员变量只有整型可以这样声明定义（了解即可，不建议这样写）
  70.                 //const static size_t npos = -1;
  71.                
  72.                 //不支持
  73.                 //const static double N = 2.2;
  74.         };
  76.         istream& operator>> (istream& is, string& str);
  77.         ostream& operator<< (ostream& os, const string& str);
  78. }
复制代码
  1. //string.cpp
  3. #include "string.h"
  5. namespace bit
  6. {
  7.         const size_t string::npos = -1;
  9.         //string::string()
  10.         //{
  11.         //        _str = new char[1]{ '\0' };
  12.         //        _size = 0;
  13.         //        _capacity = 0;
  14.         //}
  16.         string::iterator string::begin()
  17.         {
  18.                 return _str;
  19.         }
  21.         string::iterator string::end()
  22.         {
  23.                 return _str + _size;
  24.         }
  26.         string::const_iterator string::begin() const
  27.         {
  28.                 return _str;
  29.         }
  31.         string::const_iterator string::end() const
  32.         {
  33.                 return _str + _size;
  34.         }
  36.         string::string(const char* str)
  37.                 :_size(strlen(str))
  38.         {
  39.                 _str = new char[_size + 1];
  40.                 _capacity = _size;
  41.                 strcpy(_str, str);
  42.         }
  44.         //传统写法（实在人）
  45.         //s2(s1)
  46.         /*string::string(const string& s)
  47.         {
  48.                 _str = new char[s._capacity + 1];
  49.                 strcpy(_str, s._str);
  50.                 _size = s._size;
  51.                 _capacity = s._capacity;
  52.         }*/
  54.         //现代写法（让别人干活，交换）
  55.         //s2(s1)
  56.         string::string(const string& s)
  57.         {
  58.                 string tmp(s._str);
  59.                 /*std::swap(tmp._str, _str);
  60.                 std::swap(tmp._size, _size);
  61.                 std::swap(tmp._capacity, _capacity);*/
  62.                
  63.                 //这个是我们写的string类里的交换函数
  64.                 swap(tmp);
  65.         }
  67.         //s1 = s3
  68.         //s1 = s1
  69.         /*string& string::operator=(const string& s)
  70.         {
  71.                 if (this != &s)
  72.                 {
  73.                         char* tmp = new char[s._capacity + 1];
  74.                         strcpy(tmp, s._str);
  75.                         delete[] _str;
  76.                         _str = tmp;
  77.                         _size = s._size;
  78.                         _capacity = s._capacity;
  79.                 }
  81.                 return *this;
  82.         }*/
  84.         /*string& string::operator=(const string& s)
  85.         {
  86.                 if (this != &s)
  87.                 {
  88.                         string tmp(s._str);
  89.                         swap(tmp);
  90.                 }
  92.                 return *this;
  93.         }*/
  94.        
  95.         //s1 = s3
  96.         string& string::operator=(string tmp)
  97.         {
  98.                 swap(tmp);
  100.                 return *this;
  101.         }
  103.         string::~string()
  104.         {
  105.                 delete[] _str;
  106.                 _str = nullptr;
  107.                 _size = _capacity = 0;
  108.         }
  110.         const char* string::c_str() const
  111.         {
  112.                 return _str;
  113.         }
  115.         size_t string::size() const
  116.         {
  117.                 return _size;
  118.         }
  120.         char& string::operator[](size_t pos)
  121.         {
  122.                 assert(pos < _size);
  123.                 return _str[pos];
  124.         }
  126.         const char& string::operator[](size_t pos) const
  127.         {
  128.                 assert(pos < _size);
  129.                 return _str[pos];
  130.         }
  132.         void string::reserve(size_t n)
  133.         {
  134.                 if (n > _capacity)
  135.                 {
  136.                         char* tmp = new char[n + 1];
  137.                         strcpy(tmp, _str);
  138.                         delete[] _str;
  140.                         _str = tmp;
  141.                         _capacity = n;
  142.                 }
  143.         }
  145.         void string::push_back(char ch)
  146.         {
  147.                 /*if (_size == _capacity)
  148.                 {
  149.                         size_t newcapacity = 0 == _capacity ? 4 : _capacity * 2;
  150.                         reserve(newcapacity);
  151.                 }
  153.                 _str[_size] = ch;
  154.                 _str[_size + 1] = '\0';
  155.                 ++_size;*/
  157.                 insert(_size, ch);
  158.         }
  160.         //"hello"  "xxxxxxxxxxxxx"
  161.         void string::append(const char* str)
  162.         {
  163.                 /*size_t len = strlen(str);
  164.                 if (_size + len > _capacity)
  165.                 {
  166.                         reserve(_size + len);
  167.                 }
  169.                 strcpy(_str + _size, str);
  170.                 _size += len;*/
  172.                 insert(_size, str);
  173.         }
  175.         string& string::operator+=(char ch)
  176.         {
  177.                 push_back(ch);
  178.                 return *this;
  179.         }
  180.         string& string::operator+=(const char* str)
  181.         {
  182.                 append(str);
  183.                 return *this;
  184.         }
  186.         void string::insert(size_t pos, char ch)
  187.         {
  188.                 assert(pos <= _size);
  190.                 if (_size == _capacity)
  191.                 {
  192.                         size_t newcapacity = 0 == _capacity ? 4 : _capacity * 2;
  193.                         reserve(newcapacity);
  194.                 }
  196.                 /*int end = _size;
  197.                 while (end >= (int)pos)
  198.                 {
  199.                         _str[end + 1] = _str[end];
  200.                         --end;
  201.                 }*/
  203.                 size_t end = _size + 1;
  204.                 while (end > pos)
  205.                 {
  206.                         _str[end] = _str[end - 1];
  207.                         --end;
  208.                 }
  210.                 _str[pos] = ch;
  211.                 ++_size;
  212.         }
  214.         void string::insert(size_t pos, const char* str)
  215.         {
  216.                 assert(pos <= _size);
  218.                 size_t len = strlen(str);
  219.                 if (_size + len > _capacity)
  220.                 {
  221.                         reserve(_size + len);
  222.                 }
  224.                 /*int end = _size;
  225.                 while (end >= (int)pos)
  226.                 {
  227.                         _str[end + len] = _str[end];
  228.                         --end;
  229.                 }*/
  231.                 size_t end = _size + len;
  232.                 while (end > pos + len - 1)
  233.                 {
  234.                         _str[end] = _str[end - len];
  235.                         --end;
  236.                 }
  238.                 memcpy(_str + pos, str, len);
  239.                 _size += len;
  240.         }
  242.         void string::erase(size_t pos, size_t len)
  243.         {
  244.                 assert(pos < _size);
  246.                 //len 大于等于后面字符个数时，有多少删多少
  247.                 if (len >= _size - pos)
  248.                 {
  249.                         _str[pos] = '\0';
  250.                         _size = pos;
  251.                 }
  252.                 else
  253.                 {
  254.                         strcpy(_str + pos, _str + pos + len);
  255.                         _size -= len;
  256.                 }
  257.         }
  259.         size_t string::find(char ch, size_t pos)
  260.         {
  261.                 for (size_t i = pos; i < _size; i++)
  262.                 {
  263.                         if (_str[i] == ch)
  264.                         {
  265.                                 return i;
  266.                         }
  267.                 }
  269.                 return npos;
  270.         }
  272.         size_t string::find(const char* str, size_t pos)
  273.         {
  274.                 char* p = strstr(_str + pos, str);
  275.                 return p - _str;
  276.         }
  278.         //s1.swap(s3)
  279.         void string::swap(string& s)
  280.         {
  281.                 std::swap(_str, s._str);
  282.                 std::swap(_size, s._size);
  283.                 std::swap(_capacity, s._capacity);
  284.         }
  286.         string string::substr(size_t pos, size_t len)
  287.         {
  288.                 //len大于后面剩余字符，有多少取多少
  289.                 if (len > _size - pos)
  290.                 {
  291.                         string sub(_str + pos);
  292.                         return sub;
  293.                 }
  294.                 else
  295.                 {
  296.                         string sub;
  297.                         sub.reserve(len);
  298.                         for (size_t i = 0; i < len; i++)
  299.                         {
  300.                                 sub += _str[pos + i];
  301.                         }
  303.                         return sub;
  304.                 }
  305.         }
  307.         bool string::operator<(const string& s) const
  308.         {
  309.                 return strcmp(_str, s._str) < 0;
  310.         }
  312.         bool string::operator>(const string& s) const
  313.         {
  314.                 return !(*this <= s);
  315.         }
  317.         bool string::operator<=(const string& s) const
  318.         {
  319.                 return *this < s || *this == s;
  320.         }
  322.         bool string::operator>=(const string& s) const
  323.         {
  324.                 return !(*this < s);
  325.         }
  326.        
  327.         bool string::operator==(const string& s) const
  328.         {
  329.                 return strcmp(_str, s._str) == 0;
  330.         }
  332.         bool string::operator!=(const string& s) const
  333.         {
  334.                 return !(*this == s);
  335.         }
  337.         void string::clear()
  338.         {
  339.                 _str[0] = '\0';
  340.                 _size = 0;
  341.         }
  343.         //一个字符一个字符放入str里，会有很多次扩容，可以优化
  344.         //istream& operator>> (istream& is, string& str)
  345.         //{
  346.         //        str.clear();
  348.         //        //流提取（>>）提取不了空格和换行，istream里的函数get()可以
  349.         //        char ch = is.get();
  350.         //        while (ch != ' ' && ch != '\n')
  351.         //        {
  352.         //                str += ch;
  353.         //                ch = is.get();
  354.         //        }
  356.         //        return is;
  357.         //}
  359.         istream& operator>> (istream& is, string& str)
  360.         {
  361.                 str.clear();
  363.                 char buff[128];
  364.                 int i = 0;
  365.                 char ch = is.get();
  366.                 while (ch != ' ' && ch != '\n')
  367.                 {
  368.                         buff[i++] = ch;
  370.                         // 0 - 126
  371.                         if (i == 127)
  372.                         {
  373.                                 buff[i] = '\0';
  374.                                 str += buff;
  375.                                 i = 0;
  376.                         }
  378.                         ch = is.get();
  379.                 }
  381.                 if (i != 0)
  382.                 {
  383.                         buff[i] = '\0';
  384.                         str += buff;
  385.                 }
  387.                 return is;
  388.         }
  390.         ostream& operator<< (ostream& os, const string& str)
  391.         {
  392.                 for (size_t i = 0; i < str.size(); i++)
  393.                 {
  394.                         os << str[i];
  395.                 }
  397.                 return os;
  398.         }
  399. }
复制代码
  1. //Test.cpp
  3. #include "string.h"
  5. namespace bit
  6. {
  7.         void test_string1()
  8.         {
  9.                 string s1("hello world");
  10.                 cout << s1.c_str() << endl;
  12.                 for (size_t i = 0; i < s1.size(); i++)
  13.                 {
  14.                         s1[i]++;
  15.                 }
  17.                 for (size_t i = 0; i < s1.size(); i++)
  18.                 {
  19.                         cout << s1[i] << " ";
  20.                 }
  21.                 cout << endl;
  23.                 //封装：统一屏蔽了底层实现细节，提供了一种简单通用的访问容器的方式
  24.                 string::iterator it1 = s1.begin();
  25.                 while (it1 != s1.end())
  26.                 {
  27.                         cout << *it1 << " ";
  28.                         ++it1;
  29.                 }
  30.                 cout << endl;
  32.                 for (auto e : s1)
  33.                 {
  34.                         cout << e << " ";
  35.                 }
  36.                 cout << endl;
  38.                 string s2;
  39.                 cout << s2.c_str() << endl;
  41.                 const string s3("xxxxxxx");
  43.                 string::const_iterator it3 = s3.begin();
  44.                 while (it3 != s3.end())
  45.                 {
  46.                         //*it3 = 'y';//err
  48.                         cout << *it3 << " ";
  49.                         ++it3;
  50.                 }
  51.                 cout << endl;
  53.                 for (size_t i = 0; i < s3.size(); i++)
  54.                 {
  55.                         //s3[i]++;
  56.                         cout << s3[i] << " ";
  57.                 }
  58.                 cout << endl;
  59.         }
  61.         void test_string2()
  62.         {
  63.                 string s1("hello world");
  64.                 cout << s1.c_str() << endl;
  65.        
  66.                 s1.push_back('x');
  67.                 cout << s1.c_str() << endl;
  68.                
  69.                 s1.append("yyyyy");
  70.                 cout << s1.c_str() << endl;
  71.        
  72.                 s1 += 'z';
  73.                 s1 += "mmmmmm";
  74.                 cout << s1.c_str() << endl;
  75.         }
  77.         void test_string3()
  78.         {
  79.                 string s1("hello world");
  80.                 cout << s1.c_str() << endl;
  82.                 s1.insert(6, 'x');
  83.                 cout << s1.c_str() << endl;
  85.                 s1.insert(0, 'x');
  86.                 cout << s1.c_str() << endl;
  87.        
  88.                 string s2("hello world");
  89.                 cout << s2.c_str() << endl;
  91.                 s2.insert(6, "yyy");
  92.                 cout << s2.c_str() << endl;
  94.                 s2.insert(0, "yyy");
  95.                 cout << s2.c_str() << endl;
  97.                 string s3("hello world");
  98.                 cout << s3.c_str() << endl;
  99.                 //s3.erase(6, 10);
  100.                 s3.erase(6);
  101.                 cout << s3.c_str() << endl;
  103.                 string s4("hello world");
  104.                 cout << s4.c_str() << endl;
  105.                 s4.erase(6, 3);
  106.                 cout << s4.c_str() << endl;
  107.         }
  109.         void test_string4()
  110.         {
  111.                 string s1("hello world");
  112.                 cout << s1.find('o') << endl;
  113.                 cout << s1.find("wor") << endl;
  114.         }
  116.         void test_string5()
  117.         {
  118.                 string s1("hello world");
  119.                 string s2(s1);
  121.                 s1[0] = 'x';
  122.                 cout << s1.c_str() << endl;
  123.                 cout << s2.c_str() << endl;
  124.        
  125.                 string s3("yyyy");
  126.                 s1 = s3;
  127.                 cout << s1.c_str() << endl;
  128.                 cout << s3.c_str() << endl;
  129.        
  130.                 string s4("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
  131.                 s1 = s4;
  132.                 cout << s1.c_str() << endl;
  133.                 cout << s4.c_str() << endl;
  134.        
  135.                 s1 = s1;
  136.                 cout << s1.c_str() << endl;
  137.                 cout << s3.c_str() << endl;
  138.                
  139.                 std::swap(s1, s3);
  140.                 cout << s1.c_str() << endl;
  141.                 cout << s3.c_str() << endl;
  143.                 s1.swap(s3);
  144.                 cout << s1.c_str() << endl;
  145.                 cout << s3.c_str() << endl;
  146.         }
  148.         void test_string6()
  149.         {
  150.                 string url("https://gitee.com/ailiangshilove/cpp-class/blob/master/%E8%AF%BE%E4%BB%B6%E4%BB%A3%E7%A0%81/C++%E8%AF%BE%E4%BB%B6V6/string%E7%9A%84%E6%8E%A5%E5%8F%A3%E6%B5%8B%E8%AF%95%E5%8F%8A%E4%BD%BF%E7%94%A8/TestString.cpp");
  151.                 size_t pos1 = url.find(':');
  152.                 string url1 = url.substr(0, pos1 - 0);
  153.                 cout << url1.c_str() << endl;
  155.                 size_t pos2 = url.find('/', pos1 + 3);
  156.                 string url2 = url.substr(pos1 + 3, pos2 - (pos1 + 3));
  157.                 cout << url2.c_str() << endl;
  159.                 string url3 = url.substr(pos2 + 1);
  160.                 cout << url3.c_str() << endl;
  161.         }
  163.         void test_string7()
  164.         {
  165.                 //string s1("hello world");
  166.                 //cout << s1 << endl;
  167.                
  168.                 string s1;
  169.                 cin >> s1;
  170.                 cout << s1 << endl;
  171.         }
  173.         void test_string8()
  174.         {
  175.                 string s1("hello world");
  176.                 string s2(s1);
  177.                 cout << s1 << endl;
  178.                 cout << s2 << endl;
  180.                 string s3("xxxxxxxxxxxxxxxxxxxxxxxxx");
  181.                 s1 = s3;
  182.                 cout << s1 << endl;
  183.                 cout << s3 << endl;
  184.         }
  185. }
  187. int main()
  188. {
  189.         bit::test_string8();
  191.         return 0;
  192. }
复制代码
6. 写时拷贝（了解）

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

举个例子：
  1. void copy_on_write()
  2. {
  3.         //如果计数不等于1，再去做深拷贝
  4. }
  6. void string::push_back(char ch)
  7. {
  8.         //写时拷贝
  9.         copy_on_write();
  11.         /*if (_size == _capacity)
  12.         {
  13.                 size_t newcapacity = 0 == _capacity ? 4 : _capacity * 2;
  14.                 reserve(newcapacity);
  15.         }
  17.         _str[_size] = ch;
  18.         _str[_size + 1] = '\0';
  19.         ++_size;*/
  21.         insert(_size, ch);
  22. }
复制代码
可以用下面的代码来看是否是用了写时拷贝：
  1. void test_string9()
  2. {
  3.         std::string s1("hello world");
  4.         std::string s2(s1);
  6.         cout << (void*)s1.c_str() << endl;
  7.         cout << (void*)s2.c_str() << endl;
  8. }
复制代码
Windows的VS下没有用写时拷贝，而Linux的g++就使用了写时拷贝。

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

用户云卷云舒

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表