string.h

班级通讯录c++编写

#include<assert.h>
#include<iostream.h>

#define EndOfStr '\0'
class SimpleStrMatcher;
class substring;
class stringMatcher;
unsigned cstrLen(const char str[])
{
	unsigned i=0;
	while(str[i]!=EndOfStr)
		i++;
	return i;
}

class string
{
private:
	unsigned buflen;
	char * buffer;
public:
	string();
	string(char);
	string(unsigned);
	string(const char *);
	string(const string &);

	~string();

	friend class substring;
	friend class stringMatcher;
//	friend class SimpleStrMatcher;
	substring operator()(unsigned start,unsigned len);

	void operator=(const string & right);
	void operator+=(const string & right);

	istream & getline(istream &);
	unsigned length() const;
	char & operator[](unsigned & index);
	int compare(const string &) const;
	operator const char *() const;

	char & index(unsigned i);//added function...

	friend ostream & operator<<(ostream & out,const string & str);
	friend istream & operator>>(istream & in,string & str);
	
	friend string operator+(const string &,const string &);
	friend bool operator==(const string &,const substring &);
};




class substring
{
private:
	string & base;
	const unsigned start;
	const unsigned len;
public:
	substring(string & base,unsigned start,unsigned len);
	substring(const substring & source);
   // friend class stringMatcher;
	void operator=(const string &) const;
	operator string() const;
};
/******
class stringMatcher
{
protected:
	string & text;
	int pos;
	unsigned patlen;
public:
	stringMatcher(string & t);
	virtual int init();
	int operator!() const;
	virtual int operator++();
	substring operator()();
	
	unsigned position() const;
	void position(unsigned p);
	unsigned length();
};
class SimpleStrMatcher:public stringMatcher
{
private:
	const string & pattern;
public:
	SimpleStrMatcher(const string & pat,string & text);
	virtual int operator ++();
};
***/
char none;
char & string::index(unsigned i)
{
	if(i>=length())
	{
		none=EndOfStr;
		return none;
	}
	return buffer[i];
}

string::string()
{
	buflen=1;
	buffer=new char[buflen];
	assert(buffer!=0);
	buffer[0]=EndOfStr;
}
string::string(char c)
{
	buflen=2;
	buffer=new char[buflen];
	assert(buffer!=0);
	buffer[0]=c;
	buffer[1]=EndOfStr;
}
string::string(unsigned size)
{
	assert(size>=0);

	buflen=size+1;
	buffer=new char[buflen];
	assert(buffer!=0);

	for(unsigned i=0;i<buflen;i++)
		buffer[i]=EndOfStr;
}
string::string(const char * inittext)
{
	buflen=1+cstrLen(inittext);
	buffer=new char[buflen];
	assert(buffer!=0);

	for(unsigned i=0;inittext[i]!=EndOfStr;i++)
		buffer[i]=inittext[i];
	buffer[i]=EndOfStr;
}
string::string(const string & initstr)
{
	buflen=1+initstr.length();//i have changed ...
	buffer=new char[buflen];
	assert(buffer!=0);

	for(unsigned i=0;i<initstr.length();i++)//i have changed ...
		buffer[i]=initstr.buffer[i];
	buffer[i]=EndOfStr;
}
string::~string()
{
	delete [] buffer;
	buffer=0;
}
void string::operator =(const string & right)
{
	const unsigned rightLength=right.length();

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

	unsigned conLen=length()+v.length();
	if(conLen>=buflen)
	{
		char * newbuf=new char[1+conLen];
		assert(newbuf!=0);

		for(i=0;buffer[i]!=EndOfStr;i++)
			newbuf[i]=buffer[i];
		
		delete [] buffer;
		buflen=1+conLen;
		buffer=newbuf;
	}
	else
		i=cstrLen(buffer);

	for(unsigned j=0;v.buffer[j]!=EndOfStr;i++,j++)
		buffer[i]=v.buffer[j];
	buffer[i]=EndOfStr;
}
istream & string::getline(istream & in)
{
	in.getline(buffer,buflen,EndOfStr);
	return in;
}
unsigned string::length() const
{
	return cstrLen(buffer);
}
char nothing;
char & string::operator [](unsigned & index)
{
	if(index>=length())//i have changed ...
	{
		nothing=EndOfStr;
		return nothing;
	}
	return this->buffer[index];
}
int string::compare(const string & val) const
{
	char * p=buffer;
	char * q=val.buffer;
	
	for(;(*p!=EndOfStr)&&(*p!=*q);p++,q++)
		;
	return *p-*q;
}
string::operator const char *() const//？？？？？？？？？？？？？？？？？？
{
	return buffer;
}
istream & operator>>(istream & in,string & str)
{
	char inbuffer[1000];
	if(in>>inbuffer)
		str=inbuffer;
	else
		str="";
	return in;
}
ostream & operator <<(ostream & out,const string & str)
{
	out<<str.operator const char *();
	return out;
}
string operator+(const string & left,const string & right)
{
	string result(left);
	result+=right;
	return result;
}
bool operator ==(const string & str,const substring & sub)
{
	return str.buffer==sub.operator string();
}
	
substring string::operator ()(unsigned start,unsigned len)
{
	if(start>=length())
	{
		start=0;
		len=0;
	}
	unsigned maxlen=length()-start;
	if(len>maxlen)
		len=maxlen;
	return substring(*this,start,len);
}
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.index(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[j]!=EndOfStr;j++)
		newdata[i++]=rstr[j];
	for(j=start+len;base[j]!=EndOfStr;j++)
		newdata[i++]=base[j];
	newdata[i]=EndOfStr;

	delete [] base.buffer;
	base.buflen=newlen;
	base.buffer=newdata;
	return;
}
substring::operator string() const
{
	//把string 从start 开始的len 长度的
	//一段substring 转化为string 
	char * buf=new char[len+1];
	assert(buf!=0);

	for(unsigned i=0;i<len;i++)
		buf[i]=base[start+i];
	buf[len]=EndOfStr;

	string result(buf);
	delete [] buf;
	return result;
}
/*
class stringMatcher{
public:
	stringMatcher(string &t);
	virtual int init();
	int operator!()const;
	virtual int operator++();
	substring operator()();

	unsigned position()const;
	void position(unsigned p);
	unsigned length();
protected:
	string &text;
	int pos;
	unsigned patlen;
};

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


//SipleStrmatcher
class SimpleStrMatcher:public stringMatcher
{
public:
	SimpleStrMatcher(const string &p,string &t);
	virtual int operator++();
private:
	const string &pattern;
};


SimpleStrMatcher::SimpleStrMatcher(const string &p,string &t):stringMatcher(t),pattern(p){patlen=p.length();}

int SimpleStrMatcher::operator ++()
{
	int last=text.length()-patlen;
	for(pos++;pos<=last;pos++)
	{
		if(pattern==text(pos,patlen))
			return 1;
	}
	pos=-1;
	return 0;
}*/