字符串类——字符串类的创建（上）

1，历史遗留问题：

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

       2，C 语言用字符数组和一组函数实现字符串操作；

              1，字符数组模拟字符串；

              2，字符数组以 来结束就是合法字符串；

              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, ''};  // 用字符数组模拟字符串的初始化方式，这是两种初始化中的一种；
    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] != '') )  // 不为空和空字符串；
        {
            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] = '';  // 最后添加结束符
                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] = '';  // 最开始没有空格的时候；
        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] = '';  // 添加结束符
        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] = '';  //因为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] = '';
        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, ''};
    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 语言中的字符串函数实现；