串操作，C++实现

对串的基本操作都全已经实现

对kmp,kf字符串替换等功能全都已经实现

由于时间原因。没来得及注释，希望大家参考见谅。

串操作hstring.h头文件实现

 //kallen
 1 #ifndef _HSTRING_H_
#define _HSTRING_H_
#include <iostream>
class mString
{
public:
    mString();
    void newString(const char *ms);
    ~mString();
    bool isEmpty()const;          
    int  lengthString()const;     
    void copyString(const mString &src); 
    friend int compareString(const mString &lhs,const mString &rhs); 
    void clearStirng();  
    void concatString(const mString &lhs_src,const mString &rhs_src); 
    void subString(const mString &src,int pos,int len);      
    void insertString(int pos,const mString &ms); 
    void deleteString(int pos,int len);
    int  indexkfString(const mString &mt,int pos);
    int  indexkmpString(const mString &mt,int pos,int *next);                                           
    void replaceString(int repos,const mString& mt,const mString &mv,int *next);  
    
    void insaftposString(int pps,const mString& mt,const mString& mv);
    void printString()const;
private:
    char *base;
    int  length;
    void nextSt(const mString& mt,int *next);
};

#endif //_HSTRING_H_

hstring.cpp的实现代码

#include "hstring.h"

mString::mString()
{
    base = NULL;
    length = 0;
}

mString::~mString()
{
    if (base!=NULL)
    {
        delete base;
    }
    base = NULL;
}

void mString::newString(const char *ms)
{
    int i = 0;
    while(ms[i]!='')
    {
        ++i;
    }
    length = i;
    base = new char[length + 1];
    for (int j = 0;j<length;++j)
    {
        base[j] = ms[j];
    }
    base[length] = '';
}

bool mString::isEmpty()const
{
    if (0 == length)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int mString::lengthString()const
{
    return length;
}

void mString::copyString(const mString &src)  
{
    int i = 0;
    for (; i<this->length;++i)
    {
        base[i] = src.base[i];
    }
}

int compareString(const mString &lhs,const mString &rhs)
{
    int i = 0;
    while (lhs.base[i]!=''&&lhs.base[i]!='')
    {
        if (lhs.base[i] > rhs.base[i])
        {
            return 1;
        }
        else if (lhs.base[i] < rhs.base[i])
        {
            return -1;
        }
        else
        {
            ++i;
        }
    }
    if (lhs.base[i] ==''&&rhs.base[i]!='')
    {
        return -1;
    }
    else if (lhs.base[i] !=''&&rhs.base[i]=='')
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void mString::clearStirng()
{
    length = 0;
}

void mString::concatString(const mString &lhs_src,const mString &rhs_src)
{
    
    length = lhs_src.length + rhs_src.length;
    this->base = new char[length+1];
    
    for (int i = 0; i<lhs_src.length; ++i )
    {
        this->base[i] = lhs_src.base[i];
    }
    for (int i = lhs_src.length,j = 0; j < rhs_src.length; ++j,++i )
    {
        this->base[i] = rhs_src.base[j];
    }
    this->base[length] = '';

}

void mString::printString()const
{
    int i = 0;
    for (;i<length;++i)
    {
        std::cout<<base[i];
    }
    std::cout<<std::endl;
}

void mString::subString(const mString &src,int pos,int len)
{
    if (src.length != 0 )
    {
        if (pos>src.length)
        {
            std::cout<<"The  location of pos is illegal!"<<std::endl;
        }
        else
        {
            if (pos+len-1 <=src.length)
            {
                length = len;
                this->base = new char[length+1];
            
                for(int i = 0; i < length; ++i,++pos)
                {
                    this->base[i] = src.base[pos-1];
                }
            }
            else
            {
                length = src.length-pos+1;
                this->base = new char[length+1];
                int j = 0;
                for (;j<length;++j,++pos)
                {
                    this->base[j] = src.base[pos-1];
                }
                this->base[j] = '';
            }
        }

    }
    else
    {
        std::cout<<"The string is empty!"<<std::endl;
    }
}

void mString::deleteString(int pos,int len)
{
    if (0 == length)
    {
        std::cout<<"The string is empty!"<<std::endl;
    }
    else
    {
        if (pos>length)
        {
            std::cout<<"The location of pos is illegal!"<<std::endl;
        }
        else
        {
            if (pos+len-1>=length) //delete all char after pos,
                                   //but it don't move any char
            {
                int i = pos - 1;
                for (;i<length;++i)
                {
                    base[i] = '';
                }
            }
            else                   //pos+len-1<length,we have to move the char that
                                   //from pos+len to length 
            {
                int i = pos-1,j=pos+len-1,k=length-(pos+len)+1;
                for (;k>0;--k,++i,++j)
                {
                    base[i] = base[j];
                }
                for (int m = len,n = length;m>0;--n,--m)
                {
                    base[n-1] = '';
                }
            }
        }
        
    }
}

void mString::insertString(int pos,const mString &ms)//insert ms before pos
{
    if (0!=length&&0!=ms.length)
    {
        if (pos>length)
        {
            std::cout<<"The location of pos is illegal!"<<std::endl;
        }
        else
        {
            int len = ms.length,i = length-1,j=length+len-1,k = length-pos+1;
            int m = pos,n=0;
            base = (char *)realloc(base,(length+len)*sizeof(char));
            length = length+len;
            if (base==NULL)
            {
                std::cout<<"Create memory is failed!"<<std::endl;
            }
            for (;k>0;--k,--i,--j)
            {
                base[j] = base[i];
            }
            base[length]='';
            for (;n<len;++m,++n)
            {
                base[m-1] = ms.base[n];
            }
        }
    }
    else
    {
        std::cout<<"The string is empty!"<<std::endl;
    }
}

int  mString::indexkfString(const mString &mt,int pos)
{
    if (length != 0 &&mt.length!=0)
    {
        if (pos>length-mt.length+1)
        {
            std::cout<<"The location of pos is illegal!"<<std::endl;
            return 0;
        }
        else
        {
            int i = 1,j = pos;
            while(i<=mt.length&&j<=length)
            {
                if (mt.base[i-1]==base[j-1])
                {
                    ++i;
                    ++j;
                }
                else
                {
                    j = j-i+2;
                    i = 1;            //it's wrong if example : i = 1; j =j-i+2;
                    if (j>length-mt.length +1)
                    {
                        break;
                    }
                }
            }
            if (i > mt.length)
            {
                return (j-i+1);
            }
            else
            {
                return 0;
            }
        }
    }
    else
    {
        std::cout<<"The string is empty!"<<std::endl;
        return 0;
    }
}

int  mString::indexkmpString(const mString &mt,int pos,int *next)
{
    int i = pos,j = 0;
    nextSt(mt,next);
    while(j<mt.length&&i<=length)
    {
        if (j == -1||mt.base[j]==base[i-1])
        {
            ++i;
            ++j;           
        }
        else
        {
            j = next[j];         
        }    
    }
    if (j==mt.length)
    {
        std::cout<<i-j<<std::endl;
        return (i - j);
    }
    else
    {
        std::cout<<"nothing"<<std::endl;
        return 0;
    }
}

void mString::nextSt(const mString& mt,int *next)
{
    int i = 0,j = -1;
    next[0] = -1;
    while (i<mt.length)
    {
        if (j==-1||mt.base[i]==mt.base[j])
        {
            ++i;
            ++j;
            next[i] = j;      
        }
        else
        {
            j = next[j];
        }
    }
    //for (int i = 0;i<mt.length;++i)
    //{
        //std::cout<<next[i];
    //}
}

void mString::replaceString(int repos,const mString& mt,const mString &mv,int *next)
{
    if (length!=0)
    {
        int pos = repos;
        if (mt.length!=0&&mv.length!=0)
        {
            int pps = pos;
            while(pos!=0)
            {
                pos = indexkmpString(mt,pps,next);
                if (pos!=0)                              //when pos == 0,maybe execute copy in the head
                {                                        //example;a = "abcaabcacbc";mt = "bc";mv = "ff";
                    insaftposString(pos,mt,mv);          //but the result is; "fffaaffacff".
                }
                pps = pos+mv.length;            //from  pos+mv.length 
            }
        }
        else
        {
            std::cout<<"The string of mt or mv  is empty!"<<std::endl;
        }

    }
    else
    {
        std::cout<<"The main string is empty!"<<std::endl;
    }

}

void mString::insaftposString(int pps,const mString& mt,const mString& mv)
{
    if (mt.length<mv.length)
    {
        int n   = length - (pps+mt.length-1);       //the sum of movement
        int dis = mv.length - mt.length;
        int k   = length+dis-1;
        int j   = length-1;
        base = (char *)realloc(base,(length+dis)*sizeof(char));
        length = length+dis;
        if (base==NULL)
        {
            std::cout<<"Create memory is failed!"<<std::endl;
        }
        for (int i = 1;i<=n;++i,--k,--j)
        {
            base[k] = base[j];
        }
        base[length] = '';
        for (int i = 0,j=pps-1;i<mv.length;++i,++j)
        {
            base[j] = mv.base[i];
        }
    }
    else if (mt.length>mv.length)
    {
        int n = length - (pps+mt.length-1);
        int dis = mt.length-mv.length;
        int i = pps+mv.length-1;
        int j = pps+mt.length-1;
        for (int k = pps-1,l = 0;l<mv.length;++l,++k)
        {
            base[k] = mv.base[l];
        }
        for (int k=1;k<=n;++k,++i,++j)
        {
            base[i]=base[j];
        }
        for (int k=1,l = length-1;k<=dis;++k)
        {
            base[l] = '';
        }
        length = length-dis;
    }
    else
    {
        for (int i = 0;i<mv.length;++i,++pps)
        {
            base[pps-1] = mv.base[i];
        }
        printString();//inserts without thinks
    }

}

以上代码都经过正确测试

这里仅仅列出对kmp算法应用的测试。

#include "hstring.h"


int main(void)
{
    char d[100];
    char e[10];
    char f[10];
    std::cout<<"Please Enter a string!"<<std::endl;
    std::cin>>d;
    std::cout<<"Please Enter a string mt"<<std::endl;
    std::cin>>e;
    std::cout<<"Please Enter a string mt"<<std::endl;
    std::cin>>f;
    char *p1 = d; //= "abcaabcacbcabc";
    char *p2 = e;//"abc";
    char *p3 = f;//"ffff";
    int p[100];
    mString a,b,c;
    a.newString(p1);
    b.newString(p2);
    c.newString(p3);
    a.replaceString(1,b,c,p);
    //int p[88];
    //a.indexkmpString(b,1,p);
    //std::cout<<a.indexkfString(b,2);
    //a.insertString(4,b);
    //a.deleteString(1,4);
    //c.subString(a,2,3);
    a.printString();
    //c.concatString(a,b);
    //b.printString();
    //a.clearStirng();
    //std::cout<<a.isEmpty();
    //std::cout<<a.lengthString();
    //std::cout<<compareString(a,b);
     system("pause");
    return 0;
}

测试结果：

kmp字符串替换操作测试