字符串类——KMP算法的应用

1，字符串类中的新功能（本文代码已集成到字符串类——字符串类的创建（上）中，这里讲述函数实现原理）：

 

      

2，子串查找（KMP 算法直接运用）：

       1，int indexOf(const char* s) const；

       2，int indexOf(const String& s) const;

       3，子串查找成员函数的声明：

    int indexOf(const char* ) const;

    int indexOf(const String& s) const;

　　4，子串查找成员函数的定义：

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);
}

3，在字符串中将指定的子串删除：

       1，String& remove(const char* s)；

       2，String& remove(const String& s);

              1，根据 kmp 在目标字符串中查找子串的位置；

              2，通过子串位置和子串长度进行删除；

　    3，删除指定字符串成员函数的声明：

     String& remove(int i, int len);

     String& remove(const char* s);

     String& remove(const String& s);

　　4，删除指定字符串成员函数的定义：

/* 删除下标 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,因为n是不断增加的，直到 m 为等于 length
        m_length = n;  // 不应该是 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());
}

             

4，字符串的减法操作定义（operator - ）：

       1，使用 remove 实现字符串间的减法操作；

              1，字符串自身不被修改；

              2，返回产生的新串；

 

　　2，减法操作符重载的声明：

    String operator - (const String& s) const;

    String operator - (const char* s) const;

    String& operator -= (const String& s); 

    String& operator -= (const char* s);

　　3，减法操作符重载的定义：

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);
}

5，字符串中的子串替换：

       1，String& replace(const char* t, const char* s)；

       2，String& replace(const String& t, const char* s)；

       3，String& replace(cosnt char* t, const String& s)；

       4，String& replace(const String& t, const String& s)；

　　5，子串替换成员函数的声明：

    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);

　　6，子串替换成员函数的定义：

/* 用 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);
}

6，从字符串中创建子串：

       1，String sub(int i, int len) const;

              1，以 i 为起点去长度为 len 的子串；

              2，子串提取不会改变字符串本身的状态；

 

　　2，从字符串中创建子串成员函数的声明：

    String sub(int i, int len) const; // 因为这里不会改变当前字符串状态，所以为 const 成员函数；

　　3，从字符串中创建子串成员函数的定义：

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;
}

7，本节课测试代码：

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

using namespace std;
using namespace DTLib;

int main()
{
    String s = "ababax";
　　 String s1 = s- "bax";

    cout << s.str() << endl;
15　　  cout << s1.str() << endl;

    s -= "ba";
　　 s -= s;

 　　cout << "[" << s.str() << "]" << endl;

    String s2 = "ababax";
　　 s2.replace("baba", "xyz");

　　 cout << s2.str() << endl;

    String s3 = "ababax";
　　 String s4 = s3.sub(3, 2);

　　 cout << s4.str() << endl;

    return 0;
}

             

8，小结：

       1，字符串类是工程开发中必不可少的组件；

       2，字符串中应该包含常用字符串操作函数：

              1，增：insert，operator +，...；

                     1，当前字符串增加；

              2，删：remove，operator -，...；

                     1，当前字符串删除；

              3，查: indexOf，...

                     1，当前字符串查找；

              4，改：replace，...

                     1，当前字符串更改；