string1.h

是一本教程的实例代码,可以下载后直接运行,即可以得到答案.

#include <iostream.h>
#include <string.h>

class String1                          //顺序串类
{
  private:
    char *table;                       //用字符数组存储串的数据元素
    int len;                           //表示串的实际长度

  public:
    String1(char *str="");             //以C＋＋字符串构造串对象
    String1(char ch);                  //以字符构造串对象
    String1(const String1 &s);         //以已知的串对象构造新的串对象
    ~String1();                        //析构函数

    int length();                      //返回串的长度
    char charAt(int i);                //返回第i个字符
    void output();                     //输出字符数组
    void concat(char *str);            //String1串对象连接一个C＋＋字符串
    void concat(const String1 &s2);    //连接两个String1串对象

    String1& operator=(char *str);
    String1& operator=(String1 &s1);
    friend ostream& operator<<(ostream& ostr,String1 &s); //输出String1串对象
    int operator==(char *str);         //重载运算符==，串对象与C＋＋字符串比较
    int operator==(String1 &s2);       //两个串对象比较
    String1& operator+=(String1 &s2);  //重载运算符＋=，连接串对象
    String1 operator+(String1 &s2);    //重载运算符＋，连接串对象

    String1 subString(int i,int n);    //返回串中从序号i开始的长度为n的子串
    String1 insert(int i,String1 &s2); //将s2插入到串第i位置处
    String1 remove(int i,int n);       //删除串中第i位置开始的长度为n的子串
    String1 reverse();                 //将串逆转

    int indexof(String1 &sub,int start=0);  //查找，即串的模式匹配算法
                                       //返回子串sub在主串中的序号
    int indexof(char ch,int start=0);  //返回字符ch在主串中的序号
    String1 replace(String1 &oldstr,String1 &newstr); 
                                       //替换，将串中oldstr子串全部替换成newstr子串
};

String1::String1(char *str)            //构造函数1，以C＋＋字符串构造串对象
{
    len=strlen(str);                   //len为串长
    table=new char[len+1];             //分配len+1个存储单元
    strcpy(table,str);                 //有串结束符\0
}

String1::String1(char ch)              //构造函数2，以字符构造串对象
{
    len=1;
    table=new char[len+1];
    table[0]=ch;
    table[1]='\0';                     //添加串结束符\0
}

String1::String1(const String1 &s)     //构造函数3，以已知的串对象构造新的串对象
{
    len=s.len;
    table=new char[len+1];
    strcpy(table,s.table);
}

String1::~String1()                    //析构函数
{
    delete[] table;
    len=0;
}

int String1::length()                  //求串的长度
{
    return len;
}

char String1::charAt(int i)            //返回第i个字符
{
    if(i>0 && i<=len)
        return table[i-1];
    else
        return -1;
}

void String1::output()                 //输出String1串对象
{
    cout<<"s.len="<<len<<"  ";         //输出串长度
    cout<<"s.table="<<table;           //输出字符数组
    if(table[len]==0)                  //显示字符串结束符
        cout<<'0';
    cout<<endl;
}

void String1::concat(char *str)        //String1串对象连接一个C＋＋字符串
{
    char *p=this->table;               //保留原串
    int n1=len,n2=strlen(str);
    len=n1+n2;
    table=new char[len+1];             //重新申请空间
    table=strcpy(table,p);             //串复制
    for(int i=0;i<n2;i++)              //添加另一串
        table[i+n1]=str[i];
    table[len]='\0';                   //添加串结束符
} 

void String1::concat(const String1 &s2)//连接两个String1串对象
{
    concat(s2.table);                  //this连接串对象s2的字符串
} 

String1& String1::operator=(char *str)
{
    len=strlen(str);
    table=new char[len+1];
    strcpy(table,str);
    return *this;
}

String1& String1::operator=(String1 &s1)
{
    delete []table;
    len=s1.length();
    table=new char[len+1];
    strcpy(table,s1.table);
    return *this;
}

ostream& operator<<(ostream& ostr,String1 &s) //输出String1串对象
{
    cout<<s.table;                     //输出字符数组
    return ostr;
}

int String1::operator==(char *str)     //重载运算符==，串对象与C＋＋字符串比较
{
    return(strcmp(table,str));
}

int String1::operator==(String1 &s2)   //重载运算符==，两个串对象比较
{
    return(strcmp(table,s2.table));
}

String1& String1::operator+=(String1 &s2)//重载运算符＋=，连接串对象
{                                      //*this+=s2
    String1 s1=*this;
    int n1=s1.length();
    int n2=s2.length();
    len=n1+n2;
    table=new char[len+1];
    strcpy(table,s1.table);            //复制原串*this
    for(int i=0;i<n2;i++)
        table[n1+i]=s2.table[i];       //添加串s2
    table[len]='\0';
    return *this;                      //改变了原串*this
}

String1 String1::operator+(String1 &s2)//重载运算符＋，连接串对象
{                                      //news1=*this+s2
    String1 news1=*this;               //复制原串*this
	news1+=s2;
    return news1;                      //返回新串，没改变原串*this
}


String1 String1::subString(int i,int n)//返回串中从序号i开始的长度为n的子串
{
//    cout<<"i="<<i<<"  n="<<n<<"  len="<<len<<endl;
    String1 sub;                       //默认参数时，创建空串
    if(i<=0)  i=1;
    if(i>len || n==0)
        return sub;                    //返回空串对象

    delete []sub.table;                //释放原有空间
    sub.len=n;
    if(n>len-i+1) 
        sub.len=len-i+1;

    sub.table=new char[sub.len+1];     //重新申请空间
    i--;
    for(int j=0;j<sub.len;j++)
        sub.table[j]=table[i+j];
    sub.table[sub.len]='\0';
    return sub;
} 

String1 String1::insert(int i,String1 &s2) //将s2插入到串第i位置处
{
    return subString(1,i-1)+s2+subString(i,len-i+1);
} 

String1 String1::remove(int i,int n)   //删除串中第i位置开始的长度为n的子串
{
    return subString(1,i-1)+subString(i+n,len-i-n+1);
} 

String1 String1::reverse()             //将串逆转
{
    String1 temp1;
    for(int i=len;i>=1;i--)
    {
        temp1+=subString(i,1);
    }
    return temp1;
} 

int String1::indexof(String1 &sub,int start) //串的模式匹配Brute-Force算法
{       //从第start个字符开始查找，返回子串sub在主串中的序号，匹配不成功时返回0
    int i=start,j=0;                   //i、j分别为s、t当前字符的下标
    while(i<length() && j<sub.length())
    {
//        cout<<"i="<<i<<"  j="<<j<<"  "<<table[i]<<"=="<<sub.table[j]<<"? "<<endl;
        if(table[i]==sub.table[j])
        {
            i++;                       //继续比较后续字符
            j++;
        }
        else
        {
            i=i-j+1;                   //回退
            j=0;
        }
    }
    if(j==sub.length())
        return i-sub.length()+1;       //返回序号(下标+1)
    else
        return 0;                      //匹配不成功时返回0
}
 
int String1::indexof(char ch,int start)//返回字符ch在主串中的序号
{
    String1 sub(ch);                   //创建串
    return this->indexof(sub,start);
}

String1 String1::replace(String1 &oldstr,String1 &newstr) 
{                                      //将串中oldstr子串全部替换成newstr子串
    int i=indexof(oldstr);             //返回匹配子串的序号
    String1 temp=*this;
    while(i!=0)
    {
        String1 sub1,sub2,sub3;
        int len=temp.length();                   //主串长度
        sub1=temp.subString(1,i-1);
        int n=oldstr.length();                   //模式串长度
        sub2=temp.subString(i,i+n-1);            //模式串
        sub3=temp.subString(i+n,len-i-n+1);
        temp=sub1+newstr+sub3;                   //串连接
        i=temp.indexof(oldstr);                  //再次查找匹配子串
    }
    return temp;
}