淺談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類

致遠OA及相關OA系統集成與二次開發

EXCEL公式使用總結

System.Object未被引用的程序集中定義

Java 信號量（semaphore）搭配CountDownLatch 實現多線程處理循環內邏輯並限制創建線程數

[轉帖]linux命令top內存顯示M兆或者G

【面試準備】項目經驗——接口自動化項目

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以太網驅動總結