字符串類——字符串類的創建（上）

1，歷史遺留問題：

       1，C 語言不支持真正意義上的字符串；

       2，C 語言用字符數組和一組函數實現字符串操作；

              1，字符數組模擬字符串；

              2，字符數組以 \0 來結束就是合法字符串；

              3，C 語言中沒有單獨類型支持字符串，要么是字符數組，要么是 char* 指針；

       3，C 語言不支持自定義類型，因此無法獲得字符串類型；

      

2，從 C 到 C++ 的進化過程引入了自定義類型；

     在 C++ 中可以通過類完成字符串類型的定義；

     C++ 中的原生類型不包含字符串類型，要兼容 C 語言；

  

3，C++ 中通過庫來支持字符串類型：

       1，stl 中就有 string 類，這是官方承認的 string 類型；

   　2，Qt 中提供 QString；

   　3，MFC 中提供 CString；

  

4，數據結構庫中也應該包含字符串庫，否則拿出去應該沒人使用的，本文就是設計自己的 String 類；

 

5，DTLib 中字符串類的設計：

 

       1，所以字符串類的設計方案基本一致，只不過是出自不同廠商，對應的類型不同，在對應的類型下面使用設計的方法確是一樣的；

       2，繼承自 Object，依賴 C 語言關於字符串函數的一個包（函數集）；

       3，要注意設計的成員函數的先后秩序；

      

6，DTLib 中字符串類的實現（本博文中實現了包括KMP算法應用在內的一系列字符串功能函數，包括后續“字符串類——字符串類的創建（下）”、“字符串類———KMP子串查找算法”、“字符串類——KMP算法的應用”博文中的內容，不限於下圖）：

 

      

7，實現時的注意事項：

       1，無縫實現 String 對象與 char* 字符串的互操作；

       2，操作符重載函數需要考慮是否支持 const 版本；

       3，通過 C 語言中的字符串函數實現 String 的成員函數；

      

8，C 語言中的字符串類型：

       1，常量字符串：

              1，const char* string，string 指向字符數組首地址；

              2，char string[]，string[] 為字符數組；

       2，即要么是字符串數組本身，要么是指向字符數組首地址（一般的是這樣）的 char*；

       3，本質還是字符數組；

 

9，字符串類 String 的實現：

　　1，String.h 的實現：

#ifndef DTSTRING_H
#define DTSTRING_H

#include "Object.h"

namespace DTLib
{

class String : public Object // 庫規則中每個類都要繼承自頂層父類 Object
{
protected:   // 面相對象的技術封裝 C 語言中的字符串實現。
    char* m_str;  // 指向字符串，字符串的表現形式是字符數組；
　　 int m_length;  // 當前字符串的長度；

    void init(const char* s);  // 初始化函數
    /* 比對函數，為 startWith() 服務，前兩個參數為字符數組的首地址，第三個參數是字符數組長度；長度范圍內字符數組對應元素都相等，返回真； */
    bool equal(const char* l, const char* r, int len) const;
    static int* make_pmt(const char* p);
　　 static int kmp(const char* s, const char* p);

public:
    String();
    String(char c);
    String(const char* s);
　　 String(const String& s); //  拷貝構造函數；

    int length() const;  // 得到字符串長度；
　　 const char* str()  const; // 字符串對象與傳統字符串進行互操作的轉換函數

    /* 判斷當前的字符對象是否以 s 開頭,判斷當前的字符對象是否以 s 結束 */
    bool startWith(const char* s) const;
    bool startWith(const String& s) const;
    bool endOf(const char* s) const;
　　 bool endOf(const String& s) const;

    /* 將字符串 s 插入到對象下標為 i 處，返回 String& 是為了鏈式操作，返回字符串自己 */
    String& insert(int i, const char* s);
　　 String& insert(int i, const String& s);

    /* 去掉字符串中的空格 */
　　 String& trim();

    int indexOf(const char* ) const;
　　 int indexOf(const String& s) const;

    /* 刪除字符串中的子串 s */
    String& remove(int i, int len); // 刪除下標 i 處指定長度 len 的長度；
    String& remove(const char* s);
　　 String& remove(const String& s);

    /* 用 s 替換字符串中的 t */
    String& replace(const char* t, const char* s);
    String& replace(const String& t, const char* s);
    String& replace(const char* t, const String& s);
　　 String& replace(const String& t, const String& s);

    /* 提取以 i 為起點去長度為 len 的子串 */
　　 String sub(int i, int len) const; // 因為這里不會改變當前字符串狀態，所以為 const 成員函數；

    /* 字符串對象應該能夠像字符數組一樣，通過每一個下標來訪問每一個字符； */
    char& operator [] (int i); // 引用意味着可以被賦值，可以出現在賦值符號左邊（此時是對象），給沒有被 const 修飾的版本用；
　　 char operator [] (int i) const;  // 不能作為左值，所以不能返回引用對象；給 const 修飾的常對象版本使用

    /* 比較操作符重載函數，兼容字符串對象與 C 語言中 const char* 所代表的字符串中的邏輯操作；封裝 strcmp 函數完成 ；const 版本給被 const 修飾的常對象使用的，未被 const 修飾的對象也可以作為參數被調用；*/
    bool operator == (const String& s) const;
    bool operator == (const char* s) const;
    bool operator != (const String& s) const;
    bool operator != (const char* s) const;
    bool operator > (const String& s) const;
    bool operator > (const char* s) const;
    bool operator < (const String& s) const;
    bool operator < (const char* s) const;
    bool operator >= (const String& s) const;
    bool operator >= (const char* s) const;
    bool operator <= (const String& s) const;
　　 bool operator <= (const char* s) const;

    
　　 /* 加法操作符重載函數 */
    String operator + (const String& s) const;
    String operator + (const char* s) const;
    String& operator += (const String& s); 
　　 String& operator += (const char* s);

    /* 減法操作符重載函數 */
    String operator - (const String& s) const;
    String operator - (const char* s) const;
    String& operator -= (const String& s);  //成員會改變的，所以不能用const修飾了
　　 String& operator -= (const char* s);

    /* 賦值操作符重載函數 */
    String& operator = (const String& s);
    String& operator = (const char* s);
　　 String& operator = (char c);  // 加上一個字符

    ~String();
};

}

#endif // DTSTRING_H

　2，String.cpp 的實現：

#include <cstring>
#include <cstdlib>
#include "DTString.h"
#include "Exception.h"

using namespace std;
namespace DTLib
{

/* 建立指定字符串的 pmt（部分匹配表）表 */
int* String::make_pmt(const char* p)  //  O(m)，只有一個 for 循環
{
    int len = strlen(p);
　　 int* ret = static_cast<int*>(malloc(sizeof(int) * len));

    if ( ret != NULL )
    {
        int ll = 0; //定義 ll，前綴和后綴交集的最大長度數，largest length;第一步
        ret[0] = 0;  // 長度為 1 的字符串前后集都為空，對應 ll 為 0；
        for(int i=1; i<len; i++)  // 從第一個下標，也就是第二個字符開始計算，因為第 0 個字符前面已經計算過了； 第二步
        {
            /* 算法第四步 */
            while( (ll > 0) && (p[ll] != p[i]) ) // 當 ll 值為零時，轉到下面 if() 函數繼續判斷，最后賦值與匹配表，所以順序不要錯；
            {
                ll = ret[ll - 1];  // 從之前匹配的部分匹配值表中，繼續和最后擴展的那個字符匹配
            }

            /* 算法的第三步，這是成功的情況 */
            if( p[ll] == p[i] ) // 根據 ll 來確定擴展的種子個數為 ll，而數組 ll 處就處對應的擴展元素，然后和最新擴展的元素比較；
            {
                ll++;   // 若相同（與假設符合）則加一
            }

            ret[i] = ll;   // 部分匹配表里存儲部分匹配值 ll
        }
　　 }

    return ret;
}

/* 在字符串 s 中查找子串 p */
int String::kmp(const char* s, const char* p)  // O(m) + O(n) ==> O(m+n)， 只有一個 for 循環
{
    int ret = -1;
    int sl = strlen(s);
    int pl = strlen(p);
　　 int* pmt = make_pmt(p);

    if( (pmt != NULL) && (0 < pl) && (pl <= sl) ) // 判斷查找條件
    {
        for(int i=0, j=0; i<sl; i++)  // i 的值要小於目標竄長度才可以查找
        {
            while( (j > 0) && (s[i] != p[j]) ) // 比對不上的時候，持續比對，
            {
                j = pmt[j-1];  //移動后應該繼續匹配的位置，j =j-(j-LL)= LL = PMT[j-1]
            }

            if( s[i] == p[j] )  // 比對字符成功
            {
                j++;   // 加然后比對下一個字符
            }

            if( j == pl )  // 這個時候是查找到了，因為 j 增加到了 pl 的長度；
            {
                ret = i + 1 - pl; // 匹配成功后，i 的值停在最后一個匹配成功的字符上，這樣就返回匹配成功的位置
                break;
            }
        }
　　 }

　　 free(pmt);

    return ret;
}

/* 通過參數 s，具體產生當前字符串對象當中的數據，供構造函數使用；實現的方法就是封裝 */
void String::init(const char* s)
{
　　 m_str = strdup(s);  // 當前字符串當中的數據通過 m_str 指針指向；

    if( m_str )  // 復制失敗會返回空指針；
    {
        m_length = strlen(m_str);  // 獲取長度；
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to creat String object ...");
    }
}

/* 比對函數，為 startWith() 服務，前兩個參數為字符數組的首地址，第三個參數是字符數組長度；長度范圍內字符數組對應元素都相等，返回真； */
bool String::equal(const char* l, const char* r, int len) const
{
    bool ret = true;
    for(int i=0; i<len && ret; i++)  // 這里的 ret 看似沒用，實則只要有元素不相等就停止循環、非常重要；
    {
        ret = ret && (l[i] == r[i]);  // 如果有一個位置的字符不相等，則結束比較，返回 false；
　　 }

    return ret;
}

String::String()
{
    init("");
}

String::String(const char* s)
{
    init(s ? s : ""); // 將空指針轉換為空字符串，s 正確了返回 s，錯誤了返回 “”（這是空字符串）
}

String::String(const String& s)
{
    init(s.m_str);
}

/* 字符作為初始值創建字符串對象 */
String::String(char c)
{
    char s[] = {c, '\0'};  // 用字符數組模擬字符串的初始化方式，這是兩種初始化中的一種；
    init(s);
}

int String::length() const
{
    return m_length;
}

/* 字符串對象與傳統字符串進行互操作的轉換函數 */
const char* String::str() const  // 直接返回字符串首地址
{
    return m_str; // 字符串對象本身就是通過字符指針來指向的，這樣就可以直接轉換；
}

/* 判斷當前的字符對象是否以 s 開頭 */
bool String::startWith(const char* s) const
{
　　 bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);
        ret = (len < m_length) && equal(m_str, s, len);  // 如果參數字符串 s 長度比當前字符串長度更長，直接返回 false；
　　 }

    return ret;
}

bool String::startWith(const String& s) const
{
    return startWith(s.m_str); // 代碼復用了上面的
}

bool String::endOf(const char* s) const  // s 這個字符串是否是以字符開始
{
　　 bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);
        char* str = m_str + (m_length - len);  // 計算最后 n 個字符表示的字符串；
        ret = (len < m_length) && equal(str, s, len);  // 如果參數字符串 s 長度比當前字符串長度更長，直接返回 false；
　　 }

    return ret;
}

bool String::endOf(const String& s) const
{
    return endOf(s.m_str);  // 代碼復用了上面的
}

/* 第 i 個位置插入字符串 s，返回字符串對象是為了實現鏈式操作 */
String& String::insert(int i, const char* s)
{
    if( (0 <= i) && (i <= m_length) )
    {
        if( (s != NULL) && (s[0] != '\0') )  // 不為空和空字符串；
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(m_length + len + 1)); 

            if( str != NULL )
            {
                strncpy(str, m_str, i); // 當前字符串的前 i 個字符拷貝出來到 str
                strncpy(str + i, s, len);//將參數字符串s全部拷貝到 str + i 上去
                strncpy(str + i + len, m_str + i, m_length - i); // 將最后字符串拷貝出來
                str[m_length + len] = '\0';  // 最后添加結束符
                free(m_str);  // 釋放當前字符串的堆空間
                m_str = str;  // 使用申請出來的堆空間中的字符串；
                m_length = m_length + len;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert String value ...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
　　 }

    return *this;
}

String& String::insert(int i, const String& s)
{
    return insert(i, s.m_str);
}

String& String::trim()
{
    int b = 0;
　　 int e = m_length - 1;

    while( m_str[b] == ' ' ) b++;  // 確定中間字符串開始位置；
　　 while( m_str[e] == ' ' ) e--;  // 確定中間字符竄結束位置；

    if( b == 0 )
    {
        m_str[e + 1] = '\0';  // 最開始沒有空格的時候；
        m_length = e + 1;
    }
    else
    {
        for(int i=0, j=b; j<=e; i++, j++)
        {
            m_str[i] = m_str[j];  // 將當前的含有的非空字符挪到前面去；
        }
        m_str[e - b + 1] = '\0';  // 添加結束符
        m_length = e - b + 1;  // 合法的字符個數；
　　 }

    return *this;   // 實現鏈式調用
}

int String::indexOf(const char* s) const // 子串查找，返回下標
{
    return kmp(m_str, s ? s : "");
}

int String::indexOf(const String &s) const
{
    return kmp(m_str, s.m_str);
}

/* 刪除下標 i 處長度為 len 的字符串 */
String& String::remove(int i, int len)   // 和 insert() 返回的是相同的函數，還可以以字符串類繼續訪問，如查看刪除后的字符串等
{
    if( (0 <= i ) && (i < m_length) )
    {
        int n = i;
        int m = i + len; // 在 (n, m) 范圍之內的字符都要刪除掉

        while( (n < m) && (m < m_length) ) // 刪除的字符串長度是不能大於當前的長度的，否則沒有意義
        {
            m_str[n++] = m_str[m++];   // 很經典
        }

        m_str[n] = '\0';  //因為n是不斷增加的，直到 m 為等於 length
        m_length = n; 
　　 }

    return *this;
}

String& String::remove(const char *s) // 刪除子串
{
    return remove(indexOf(s), s ? strlen(s) : 0);  
}

String& String::remove(const String &s) // 刪除子串
{
    return remove(indexOf(s), s.length());
}

/* 用 s 替換字符串中的 t */
String& String::replace(const char* t, const char* s)
{
　　 int index = indexOf(t); // 查找 t 的位置

    if( index >= 0 ) // t 存在於當前的字符串中
    {
        remove(t);  // 不要復制粘貼代碼，要復用
        insert(index, s);
　　 }

    return *this;
}

String& String::replace(const String& t, const char* s)
{
    return replace(t.m_str, s);
}

String& String::replace(const char* t, const String& s)
{
    return replace(t, s.m_str);
}

String& String::replace(const String& t, const String& s)
{
    return replace(t.m_str, s.m_str);
}

String String::sub(int i, int len) const  // 查找當前字符串中第 i 個位置長度為 len 的字符串
{
　　 String ret;

    if( (0 <= i) && (i < m_length) )
    {
        if( len < 0 ) len = 0; // 當小於零時候，不可能，要歸一化到 0
        if(len+i > m_length) len = m_length - i; // 只能夠提取這么長的長度
        char* str = reinterpret_cast<char*>(malloc(len + 1));

        if( str != NULL )
        {
            strncpy(str, m_str + i, len); // 從 m_str + i 位置拷貝 len 長度的字符串，這里 m_str 是字符串起始位置
        }

        str[len] = '\0';
        ret = str;  // 返回子串

        free(str);
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invaid ...");
　　 }

    return ret;
}

char& String::operator [] (int i)
{
    if( (0 <= i) && (i < m_length) )
    {
        return m_str[i];   // 封裝；
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }
}

char String::operator [] (int i) const
{
　　 return (const_cast<String&>(*this))[i]; // 在當前版本當中對非 const 代碼復用上面
}

/* 直接封裝 C 語言中的相關函數，直接封裝 C 語言庫中 strcmp() 函數即可 */
bool String::operator ==(const String& s) const
{
    return (strcmp(m_str, s.m_str) == 0);  // strcmp 的函數原型為 int strcmp(const char* s1, const char* s2)
}

bool String::operator ==(const char* s) const
{
    return (strcmp(m_str, s ? s : "") == 0);  // 三目運算符是為了防止 s 為空指針。
}

bool String::operator != (const String& s) const
{
    return !(*this == s);
}

bool String::operator != (const char* s) const
{
    return !(*this == s);
}

bool String::operator > (const String& s) const
{
    return (strcmp(m_str, s.m_str) > 0);
}

bool String::operator > (const char* s) const
{
    return (strcmp(m_str, s ? s : "") > 0);
}

bool String::operator < (const String& s) const
{
    return (strcmp(m_str, s.m_str) < 0);
}

bool String::operator < (const char* s) const
{
    return (strcmp(m_str, s ? s : "") < 0);
}

bool String::operator >= (const String& s) const
{
    return (strcmp(m_str, s.m_str) >= 0);
}

bool String::operator >= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") <= 0);
}

bool String::operator <= (const String& s) const
{
    return (strcmp(m_str, s.m_str) <= 0);
}

bool String::operator <= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") <= 0);
}

String String::operator + (const String& s) const
{
    return (*this + s.m_str);   
}

String String::operator + (const char* s) const
{
    String ret;  // 定義一個兩個字符串拼接后結果的字符串對象；
    int len = m_length + strlen(s ? s : "");  // 三目運算符是為了防止 s 為空指針；
　　 char* str = reinterpret_cast<char*>(malloc(len + 1));  // 堆空間申請內存，並將 void* 重新解釋為 char*

    if( str )
    {
        strcpy(str, m_str);  // 當前對象的字符串拷貝到申請的堆空間中
        strcat(str, s ? s : "");  // 將要添加的字符串拼接到對象字符串后面

        free(ret.m_str);  // 這里歸還之前指針所指的內存；

        ret.m_str = str;  // 這里又重新賦值了指針；
        ret.m_length = len;
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to add String values");
　　 }

    return ret;
}

String& String::operator += (const String& s)
{
    return (*this = *this + s.m_str); //這里用到了賦值操作符，因此必須實現其重載；
}

String& String::operator += (const char* s)
{
    return (*this = *this + s);
}

String String::operator - (const String& s) const  // 字符串自身會被改變
{
    return String(*this).remove(s);  // 直接調用構造函數產生一個新的臨時字符串對象，值和當前字符串對象值相同，然后調用臨時對象的remove() 函數將子串刪除，最后將刪除結果返回，但是當前的字符串沒有被改變,因為是拷貝賦值
}

String String::operator - (const char* s) const  // 字符串自身會被改變
{
    return String(*this).remove(s);  // 同上
}

String& String::operator -= (const String& s) // 字符串自生不會被改變
{
    return remove(s);
}

String& String::operator -= (const char* s)
{
    return remove(s);
}

String& String::operator = (const String& s)
{
    return(*this = s.m_str);
}

String& String::operator = (const char* s)
{
    if( m_str != s )
    {
        char* str = strdup(s ? s : "");  // 復制一份字符串；

        if( str )  // 復制是否成功
        {
            free(m_str);
            m_str = str;
            m_length = strlen(m_str);
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to assign new String value...");
        }
　　 }

    return *this;
}

String& String::operator = (char c)
{
    char s[] = {c, '\0'};
    return (*this = s);
}

String::~String()
{
    free(m_str);
}

}

 

10，本節課字符串類測試代碼：

#include <iostream>
#include "DTString.h"

using namespace std;
using namespace DTLib;

void test_1()
{
    cout << "test_1() begin ..." << endl;
    String s;
　　 s = 'D';

    cout << s.str() << endl;
    cout << s.length() << endl;
    cout << (s == "D") << endl;
　　 cout << (s > "CCC") << endl;

　　 s += " Delphi Tang ";

    cout << s.str() << endl;
    cout << s.length() << endl;
    cout << (s == "D Delphi Tang ") << endl;
    cout << "test_1() end ..." << endl;
}

void test_2()
{
　　 cout << "test_2() begin ..." << endl;

    String a[] = {"E", "D", "C", "B", "A"};  // 字符串的比較遵循字典當中的順序。
　　 String min = a[0];

    for(int i=0; i<5; i++)
    {
        if( min > a[i] )
        {
            min = a[i];
        }
}

　　 cout << "min = " << min.str() << endl;

    cout << "test_2() end ..." << endl;
}

int main()
{
    test_1();
　　 test_2();

    return 0;
}

 

11，字符串類實現的實質是：

       1，使用面向對象的技術來對原來所使用過的 C 語言字符串相關函數進行合理封裝，方便開發；

       2，封裝達到的最終目的是代碼復用；

      

12，小結：

       1，C/C++ 語言本身不支持字符串類型；

       2，C 語言通過字符數組和一組函數支持字符串操作；

              1，不方便也不利於代碼復用

       3，C++ 通過自定義字符串類型支持字符串操作；

              1，通過面向對象的技術來封裝 C 語言中的函數，封裝后的結果是我們擁有一個完整的字符串類型，並且這個字符串類型在實際工程開發中非常方便；

       4，字符串類型通過 C 語言中的字符串函數實現；