浅谈C++string类

这里向大家介绍C++库函数中的一个文件
为了简化程序员的工作量并提高代码的安全性和健壮性 C++标准库找专门提供了文件用来提供对字符串进行多种操作的库函数接口，
这些接口配合C++中文件中的strlen strstr strcpy …….系列函数共同为字符串的处理服务。

本文中模拟的string类没有加迭代器为了简化抽象出文件中string类的功能、内部实现机制和设计思想。

拷贝构造函数 operator=（）中的浅拷贝与深拷贝

String::String(const String& s)//浅拷贝
        :_str(s._str)
{}

                  测试用例
void Test2()
{
    String s1("hello");
    String s2(s1);
}

这里的s2 中的字符指针直接指向了s1中字符指针指向的字符串。对象s1析构之后 s2中指针指向的字符串已被释放再调用s2的析构函数导致同一空间被析构两次程序崩溃。
编译器只是将指针的内容拷贝过来，导致多个对象共用一块内存空间，当其中任意对象将这块空间释放之后，另外一些对象并不知道这块空间已经还给了操作系统，以为还有效，所以再对这块空间进行操作时，造成了违规访问。

为解决浅拷贝问题只有进行深拷贝即为新对象重新开辟字符串空间让新对象字符指针指向自己的字符串空间该空间字符串内荣是源字符串的拷贝

 String(char* str = "")
       :_str(new char[strlen(str) + 1])
   {
        strcpy(_str, str);
   }

String&operator = (constString& s)//写法1
   {
       if(this!= &s){
       delete[] _str;
       _str =new char[strlen(s._str) + 1];
       strcpy(_str, s._str);
       }
  }

 String&operator=(constString& s)//写法2
      {
          if(this!= &s)
          {
               char* tmp = new char[strlen(s._str) + 1];
               strcpy(tmp, s._str);
               delete[] _str;
               _str = tmp;
          }
          return*this;//为了支持链式访问
      }

voidTest2()
{
     String s1("hello");
     String s2(s1);
     Srring s3;
     s3 = s2;
}

拷贝的对象s2中_str的值（字符串的地址）和s1对象中的_str的值不同，重新开辟了空间（即就是深拷贝）。

一般情况下，上面的两种写法都可以，但是相对而言，第二种更优一点。
对于第一种，先释放了旧空间，但是如果下面用new开辟新空间时有可能失败——>抛异常，而这时你是将s2赋值给s3,不仅没有赋值成功（空间开辟失败），而且也破坏了原有的s3对象。
对于第二种，先开辟新空间，将新空间的地址赋给一个临时变量，就算这时空间开辟失败，也不会影响原本s3对象。
综上：第二种方法更优一点。
最后的返回值是为了支持链式访问。
例如：s3 = s2 = s1;
上面所写的拷贝构造函数和赋值运算符重载函数属于传统写法，下面我们一起来看看它们的现代写法：

String(constString& s)
              :_str(NULL)
          {
              Stringtmp(s._str);
              swap(_str, tmp._str);
          }

          String&operator = (constString& s)
          {
              if(this!= &s){
                   Stringtmp(s._str);
                   swap(_str, tmp._str);
              }
              return*this;
          }

下面两幅图介绍一下现代写法拷贝构造函数和赋值运算符重载的思想：

从上面的深拷贝我们可以看出，相比浅拷贝，深拷贝的效率明显较低，因为每拷贝一个对象就需要开辟空间和释放空间，再有就是赋值运算符重载也是一样的需要重新开辟空间并释放空间。
假如有这样的一种情况，拷贝和赋值得到的对象只用于”读”,而不用于”写”，那么是不是就不需要重新开辟空间了呢？

string的引用计数指针版本:
在对象中搞一个指向多个对象公共引用计数的指针用以记录该字符串空间被几个对象的字符指针共同管理

namespaceCOW1//写时拷贝 引用计数指针
{
     classString
     {
     public:
          String(constchar* str ="")
              :_refCountPtr(newint(1))
          {//引用计数指针版本的String构造函数初始化标识字符串字符数的_size
          //字符串空间大小的_capacity
          //字符串_str
          //引用计数指针_refCountPtr指向的空间 并初始化为一（同一个字符串最初只有一个对象管理）
              _size =strlen(str);
              _capacity = _size;
              _str =new char[_capacity + 1];
              strcpy(_str, str);
          }

          String(constString& s)//引用计数方式的String类的拷贝构造函数
              :_refCountPtr(s._refCountPtr)
              ,_size(s._size)
              ,_capacity(s._capacity)
              ,_str(s._str)
          {//每次做拷贝的时候只是让新对象的字符指针和引用计数指针指向原对象空间
              //并++两对象引用计数指针指向的共同引用计数 实际上内存中的字符串只有一份
              (*_refCountPtr)++;//这样做是为了节省空间  所谓“写时拷贝 不拷就赚”
          }

          String&operator = (constString& s)
          {
              if(_str != s._str){
                   Ralese();

                   _refCountPtr = s._refCountPtr;
                   _str = s._str;
                   (*_refCountPtr)++;
              }
              return*this;
          }

          voidRalese()
          {
              if(--(*_refCountPtr) == 0){
                   cout <<"delete[]" << _str << endl;
                   delete[] _str;
                   delete_refCountPtr;
              }
          }

          voidPushBack(constchar& ch)
          {
              //修改字符串的时候 才真正拷贝一份新的在使用角度上已经有的新字符串
              //在该字符串上做修改 
              CopyOnWrite();
              if(_size == _capacity){

              }
              _str[_size++] = ch;
              _str[_size] ='\0';

          }

          voidCopyOnWrite()
          {
              if(*_refCountPtr > 1){//写时拷贝发生的条件 即同一个在内存中的字符串被多个对象
                                           //的字符指针所引用
                   char* newSize = new char[_capacity];
                   strcpy(newSize,_str);

                   *(_refCountPtr)--;
                   _str = newSize;
                   _refCountPtr =new int(1);//本函数负责修改公共引用计数 拷贝原对象所有内容
              }
          }

          char&operator[](size_tpos)
          {
              CopyOnWrite();//非const类型的operator[]函数因为要修改_str[X]中的内容
              return_str[pos];//必须为要修改的对象的字符串重新开辟空间 否则在应用层面上将形成
                                  //改变了多个字符串的现象 因为在底层他们各自的char*指向同一字符串
          }

          char&operator[] (size_tpos)const
          {
              return_str[pos];
          }

          ~String()
          {
              Ralese();
          }

          constchar*c_str()
          {
              return_str;
          }
     private:
          char* _str;
          int* _refCountPtr;
          size_t_size;
          size_t_capacity;
     };

     // "有时候读的时候也要拷贝"
     voidTestString1()
     {
          /*String s1("hello world");
          String s2(s1);
          s1 = s2;

          String s3("dadadada");
          s3 = s1;

          String s4("dadadsqwqdq");
          s1 = s4;*/

          Strings1("hello world");
          Strings2(s1);
          cout << s1[0] <<endl;
          cout << s1.c_str() << endl;
          cout << s2.c_str() << endl;
     }
}

以下是图示思路：

使用指针可以完成引用计数的浅拷贝，但是因为每构造一个对象，都需要开辟两块空间，这样容易造成内存碎片。
由new[]可以联想到类似模型—->只开辟一块空间（多开四个字节），把引用计数放在字符串首地址的前四个字节上。
这样不但解决了内存碎片问题，而且也可以程序的运行效率。

                    string的引用计数在对象空间前4字节版本:

namespaceCOW2//写时拷贝 在对象空间前4个字节存放引用计数
{
     classString//在构造时初始化引用计数 涉及到拷贝时修改引用计数
     {
     public:
          String(constchar* str ="")
              :_size(strlen(str))
              , _capacity(_size)
          {
              _str =new char[_capacity + 5];
              strcpy(_str + 4, str);
              _str += 4;
              GetCountRef()++;
          }

          int&GetCountRef()
          {
              return*((int*)(_str - 4));
          }

          String(constString& s)
              :_size(s._size)
              ,_capacity(s._capacity)
              ,_str(s._str)
          {
              GetCountRef()++;
          }

          String&operator = (constString& s)
          {
              if(_str != s._str){
                   Ralese();
                   _size = s._size;
                   _capacity = s._capacity;
                   _str = s._str;
                   GetCountRef()++;
              }
          }

          voidRalese()
          {
              if(--GetCountRef() == 0){
                   delete[] (_str - 4);
              }
          }

          voidCopyOnwrite()
          {
              if(GetCountRef() > 1){
                   char* newSize = new char[_capacity + 5];
                   strcpy(newSize + 4, _str);

                   GetCountRef()--;
                   _str = newSize + 4;
                   *((int*)(_str - 4)) = 1;
              }
          }

          char&operator[](size_tpos)
          {
              CopyOnwrite();
              return_str[pos];
          }

          charoperator[](size_tpos)const
          {
              return_str[pos];
          }

          ~String()
          {
              Ralese();
          }

          constchar*c_str()
          {
              return_str;
          }
     private:
          char* _str;
          size_t_size;
          size_t_capacity;
     };
}
关于string类中涉及的增删查改工作：
namespaceDC//实现String类的增删查改
{
     classString
     {
     public:
          String(constchar* str ="")
          {
              _size =strlen(str);
              _capacity = _size;
              _str =new char(_capacity + 1);
              strcpy(_str,str);
          }

          String(constString& s)
          {
              Stringtmp(s._str);//拷贝构造时先创造一个临时对象 让临时对象和当前
              Swap(tmp);        //对象内容交换 再因为临时对象出函数作用域要被释放 所以释放对象
                                    //留下拷贝后的对象。
          }

          voidSwap(String& tmp)
          {
              swap(_str, tmp._str);
              swap(_size, tmp._size);
              swap(_capacity, tmp._capacity);
          }

          String&operator = (String& s)
          {
              Swap(s);
              return*this;
          }

          size_tSize()
          {
              return_size;
          }

          size_tCapacity()
          {
              return_capacity;
          }

          char*c_str()
          {
              return_str;
          }

          voidPushBack(charch)
          {
              if(_size == _capacity){
                   Expand(_capacity * 2);
              }

              _str[_size++] = ch;
              _str[_size] ='\0';
          }

          voidPushBack(constchar* str)
          {
              size_tlen = strlen(str);
              if(_size + len > _capacity){
                   Expand(_size + len);
              }

              strcpy(_str + len, str);
          }

          voidPopback()
          {
              assert(_size);
              --_size;
          }

          voidInsert(charch, int pos)
          {
              if(_size > _capacity){
                   Expand(_capacity * 2);
              }

              intend = _size;
              while(end >= pos){
                   _str[end+ 1] = _str[end];
                   --end;
              }
              _str[pos] = ch;
              ++_size;
          }
          //插入方法同顺序表
          voidInsert(constchar* str,int pos)
          {
              if(_size + strlen(str) > _capacity){
                   Expand(_size + strlen(str));
              }
              intend = _size;
              while(end >= (int)pos){
                   _str[end +strlen(str)] = _str[end];
                   --end;
              }
              while(*str){
                   _str[pos++] = *str++;
              }
              _size +=strlen(str);
          }

          voidErase(size_tpos, size_t count)
          {
              if(pos + count > _size - 1){
                   _str[pos] ='\0';
                   _size = pos;//pos 到 count超过整个字符串 删去pos之后字符
              }
              else{
                   strcpy(_str + pos, _str + pos + count);//将 pos 至 count 段的字符覆盖掉
                   _size -= count;
              }
          }

          voidExpand(size_tn)
          {
              if(n > _capacity){
                   _str = (char*)realloc(_str, n + 1);
                   assert(_str);
                   _capacity = n;
              }
          }

          intFind(constchar ch)
          {
              for(size_ti = 0; i < _size; ++i){
                   if(_str[i] == ch){
                        returni;
                   }
                   else{
                        return-1;
                   }
              }
          }

          intFind(constchar* str)const
          {
              assert(str);
              constchar* srcStr = _str;
              constchar* subStr = str;
              size_tsrcIndex = 0;
              size_tsubIndex = 0;
              size_tsublen = strlen(str);

              while(srcIndex < _size - sublen -  1){
                   size_tmatchIndex = srcIndex;//这里是在一个疑似的第一个字符索引
                   while(_str[matchIndex] == str[subIndex]){//该循环在疑似字串中一个个比对
                        matchIndex++;                        //字符直到比到要找的字串结尾2
                        subIndex++;
                        if(subIndex == sublen){
                             returnsrcIndex;
                        }
                   }
                   subIndex = 0;//字串的索引重新置零 从下一个子串的头开始找
                   srcIndex++;//找以下一个字符为首的字符串是不是字串str
              }
              return-1;
          }

          ~String()
          {
              if(_str){
                   delete[] _str;
                   _str =NULL;
                   _capacity = _size = 0;
              }
          }

          booloperator<(constString& s)const
          {
              size_ti = 0;
              for(; i < _size && i < s._size; ++i)
              {
                   if(_str[i] < s._str[i])
                   {
                        returntrue;
                   }
                   elseif (_str[i] > s._str[i])
                   {
                        returnfalse;
                   }
              }

              if(i == _size && i < s._size) //?
              {
                   returntrue;
              }
              else
              {
                   returnfalse;
              }

          }

          inlinebool operator<=(constString& s)const
          {
              return*this< s || *this== s;
          }
          inlinebool operator>(constString& s)const
          {
              return!(*this<= s);
          }
          booloperator>=(constString& s)const;

          booloperator==(constString& s)const
          {
              size_ti = 0;
              for(; i < _size && i < s._size; ++i)
              {
                   if(_str[i] != s._str[i])
                   {
                        returnfalse;
                   }
              }

              if(i == _size && i == s._size)
              {
                   returntrue;
              }
              else
              {
                   returnfalse;
              }

          }
     private:
          char* _str;
          size_t_size;
          size_t_capacity;
     };
}

浅谈C++string类

Linux 文件描述符與文件系統

字符串編程題題目解析（From leetcode）——1

C++實現五子棋小遊戲

類的六個默認成員函數（轉）

淺談C++string類

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結