cstring.cpp

是一个用C++编写的图形编辑器！

// cstring.cpp: implementation of the cstring class.
//
//////////////////////////////////////////////////////////////////////

#include "cstring.h"

unsigned cstring::_pagesize = 1024;

cstring::cstring()
{
	_contents=new char[_pagesize];
	_contents[0]='\0';
	_length=0;
}

ostream& operator<<(ostream& output,cstring& s)
{
	output<<s._contents<<endl;
	return output;
}

istream& operator>>(istream& input,cstring& s)
{
	input>>s._contents;
	return input;
}

cstring::cstring(unsigned len)
{
	_contents=new char[_pagesize];
	_length=len;
	for(unsigned i=0;i<len;i++)
		_contents[i]='\0';
	_contents[len]='\0';
}

//系统自动生成的copy-constructor 
/*
cstring::cstring(const cstring& s)
{
	_length=s._length;
	_contents=s._length;
}
*/

//用户重载生成的copy-constructor
cstring::cstring(const cstring& s)
{
	_length=s._length;
	_contents=new char[_pagesize];
	strcpy(_contents,s._contents);
}

cstring::cstring(const char* str)
{
	_length=strlen(str);
	_contents=new char[_pagesize];
	strcpy(_contents,str);
}

cstring::cstring(const char c)
{
	_length=1;
	_contents=new char[_pagesize];
	_contents[0]=c;
	_contents[1]='\0';
}

cstring::cstring(const char* str,unsigned len)
{
	_length=len;
	_contents=new char[_pagesize];
	_contents[len]='\0';
	strncpy(_contents,str,len);
}

char& cstring::operator [](unsigned index)
{
	if(index <= _length)
		return _contents[index];
	else
		throw Error();
}

const char& cstring::operator [](unsigned index) const
{
	if(index <= _length)
		return _contents[index];
	else
		throw Error();
}


void cstring::SetAt(unsigned nIndex,char ch)
{
	_contents[nIndex]=ch;
    _length = nIndex;
	_contents[nIndex + 1] = '\0';
}

cstring& cstring::Replace(unsigned pos,unsigned len,const char* s)
{
	unsigned new_len=strlen(s);
	if(_length+new_len-len<_pagesize)
	{
		memmove(&(_contents[pos+new_len]),&(_contents[pos+len]),_length-pos-len);
		memmove(&(_contents[pos]),s,new_len);
	}
	else
	{
		char* t=new char[_pagesize];
		memmove(t,_contents,pos);
		memmove(&(t[pos]),s,new_len);
		memmove(&(t[pos+new_len]),&(_contents[pos+len]),_length-pos-len);
		delete _contents;
		_contents=t;
	}
	_length+=new_len-len;
	_contents[_length]='\0';
	return *this;
}


cstring& cstring::operator =(const cstring& s)
{
	_length=s._length;
	delete _contents;
	_contents=new char[_pagesize];
	strcpy(_contents,s._contents);
	return *this;
}


bool cstring::operator ==(const cstring& s)
{
	if(strcmp(s._contents,_contents)==0)
		return true;
	else
		return false;
}

cstring operator+(const cstring& s1,const cstring& s2)
{
	unsigned len=s1._length+s2._length;
	char* t=new char[len+1];
	strcpy(t,s1._contents);
	strcat(t,s2._contents);
	cstring s3(t);
	return s3;
}

cstring operator+(const cstring& s1,const char& ch)
{
	unsigned len=s1._length+1;
	char* t=new char[cstring::_pagesize];
	strcpy(t,s1._contents);
    t[len-1]=ch;
	t[len]='\0';
	cstring s3(t);
	return s3;
}

cstring operator+(const char& ch,const cstring& s2)
{
	unsigned len=s2._length+1;
	char* t=new char[cstring::_pagesize];
	t[0]=ch;
	strcpy(t+1,s2._contents);
	t[len]='\0';
	cstring s3(t);
	return s3;
}

cstring& cstring::operator+=(const cstring& s2)
{
	unsigned newlen=_length+s2._length;
	char *t=new char[_pagesize];
    memmove(t,_contents,_length);
	memmove(t+_length,s2._contents,s2._length);
	t[newlen]='\0';
	delete _contents;
	_contents=t;
	_length=newlen;
	return *this;
}

cstring& cstring::operator+=(const char& ch)
{
	unsigned newlen=_length+1;
	char *t=new char[_pagesize];
    memmove(t,_contents,_length);
    t[newlen-1]=ch;
	t[newlen]='\0';
	delete _contents;
	_contents=t;
	_length=newlen;
	return *this;
}

void cstring::Empty()
{
	delete _contents;
	_contents=new char[_pagesize];
	_contents[0]='\0';
	_length=0;
}

cstring cstring::Left(int ncount) const
{
	char *t=new char[ncount+1];
	memmove(t,_contents,ncount);
	t[ncount]='\0';
	return cstring(t);
}

cstring cstring::Right( int nCount ) const
{
	if(_length-nCount<=0)
		return *this;
	else{
		char *t=new char[nCount+1];
		memmove(t,_contents+_length-nCount,nCount);
		t[nCount]='\0';
		return cstring(t);
	}

}

cstring& cstring::Insert(unsigned nIndex,const char& ch)
{
	if(nIndex>0 && nIndex<=_length)
	{
		char* t=new char[_length+1];
		memmove(t,_contents,nIndex);
		t[nIndex]=ch;
		memmove(t+nIndex+1,_contents+nIndex,_length-nIndex);
		delete _contents;
		_contents=t;
		_length+=1;
	}
	return *this;
}

cstring& cstring::Insert(unsigned nBegin,const cstring& str)
{
	if(nBegin >= 0 && nBegin <= _length)
	{
		char* t=new char[_length + str._length + 1];
		memmove(t,_contents,nBegin);
		memmove(t + nBegin,str._contents,str._length);
		memmove(t + nBegin + str._length,_contents+nBegin,_length-nBegin);
		delete _contents;
		_contents = t;
		_length += str._length;
		_contents[_length]='\0';
	}
	return *this;
}


cstring& cstring::Delete(unsigned nIndex)
{
	if(nIndex >= 0 && nIndex < _length)
	{
		memmove(_contents+nIndex,_contents+nIndex + 1,_length-nIndex + 1);
		_length-=1;
		_contents[_length]='\0';
	}
	return *this;
}

cstring cstring::Delete(unsigned nBegin,unsigned nCount)
{
	if(nBegin >= 0 && nCount <= _length)
	{
		cstring temp(_length - nBegin - nCount);
		memmove(temp._contents,_contents+nBegin,nCount);
		memmove(_contents+nBegin,_contents+nBegin+nCount,_length - nBegin - nCount);
		_length-=nCount;
		_contents[_length]='\0';
		temp._contents[temp._length]='\0';
		return temp;
	}
	throw Error();	
}


int cstring::Find(const char& ch)
{
	for(unsigned i=0;i<_length;i++)
		if (_contents[i] == ch)
			return i;
	return -1;
}


int cstring::Find(unsigned  nNumber,char ch)
{
	if(nNumber ==0 )
		return 0;
	else if(nNumber > 0){
		unsigned nCount=0;
		char* pCurrent=_contents;
		while(*pCurrent){
			if(*pCurrent == ch ){
				nCount++;
				if(nCount == nNumber)
					return pCurrent-_contents+1;
			}
			pCurrent++;
		}
		return _length;

	}
	return -1;
}



cstring cstring::SubString(unsigned nBegin,unsigned nCount)
{
	if(nBegin>=0 && nBegin < _length){
		cstring m_strBuffer(nCount);
		memmove(m_strBuffer._contents,_contents+nBegin,nCount);
		m_strBuffer[nCount]='\0';
		return m_strBuffer;
	}
	else
		return cstring();
}