字符串类——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( ( <= 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,因为n是不断增加的，直到 m 为等于 length
         m_length = n;  // 不应该是 m_length - n 吗？
 }

     return *this;
 }

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

 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 >=  ) // 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( ( <= i) && (i < m_length) )
     {
         if( len <  ) len = ; // 当小于零时候，不可能，要归一化到 0
         if(len+i > m_length) len = m_length - i; // 只能够提取这么长的长度

         char* str = reinterpret_cast<char*>(malloc(len + ));

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

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

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

     return ;
 }

8，小结：

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

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

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

1，当前字符串增加；

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

1，当前字符串删除；

3，查: indexOf，...

1，当前字符串查找；

4，改：replace，...

1，当前字符串更改；