string1.cpp

对8组包含不同个数据的向量进行排序

#include"string1.h"
#include<assert.h> 
char nothing;
#include<string.h>
//string 
string::string(){
	buflen=1;
	buffer=new char [buflen];
	assert(buffer!=0);
	buffer[0]='\0';
}
string::string(char a){
		buflen=2;
	buffer=new char [buflen];
	assert(buffer!=0);
	buffer[0]= a;
	buffer[1]='\0';
}
string::string(unsigned a){
	assert(a>=0);
	buflen=a+1;
	buffer=new char [buflen];
	assert(buffer!=0);
	for(unsigned i=0;i<buflen;i++)
	buffer[i]='\0';
}

string::string(const char*a){
	buflen=strlen(a)+1;		
	buffer=new char [buflen];
	assert(buffer!=0);
	for(unsigned i=0;a[i]!='\0';i++)
	buffer[i]=a[i];
	buffer[i]='\0';
}
string::string(const string&a){
	buflen=strlen(a.buffer)+1;		
	buffer=new char [buflen];
	assert(buffer!=0);
	for(unsigned i=0;a.buffer[i]!='\0';i++)
	buffer[i]=a.buffer[i];
	buffer[i]='\0';
}
string::~string(){
	delete[]buffer;
	buffer=0;
}
unsigned string::length()const{
	unsigned i=	strlen(buffer);		
     return i;
}

void string::operator=(const string &right){
	const unsigned rightLength=right.length();
	if(right.length()>=buflen){
		delete[]buffer;
		buflen=1+rightLength;
		buffer=new char[buflen];
		assert(buffer!=0);
	}
	for(unsigned i=0;right.buffer[i]!='\0';i++)
		buffer[i]=right.buffer [i];
	buffer [i]='\0';
}

void string::operator +=(const string&r ){
unsigned i;
unsigned conLen=length()+r.length ();
if(conLen>=buflen){
	char*newbuf=new char[1+conLen];
	assert(newbuf!=0);
	for(i=0;buffer[i]!='\0';i++)
		newbuf[i]=buffer[i];
	delete[]buffer;
	buflen=1+conLen;
	buffer=newbuf;
}
else
i=strlen(buffer);
for (unsigned j=0;r.buffer[i]!='\0';i++,j++)
buffer[i]=r.buffer [j];
buffer[i]='\0';
}
string operator +(const string &left,const string &right){
	string result(left);
	result+=right;
	return result;
}

substring string::operator ()(unsigned start ,unsigned len)  {
	if(start>=length()){
		start=0;
		len=0;
	}
	int maxLen=length()-start;
	if(len>maxLen)len=maxLen;
	return substring(*this,start,len);
}
istream&string::getline(istream&in){
	in.getline (buffer,buflen,'\n');
	return in;
}
char&string::operator [](unsigned index)const{
	if(index>=length()){
		nothing='\0';
		return nothing;
	}
	return buffer[index];
}
int string::compare(const string&str)const{
	char*p=buffer;
	char*q=str.buffer ;
	for(;(*p!='\0')&&(*p==*q);p++,q++)
		;
	return *p-*q;
}
			   
string::operator const char*()const{
	return buffer;
}
//substring
substring ::substring(string &str,unsigned s,unsigned l):base(str),start(s),len(l)
{
}
substring::substring(const substring &source):base(source.base),start(source.start),len(source.len)
{
}
void substring::operator=(const string&rstr)const
{
	unsigned i;
	if(len==rstr.length())
	{
		for(i=0;i<len;i++)
			base[start+i]=rstr[i];
		return;
	}
	unsigned newlen=rstr.length()+base.length()-len;
	char*newdata=new char[newlen+1];
	for(i=0;i<start;i++)
		newdata[i]=base[i];
	for(unsigned j=0;rstr[i]!='\0';j++)
		newdata[i++]=rstr[j];
	for(/*unsigned */j=start+len;base[j]!='\0';j++)
		newdata[i++]=base[j];
	newdata[i]='\0';
	delete[]base.buffer;
	base.buflen=newlen;
	base.buffer=newdata;
	return;
}
substring::operator string()const
{
	char*buf=new char[len+1];
	assert(buf!=0);
	for(unsigned i=0;i<len;i++)
		buf[i]=base[start+i];
	buf[len]='\0';
	string result(buf);
	delete[]buf;
	return result;
}
//stmacher
    stringMatcher:: stringMatcher(string&t)
		:text(t){
	pos=0;
}

 int stringMatcher::init(){
	pos=-1;
	return operator++();
}
	int stringMatcher::operator !()const{
	return (pos>=0)&&(pos<text.length());
}
	substring stringMatcher:: operator()(){
		return text(position(),length());
	}
	unsigned stringMatcher::position ()const{
		return pos;
	}
	void   stringMatcher::position (unsigned p){                      
		pos=p;
	}

		unsigned stringMatcher::length(){
			return patlen;
		}
//kmpstrmathcher
		     KMPStrMatcher::KMPStrMatcher( const string &p,string &t):stringMatcher(t),pattern(p)
{
patlen=p.length();
	assert(patlen>0);
prefix=new int[patlen];
assert(prefix!=0);
prefix[0]=0;
for(unsigned/*int*/ i=1;i<patlen;i++){
	unsigned/*int*/ k=prefix[i-1];
	while(pattern[i]!=pattern[k]&&k!=0)
		k=prefix[k-1];
	if(pattern[i]==pattern[k])
		prefix[i]=k+1;
	else
		prefix[i]=0;
}
}
int KMPStrMatcher::operator++()
{
unsigned/*int*/  end=text.length();
unsigned/*int*/  cur=pos+1;
unsigned/*int*/  patp=0;
	for(;cur<end;cur++)
	{
		while(patp>0&&pattern[patp]!=text[cur])
			patp=prefix[patp-1];
		if(pattern[patp]==text[cur])
			if(pattern[patp]==text[cur])
				if(++patp==patlen){
					pos=1+cur-patlen;
					return 1;
				}
				}
	pos=-1;
	return 0;
}
KMPStrMatcher::	~ KMPStrMatcher(){}