tstring.h

CRegistry注册表

#ifndef _tstring_H
#define _tstring_H

#include <stdarg.h>
#include <stdlib.h>

//转换成大写
#define TOUPPER(c) ((((c) >= 'a') && ((c) <= 'z')) ? (c)+'A'-'a' : (c))

class tstring 
{
public:
	char *m_buff;
	size_t m_nLength;	//字符长度	
	size_t m_nBuffer;	//内存空间数
public:
	tstring()
	{
		m_nBuffer=m_nLength=0;
		m_buff=NULL;
	}
	tstring(const char *str)
	{
		if(str==NULL)tstring();
		Set(str,strlen(str));
	}
	tstring(const char *str,int len)
	{
		Set(str,len);
	}
	~tstring(void) { if(m_buff)free(m_buff) ;}

	void  Set(const char *str, size_t len )
	{
		if(str==NULL)len=0;
		m_nBuffer=m_nLength=0;
		m_buff=NULL;
		EnsureBuffer(len);
		size_t sl=strlen(str);
		if(len>sl)len=sl;
		if(len)
		{
			strncpy(m_buff, str,len);
			m_buff[len]=0;
		}
		m_nLength=len;
	}

	void Empty(){ if(m_buff) memset(m_buff,0,m_nBuffer);m_nLength=0;}

	void TrimRight();
	void TrimLeft();

	void Insert(size_t pos,const char *str);
	int Delete(int nIndex, int nCount = 1);
	
	char* GetBuffer(size_t size=-1)
	{
		if(size!=-1 && m_nBuffer<size)
		{
			m_buff=(char *)realloc(m_buff,size*sizeof(char));
			memset(m_buff+m_nLength,0,size-m_nLength);
			m_nBuffer=size;
		}
		return m_buff;
	}
	void ReleaseBuffer()
	{
		m_nLength=strlen(m_buff);
	}
	//查询函数
	bool IsEmpty() {return m_nLength==0;}
	size_t GetLength(void) {return m_nLength;}      // return tstring size
	//size_t Find(const char *str);
	size_t Find(const char *str)const
	{
		char *s1=m_buff;
		int i=0;
		for(size_t i=0;i<m_nLength;i++)
		{
			if (s1[i] == *str)
			{
				const char *c1 = &s1[i];
				const char *c2 = str;

				while (*c1 && *c2)
				{
					if (*c1 != *c2)
						break;
					c1++;
					c2++;
				}
				if (*c2==0)
					return i;
			}
		}
		return -1;
	}
	//找不到就返回(unsigned int)-1
	size_t FindNoCase(const char *str)
	{
		for(size_t i=0;i<(m_nLength);i++)
		{
			if (TOUPPER(m_buff[i]) == TOUPPER(*str))
			{
				const char *c1 = m_buff+i;
				const char *c2 = str;

				while (*c1 && *c2)
				{
					if (TOUPPER(*c1) != TOUPPER(*c2))
						break;
					c1++;
					c2++;
				}
				if (*c2==0)
					return i;
			}
		}
		return -1;
	}
	int ReverseFind(char c)
	{
		char *s;
		s=m_buff;
		int i,j;
		for(i=0,j=0;*s;i++)
		{
			if (*s++ == c)
				j = i;
		}
		return j;
	}
	int ReverseFind(const char *str)
	{
		char *s;
		s=m_buff;
		int i,j;
		for(i=0,j=0;*s;i++,s++)
		{
			if(strstr(s,str))
				j = i;
		}
		return j;
	}
	char GetAt(size_t pos){ 
		if(pos<=m_nLength)return m_buff[pos];
		else return NULL;
	}
	char operator[](int nIndex) const
	{
		return m_buff[nIndex];
	}
	void SetAt(size_t pos,const char c)
	{
		if(pos>m_nBuffer)return;
		else
			m_buff[pos]=c;
	}
	tstring Left(int nCount) const
	{
		return Mid(0,nCount);
	}
	tstring Right(int nCount) const;
	tstring Mid(int nFirst, int nCount) const
	{
		tstring result;

		for(int i = nFirst; i < m_nLength && (i - nFirst) < nCount; i ++)
		{
			result += m_buff[i];
		}

		return result;
	}
	tstring Mid(int nFirst) const;

	void MakeUpper();
	void MakeLower();
	void MakeReverse();

	int CompareNoCase(const char* lpsz) const;
	
	//格式化
	void Format(LPCSTR formatstring, ...)
	{
		char buff[4096];
		va_list args;
		va_start(args, formatstring);

		Empty();
	#ifdef WIN32
			int	len = _vsnprintf(buff, sizeof(buff) - 1, formatstring, args)+1;
	#else
			int len = vsnprintf(buff, sizeof(buff) - 1, formatstring, args)+1;
	#endif
		va_end(args);
		
		EnsureBuffer(len);

		va_start(args,formatstring);
		_vsnprintf( m_buff,m_nBuffer, formatstring, args);
		va_end(args);
	}

	//操作符重载
	const tstring& operator=(char ch)
	{
		char str[2] = { ch, 0};
	
		Set((const char*)str,strlen(str));	
		return *this;
	}
	const tstring& operator=(const char * str)
	{
		if(str==NULL)return tstring("");
		Set(str,strlen(str));
		return *this;
	}
	const tstring& operator=(const tstring &obj)
	{
		*this=(const char *)obj;
		return *this;
	}	

	const tstring& operator+=(const char *lpsz)
	{
		if(lpsz)
		{
			int nSize = strlen(lpsz) + m_nLength;
			EnsureBuffer( nSize );
			
			strcpy(m_buff + m_nLength, lpsz);
			m_nLength = nSize;
		}

		return *this;
	}
	const tstring& operator+=(char ch)
	{
		char str[2] = {ch, 0};
		return operator+=((const char*)str);
	}
	const tstring& operator+=(const tstring& string);


	operator const char*() const
	{
		if(m_buff)
			return (const char*)m_buff;
		else
			return "";
	}

	tstring operator-(tstring &obj);       // subtract a String object
	tstring operator-(char *s);            // subtract a quoted string

	bool operator==(const char *s)
	{
		return _tcscmp(m_buff,s)==0;
	}
protected:
	void EnsureBuffer(size_t nLength)
	{
		if ( m_nBuffer - m_nLength > nLength ) return; 

		int nSize= m_nLength + nLength+1;

		if(m_buff)
			m_buff = (char*)realloc( m_buff, nSize ); // May return a different pointer
		else
			m_buff = (char*)malloc(nSize);
		m_nBuffer =nSize;
	}
};

inline bool operator<(const tstring& s1, const tstring& s2)
{
	return ( strcmp(s1, s2) < 0);
}

inline bool operator<(const tstring& s1, const char* s2)
{
	return ( strcmp(s1, s2) < 0);
}
inline bool operator<(const char* s1, const tstring& s2)
{
	return ( strcmp(s1, s2) < 0);
}
inline bool operator>(const tstring& s1, const tstring& s2)
{
	return ( strcmp(s1, s2) > 0);
}
inline bool operator>(const tstring& s1, const char* s2)
{
	return ( strcmp(s1, s2) > 0);
}
inline bool operator>(const char* s1, const tstring& s2)
{
	return ( strcmp(s1, s2) > 0);
}
inline bool operator<=(const tstring& s1, const tstring& s2)
{
	return ( strcmp(s1, s2) <=  0);
}
inline bool operator<=(const tstring& s1, const char* s2)
{
	return ( strcmp(s1, s2) <= 0);
}
inline bool operator<=(const char* s1, const tstring& s2)
{
	return ( strcmp(s1, s2) <= 0);
}
inline bool operator>=(const tstring& s1, const tstring& s2)
{
	return ( strcmp(s1, s2) >= 0);
}
inline bool operator>=(const tstring& s1, const char* s2)
{
	return ( strcmp(s1, s2) >= 0);
}
inline bool operator>=(const char* s1, const tstring& s2)
{
	return ( strcmp(s1, s2) >= 0);
}

#endif