这是一个简化了的版本，再粘一个没简化的

//
// string.cpp 　　TString类的具体实现
// lanjingquan  　　　　2002.4.22
///////////////////////////////////////////////

#include"string.h"

///////////////////////////////////////////////
//构造函数
//出于对时空的考虑　m_lSize一般不多分配空间,仅在
//有insert调用时才多分配10个空间. 用 m_lSize作参
//数保持与下面几个构造函数传参一致. 未位置空'\0'

TString::TString(long mLen) //仅定义长度
{
ASSERT(mLen);
m_lLen=0; //串中元素总数置零
m_lSize=mLen+1;

failRecord=NULL;
m_pRoom=new char[m_lSize];
ASSERT(m_pRoom);

for(long i=0;i<m_lSize;i++)
m_pRoom[i]='\0';
}

TString::TString(const char ch) //字符到类
{
m_lLen=1;
m_lSize=2;
failRecord=NULL;
m_pRoom=new char[m_lSize];
ASSERT(m_pRoom);

m_pRoom[0]=ch;
m_pRoom[1]='\0';
}

TString::TString(const char* pch)//字符串到类
{
m_lSize=strlen(pch)+1;
m_lLen=strlen(pch);
failRecord=NULL;
m_pRoom=new char[m_lSize];
ASSERT(m_pRoom);

long i=0;
while(pch[i])
m_pRoom[i]=pch[i++];

m_pRoom[i]='\0';
}

///////////////////////////////////////////////
//拷贝构造函数
TString::TString(const TString & s)
{
m_lLen=s.m_lLen;
m_lSize=s.m_lSize;
failRecord=NULL;
m_pRoom=new char[m_lSize];
ASSERT(m_pRoom);

long i=0;
while(s.m_pRoom[i])
m_pRoom[i]=s.m_pRoom[i++];

m_pRoom[i]='\0';
}

///////////////////////////////////////////////
//析构函数
TString::~TString()
{
delete[] m_pRoom; //无须判空
if(failRecord!=NULL) //须判空
delete[] failRecord;
}

///////////////////////////////////////////////
//返回s中序号为idx的字符
char TString::StrChar(long idx)
{
idx=idx>0?idx:m_lLen-idx;

idx=idx>m_lLen-1?m_lLen-1:idx; //大于m_lLen-1当m_lLen-1处理
idx=idx<0?0:idx; //小于0当0处理

return m_pRoom[idx];
}

///////////////////////////////////////////////
//maxNum表示最多复制的字符数目，省缺时表示全部
TString& TString::StrCopy(long maxNum)
{
ASSERT(maxNum);
maxNum=maxNum>m_lLen?m_lLen:maxNum;    //越界处理

TString* TStringNew=new TString(maxNum);//TStringNew->m_pRoom已全部置'\0'
for(long i=0;i<maxNum;i++)             //TStringNew->m_lSize已置maxNum+1
TStringNew->m_pRoom[i]=m_pRoom[i];
TStringNew->m_lLen=maxNum;

return *TStringNew;    //这里的指针是否会同下面相冲
}

///////////////////////////////////////////////
//比较两个TString前n个字符大小
//mode(比较/匹配模式):1:大小写敏感;-1:大小写不敏感
int TString::StrCompare(const TString& s1,long n,int mode)
{
ASSERT(n>0);
mode= mode>0?1:-1;

switch(mode)
{
case 1:
return memcmp(m_pRoom,s1.m_pRoom,n);  //调用string.h中函数实现
case -1:
return memicmp(m_pRoom,s1.m_pRoom,n); //同上
default:
return 1;
}
}

///////////////////////////////////////////////
//长度函数
long TString::StrLen()
{
return m_lLen;
}

///////////////////////////////////////////////
//连接函数
TString& TString::StrConcat(const TString& s1,long maxNum)   
{
ASSERT(maxNum>0);
maxNum=maxNum>s1.m_lLen?s1.m_lLen:maxNum;

if(m_lSize<m_lLen+maxNum+1)       //当前m_pRoom中没有足够的空间
{
long len=m_lLen;
m_lLen+=maxNum;
m_lSize=m_lLen+1;
char * reTemp=new char[m_lSize];
ASSERT(reTemp);

long i=0;
while(m_pRoom[i])                 //复制this
reTemp[i]=m_pRoom[i++];
while(i<m_lLen)
{   //复制s1
reTemp[i]=s1.m_pRoom[i-len];
i++;
}
reTemp[i]='\0';

delete[] m_pRoom;
m_pRoom=reTemp;
}
else  //当前m_pRoom中有足够的空间
{
long p=m_lLen;
while(p-m_lLen<maxNum)
{
m_pRoom[p]=s1.m_pRoom[p-m_lLen];
p++;
}

m_lLen+=maxNum;
m_lSize=m_lLen+1;
}

return *this;
}

///////////////////////////////////////////////
//字符位置函数
long TString::StrCharAt(char ch,int mode,long sn)      
{
ASSERT(sn);
long times=0,i=0;

if(sn>0)
{
for(i=0;i<m_lLen;i++)
if(twoCharCmp(m_pRoom[i],ch,mode)==0&&(++times==sn))
     return i;
}
else
for(i=m_lLen-1;i>=0;i--)
if(twoCharCmp(m_pRoom[i],ch,mode)==0&&(++times==-sn))
      return i;

return -1;        //查找失败
}

///////////////////////////////////////////////
//子串位置函数
long TString::StrStr(TString& s1,int mode,long sn)     
{
return StrSearch(s1,mode,1,sn);
}

///////////////////////////////////////////////
//搜索子串函数,用KMP算法来实现
//sn1和sn2的正负同查找方向相关
long TString::StrSearch(TString& s1,int mode,long sn1,long sn2)            
{
ASSERT(sn1);              //sn1非零断言

if(sn1*sn2>0)                        //对sn1,sn2符号相同的处理
{
long currT1=sn1>0?sn1:1;
long length1=sn1>0?m_lLen:m_lLen+sn1+1;    //进行扫描串长度
sn2=sn2>0?sn2:-sn2;

fail(s1,mode);        //产生失效数组,下同
return find(s1,mode,currT1,length1,sn2);   //用find来分散一下
}
else                                           //对sn1,sn2符号不相同的处理
{
long currT2=sn1>0?1:m_lLen+sn1-1;
long length2=sn1>0?m_lLen-sn1:m_lLen;//进行扫描串长度
sn2=sn2>0?sn2:-sn2;

backspin(s1);    //将两串倒置
backspin(*this);

fail(s1,mode);
long temp=m_lLen-2-find(s1,mode,currT2,length2,sn2);
backspin(s1);    //将两串复原
backspin(*this);

return temp;
}
}

///////////////////////////////////////////////
//求子串函数,num可以为负,sn出界越界做首尾处理
//num不能出越界,不影响母串
TString& TString::StrSub(long sn,long num)             
{
ASSERT(sn);
sn=abs(sn)>m_lLen?sn/abs(sn)*m_lLen:sn;//越界处理

long length=num>0?num:-num;
long currNew=0;
TString* TStringNew;

if(length==0)                               //复制整个串
{
long sta=sn>0?sn-1:0;             //设定起点
length=sn>0?m_lLen-sta:m_lLen+sn+1;
TStringNew=new TString(length);

while(currNew<TStringNew->m_lSize-1)
TStringNew->m_pRoom[currNew++]=m_pRoom[sta++];

TStringNew->m_pRoom[currNew]='\0';
TStringNew->m_lLen=length;
}
else
{
long sta=sn>0?sn-1:m_lLen+sn;

if(sn>0) ASSERT((sta+length-1)<m_lLen);
else ASSERT((sta-length+1)>=0); //越界断言
TStringNew=new TString(length);
sta=num>0?sta:sta+num+1; //重定起点

while(currNew<TStringNew->m_lSize-1)
TStringNew->m_pRoom[currNew++]=m_pRoom[sta++];

TStringNew->m_pRoom[currNew]='\0';
TStringNew->m_lLen=length;
}
return *TStringNew;
}

///////////////////////////////////////////////
//子串替换函数
long TString::StrReplace(TString& s1,TString& s2,int mode,long sn,long num)   
{
ASSERT(num);
long idx=sn;
long times=0,sum=0;

while(abs(times)<abs(num))
{
idx=StrSearch(s1,mode,idx,num/abs(num));
if(idx!=-1)
{
StrDelete(idx+1,s1.m_lLen);     //删除s1
StrInsert(s2,idx+1);            //插入s2
sum++;
}
else if(idx==-1&&times!=0)
break;

if(num>0)         //设置查找方向
{
times++;
idx+=s2.m_lLen;
}
else
{
times--;
idx--;
}
}

return sum;
}

///////////////////////////////////////////////
//插入函数
TString& TString::StrInsert(TString& s1,long sn)       
{
ASSERT(sn);
sn=sn<-m_lLen?-m_lLen:sn;    //左越界处理
sn=sn>m_lLen?m_lLen+1:sn;    //右越界处理

sn=sn>0?sn-1:m_lLen+sn;
if(m_lSize<m_lLen+s1.m_lLen+1)
{
m_lSize+=s1.m_lLen+10;                 //每次分配多10个空间
char* charNew=new char[m_lSize];
long curr=0,curr2=0;

while(curr<sn)
charNew[curr]=m_pRoom[curr++]; //前

while(curr<sn+s1.m_lLen)
charNew[curr++]=s1.m_pRoom[curr2++];//插入

curr2=sn;
while(curr<m_lLen+s1.m_lLen)
charNew[curr++]=m_pRoom[curr2++];   //后

while(curr<m_lSize)
charNew[curr++]='\0';               //置空

delete[] m_pRoom;
m_pRoom=charNew;
}
else
{
long curr=m_lLen-1,curr2=0;
while(curr>=sn)
m_pRoom[curr+s1.m_lLen]=m_pRoom[curr--];//后移

curr=sn;
while(curr<sn+s1.m_lLen)
m_pRoom[curr++]=s1.m_pRoom[curr2++]; //插入
}

m_lLen+=s1.m_lLen;
return *this;
}

///////////////////////////////////////////////
//删除函数
TString& TString::StrDelete(long sn,long num)           
{
ASSERT(sn);
sn=sn<-m_lLen?-m_lLen:sn;     //左越界处理
sn=sn>m_lLen?m_lLen:sn;     //右越界处理

sn=sn>0?sn-1:m_lLen+sn;
long currP=sn; //删除子串的首下标
long currB=sn+num;      //删除子串后原串首下标

if(num>0)
currB= currB<m_lLen?currB:m_lLen;
else  
{
currB= currB>0?currB:-1;

long currTemp=currB; //重定位
currB=currP+1;
currP=currTemp+1;
}

while(m_pRoom[currB])
m_pRoom[currP++]=m_pRoom[currB++];   //移位

while(m_pRoom[currP])  //置零
{
m_pRoom[currP++]='\0';
m_lLen--;
}

return *this;
}

///////////////////////////////////////////////
//删除s中打头空格，返回s
TString& TString::StrTrimL()                           
{
long idx=0;
while(m_pRoom[idx]==' ')
idx++;
StrDelete(1,idx);
return *this;
}

///////////////////////////////////////////////
//删除s中尾随空格，返回s
TString& TString::StrTrimR()    
{
long idx=m_lLen-1;
while(m_pRoom[idx]==' ')
idx--;
StrDelete(m_lLen,idx-m_lLen+1);
return *this;
}

///////////////////////////////////////////////
//删除s中打头和尾随空格，返回s
TString& TString::StrTrimLR()                          
{
StrTrimL();
StrTrimR();
return *this;
}

///////////////////////////////////////////////
//删除s中所有空格，返回s
TString& TString::StrTrimAll()                         
{
long idx=0;
while(idx<m_lLen)
if(m_pRoom[idx]==' ')
StrDelete(idx+1,1);
else
idx++;

return *this;
}

///////////////////////////////////////////////
//逆置串
TString& TString::StrBackspin()
{
return backspin(*this);
}

///////////////////////////////////////////////
//转化为大写
TString& TString::ToUpper()                            
{
int i=0;
while(m_pRoom[i])
{
if(isLowerCase(m_pRoom[i]))
m_pRoom[i]=(m_pRoom[i]-'a')+'A';
i++;
}

return *this;
}

///////////////////////////////////////////////
//转化为小写
TString& TString::ToLower()                            
{
int i=0;
while(m_pRoom[i])
{
if(!isLowerCase(m_pRoom[i]))
m_pRoom[i]=(m_pRoom[i]-'A')+'a';
i++;
}

return *this;
}

///////////////////////////////////////////////
//转化为整数,也可用stdlib.h中的atoi(char*)实现
long TString::ToInteger()                              
{
long idx=0;
long num=0;

while(idx<m_lLen)
{
if(isNumber(m_pRoom[idx])==0)
ASSERT(0); //非数字则断言
else
num+=changeToNum(m_pRoom[idx])*long(pow(10,m_lLen-idx-1));

idx++;
}
return num;
}

///////////////////////////////////////////////
//转化为浮点数
double TString::ToFloat()                              
{
for(long i=0;m_pRoom[i];i++)
if(m_pRoom[i]!='.'&&!isNumber(m_pRoom[i]))
ASSERT(0);

return atof(m_pRoom);
}

///////////////////////////////////////////////
//将number所表示的数值转化为字符串，作为s的新值
TString& TString::ToString(double number,long wd,long dec)            
{
delete[] m_pRoom;

m_lSize=wd+5;
m_pRoom=new char[m_lSize];    
gcvt(number,wd,m_pRoom);    
m_lLen=strlen(m_pRoom);

long i=0,idx=0;
while(m_pRoom[i])
if(m_pRoom[i++]=='.')
idx=i;

if(idx!=0&&m_lLen-idx>dec)
{
i=idx+dec;
while(m_pRoom[i])
m_pRoom[i++]='0';
}

return *this;
}

///////////////////////////////////////////////
//取子串
TString& TString::operator ()(long pos,long len)
{
return StrSub(pos,len);
}

///////////////////////////////////////////////
//相等比较
int TString::operator ==(const TString& ob)
{
long length=ob.m_lLen>m_lLen?m_lLen:ob.m_lLen;
if(StrCompare(ob,length)==0&&ob.m_lLen==m_lLen)
return 1;
else
return 0;
}

///////////////////////////////////////////////
//不等比较
int TString::operator !=(const TString& ob)
{
long length=ob.m_lLen>m_lLen?m_lLen:ob.m_lLen;
if(StrCompare(ob,length)==0&&ob.m_lLen==m_lLen)
return 0;
else
return 1;
}

///////////////////////////////////////////////
//求非
int TString::operator !()const
{
return m_lLen!=0;
}

///////////////////////////////////////////////
//赋值
TString& TString::operator =(const TString& ob)
{
StrDelete();
return StrConcat(ob);
}

///////////////////////////////////////////////
//连接
TString& TString::operator +=(const TString& ob)
{
return StrConcat(ob);
}

///////////////////////////////////////////////
//取字符
char TString::operator [](int idx)
{
return StrChar(idx);
}

//////////////////////////////////////////////
//转化成普通字符串
TString::operator const char *()
{
return m_pRoom;
}

/////////////////////////////////////////////
//输入
istream & operator >>(istream& in,TString & str)
{
str.StrDelete();
char c=getche();
while(c!='\r')
{
str+=TString(c);
c=getche();
}

cout<<endl;
return in;
}

/////////////////////////////////////////////
//输出
ostream & operator <<(ostream & out,TString & str)
{
long i=0;
while(str.m_pRoom[i])
out<<str.m_pRoom[i++];

return out;
}
///////////////////////////////////////////////
//判断大小写,s必须为字母
bool TString::isLowerCase(char s)
{
return ((s>='a')&&(s<='z'));
}

///////////////////////////////////////////////
//带mode比较两字符
int TString::twoCharCmp(char s,char d,int mode)
{
mode=mode>=0?1:-1;

switch(mode)
{
case 1:
return (s-d);
case -1:
return (tolower(s)-tolower(d));
}
return 1;
}

///////////////////////////////////////////////
//失效函数
void TString::fail(TString& s,int mode)
{
if(failRecord!=NULL)
delete[] failRecord;
failRecord=new int[s.m_lLen];

failRecord[0]=-1;
long i;

for(long j=1;j<s.m_lLen;j++)
{
i=failRecord[j-1];

while(twoCharCmp(s.m_pRoom[j],s.m_pRoom[i+1],mode)!=0&&i>=0)
i=failRecord[i];

if(twoCharCmp(s.m_pRoom[j],s.m_pRoom[i+1],mode)==0)
failRecord[j]=i+1;
else
failRecord[j]=-1;
}
}

///////////////////////////////////////////////
//find的辅助函数,只能正向查找
long TString::find(TString& s1,int mode,long sn1,long length,long sn2)
{
int times=0;
long currT=sn1-1;
long currP=0;

while(currT<length)
{
while(currT<length&&currP<s1.m_lLen)
if(twoCharCmp(s1.m_pRoom[currP],m_pRoom[currT],mode)==0)
{ //两字符相等
currT++;
currP++;
}
else if(currP==0) currT++;
else currP=failRecord[currP-1]+1;   

if(currP>=s1.m_lLen)  
{
currP=0;
if(++times==sn2)
return currT-s1.m_lLen;
}
}
return -1;
}

///////////////////////////////////////////////
//逆置串,改变ops并返回
TString& TString::backspin(TString& ops)
{
long len=ops.m_lLen-1;
int flag=len%2==0?0:1;
long i=0;
char temp='\0';

while((len-i)!=flag)
{
temp=ops.m_pRoom[len];
ops.m_pRoom[len]=ops.m_pRoom[i];
ops.m_pRoom[i]=temp;
i++;
len--;
}
temp=ops.m_pRoom[len];
ops.m_pRoom[len]=ops.m_pRoom[i];
ops.m_pRoom[i]=temp;

return ops;
}

//////////////////////////////////////////////
//s为数字或非数字
bool TString::isNumber(char s)
{
return (s>='0'&&s<'9');
}

//////////////////////////////////////////////
//转化成数字
int TString::changeToNum(char s)
{
if(isNumber(s))
return (s-48);

return-1;
}

cstring.ｈ就不粘出来了，呵呵

大哥，你给我们下马威啊