//header.h
#ifndef _HEADER_H
#define _HEADER_H
#define defaultSize 128
#include
#include
#include
using namespace std;
class myString
{
private:
char *ch;
int curLength;
int maxSize;
　　　　protected：

　　　　　　　　friend ostream& operator<<(ostream& out, myString& str) 　　　　　　　　{ 　　　　　　　　　　if(str.curLength>0 && str!=NULL) 　　　　　　　　　　　　cout<<str.ch<<endl; 　　　　　　　　　　else 　　　　　　　　　　　　cerr<<"error string object!\n"; 　　　　　　　　　　return out; 　　　　　　　　}
public:
myString(int sz=defaultSize);//三种构造方式
myString(const char *init);
myString(const myString& ob);
~myString(){delete []ch;}
void print();//打印字符串
int Length()const;
myString operator()(int pos, int len)；//字符串切片操作
bool operator == (myString& ob)const;//符号重载
bool operator != (myString& ob)const;
bool operator !()const;//判断字符串是否为空
myString& operator = (const myString& ob);//临时变量不能作为非const的引用参数
myString& operator +=(myString& ob);
char& operator[](int i);//返回字符串第i个位置的字符
int Find(myString &pat)const;//查子串，返回第一个子串起始位置，不存在返回-1
};
int myString::Find(myString &pat)const
{
if(pat.curLength > this->curLength)
return -1;
int i=0, j=0;
while(this->ch[i]!=pat.ch[0] && icurLength)//在母串匹配子串第一个字符
{
++i;
}

CIRCLE: while(this->ch[i]!=pat.ch[0] && icurLength)//在母串匹配子串第一个字符
{
++i;
}

if(i==this->curLength)//抵达母串最大长度还没找到。返回-1  
    return -1;  
else if(this->ch\[i\] == pat.ch\[0\])//找到了继续匹配  
{  
    ++i, j=1;  
    while(i<this->curLength && j<pat.curLength && this->ch\[i\]==pat.ch\[j\])  
    {  
        ++i;  
        ++j;  
    }  
    if(j == pat.curLength)//抵达子串最大长度，则说明子串在母串内，返回位置  
        return i-j+1;  
    else if(i < this->curLength)//没找到子串且母串未抵达最大位置，继续在母串匹配子串第一个字符  
        goto CIRCLE;  
    else　　　　　　　　　　　　//母串抵达最大位置且没找到子串，返回-1  
        return -1;  
}

}
char& myString::operator[](int i)
{
assert(i<=this->curLength&&i>0);
return this->ch[i-1];
}
myString& myString::operator+=(myString& ob)//这个函数直接strcat(this->ch, ob.ch)就可以成功拼接，但是若这样操作则无法知道字符串的最大长度
{
myString tmp(*this);
delete [] this->ch;
this->ch = new char[this->maxSize+ob.maxSize];
strcpy(this->ch, tmp.ch);
strcat(this->ch, ob.ch);
this->curLength += ob.curLength;
this->maxSize += ob.maxSize;
delete[] tmp.ch;
return *this;
}
bool myString::operator !()const
{
return this->curLength==0;
}
bool myString::operator != (myString& ob)const
{
return strcmp(this->ch, ob.ch) == 0 ? false : true;
}
bool myString::operator == (myString& ob)const
{
return strcmp(this->ch, ob.ch) == 0 ? true : false;
}
myString& myString::operator = (const myString& ob)
{
if(&ob!=this)
{
delete[]ch;

    this->ch = new char\[ob.maxSize\];  
    this->maxSize = ob.curLength;  
    strcpy(this->ch, ob.ch);  
    this->curLength = ob.curLength;  
}  
else  
{  
    cerr<<"String copy error\\n";  
}  
return \*this;  

}

myString myString::operator()(int pos, int len)
{
myString temp;
if(pos<0 || len<=0 || pos+len-1>=this->maxSize)
{
temp.curLength = 0;
temp.ch[0] = '\0';
}
else
{
if(pos+len-1 >= this->curLength)
len = this->curLength-pos;
temp.curLength = len;
for(int i=0,j=pos; ich[j];
temp.ch[len] = '\0';
}
return temp;
}

int myString::Length()const
{
return this->curLength;
}

void myString::print()
{
cout<ch<<endl;
}

myString::myString(int sz)
{
this->maxSize = sz;
this->ch = new char[this->maxSize+1];
if(this->ch == NULL)
{
cerr<<"Allocation ERROR\n"; exit(1); } this->curLength = 0;
ch[0] = '\0';
}

myString::myString(const char *init)
{
int len = strlen(init);
this->maxSize = (len > defaultSize) ? len : defaultSize;
this->ch = new char[this->maxSize+1];
if(this->ch == NULL)
{
cerr<<"Application Memory ERROR\n";
exit(1);
}

this->curLength = len;  
strcpy(this->ch, init);

}

myString::myString(const myString& ob)
{
this->maxSize = ob.maxSize;
this->ch = new char[this->maxSize+1];
if(this->ch == NULL)
{
cerr<<"Application Memory ERROR\n"; exit(1); } this->curLength = ob.curLength;
strcpy(this->ch, ob.ch);

}

#endif

#include"header.h"

int main()
{
myString st(10), st1("ABCDEFG");
myString st2(st1);
//st.print(), st1.print(), st2.print();
st = st1(0, 4);
cout<<"st = ";
st.print();
cout<<"st1 = ";
st1.print();
st += st1;
cout<<"st + st1 = ";
st.print();
char a = st[5];
cout<<a<<endl;
myString st3("EFGH");
cout<<st1.Find(st3)<<endl;
st3 = st3(0, 3);
cout<<st1.Find(st3)<<endl;
return 0;
}

在实现自定义字符串类的时候遇到两个问题，一个是=号重载时，参数必须为const才能正常赋值。

https://www.cnblogs.com/area-h-p/p/11498481.html

另一个就是模式匹配寻找子串。

我实现的寻找子串的方法只需将母串遍历一遍，即可得到子串位置。

具体操作就是先在母串找到子串的第一个字符，然后检查后面字符是否也同样相同，不同继续在母串后边找与子串第一个字符相同的字符，相同则继续循环匹配，直到抵达子串或母串最大长度，若抵达子串最大长度，即找到子串位置，若没有到母串最大长度，则继续在母串后边找与子串第一个字符相同的字符。以此循环。