xstring.cpp

该程序是用vc开发的对动态数组进行管理的DLL

#include "cwp.h"
#include "xstring.h"
#include <assert.h>


XString::XString()
{
	char str[]="";
	m_nLength = strlen(str);
	m_pString = new char[m_nLength + 1]; 
	memset(m_pString,'\0',m_nLength + 1);
	assert(m_pString != 0);
	strcpy(m_pString, str);
}


XString ::XString( const char ch )
{
	m_nLength = 1;
	m_pString = new char[m_nLength + 1];
	m_pString[1] = '\0';
	m_pString[0] = ch;	
}

XString ::XString( const char *str )
{
	if(str == NULL)
	{
		m_nLength = 0;
		m_pString = new char [1];
		m_pString[0]='\0';	
	}
	else
	{
		m_nLength = strlen(str);
		m_pString = new char[m_nLength + 1];
		memset(m_pString,'\0',m_nLength + 1);
		assert(m_pString != 0);
		strcpy(m_pString, str);	
	}
}

XString ::XString( const XString   & str )
{
	{
		m_nLength = str.m_nLength;
		m_pString = new char[m_nLength + 1];
		memset(m_pString,'\0',m_nLength + 1);
		assert(m_pString != 0);
		strcpy(m_pString, str.m_pString);
	}
 
}

/* operator = */

XString& XString ::operator=( char c )
{
	if (m_pString) delete []m_pString;
	m_nLength = 1;
	m_pString = new char[m_nLength + 1];
	m_pString[0] = c;
	m_pString[1] = '\0';
	
	return *this;	
}

XString& XString ::operator=( const char * str )
{
	if (m_pString) delete []m_pString;
	m_nLength = strlen(str);
	m_pString = new char[m_nLength + 1]; 
	memset(m_pString,'\0',m_nLength + 1);
	assert(m_pString != 0);
	strcpy(m_pString, str);

	return *this;	
}

XString& XString ::operator=( const XString   & str )
{
	if (m_pString) delete []m_pString;
	m_nLength = str.m_nLength;
	m_pString = new char[m_nLength + 1];
	memset(m_pString,'\0',m_nLength + 1);
	assert(m_pString != 0);
	strcpy(m_pString, str.m_pString);	

	return *this;
}

/* operator + */

XString  operator+(const  XString &xstr,const char * c )
{
	XString tmp;
	tmp.m_nLength= xstr.m_nLength+strlen(c);
	delete []tmp.m_pString;
	tmp.m_pString = new char [tmp.m_nLength+1];
	strcpy(tmp.m_pString,xstr.m_pString);
	strcat(tmp.m_pString,c);
	return tmp;
}

XString   operator+(const   XString &xstr, const char   c )
{
	char c1[2];
	c1[0]=c;
	c1[1]='\0';
	return xstr+c1;
	
}

XString   operator+(const    XString &xstr, const XString   & str )
{
	return xstr+str.m_pString;	
}


XString  operator+(const char * c ,const  XString &xstr)
{
	return XString(c) + xstr;
}

XString   operator+(const char   c, const   XString &xstr )
{
	return XString(c) + xstr;
}

 



/* operator += */

XString& XString ::operator+=( char c )
{
	m_nLength += 1;
	char* pNew = new char[m_nLength + 1];
	memset(pNew,'\0',m_nLength + 1);
	assert(pNew != 0);
	strcpy(pNew, m_pString);
	pNew[m_nLength - 1] = c;
	delete []m_pString;
	m_pString = pNew;

	return *this;
}

XString& XString ::operator+=( const char * str )
{
	m_nLength += strlen(str);
	char* pNew = new char[m_nLength + 1];
	memset(pNew,'\0',m_nLength + 1);
	assert(pNew != 0);
	strcpy(pNew, m_pString);
	strcat(pNew, str);
	delete []m_pString;
	m_pString = pNew;

	return *this;	
}

XString& XString ::operator+=( const XString   & str )
{
	m_nLength += str.m_nLength;
	char* pNew = new char[m_nLength + 1];
	memset(pNew,'\0',m_nLength + 1);
	assert(pNew != 0);
	strcpy(pNew, m_pString);
	strcat(pNew, str.m_pString);
	delete []m_pString;
	m_pString = pNew;

	return *this;
}

XString::~XString()
{
	if (m_pString) delete []m_pString;
}

int XString::length()
{
	return m_nLength;	
}

char* XString::ascii()
{
	return m_pString;
}

int XString::args(const char* format, ...)
{
	/*
	assert(format != 0);

	int len;
	char* MaxBuf;
	for(int i = 5; ; i ++)
	{
		len = (int)pow(2, i);
		MaxBuf = new char[len];
		memset(MaxBuf,'\0',len);
		if (!MaxBuf) return 0;
		// some UNIX's do not support vsnprintf and snprintf
		len = _vsnprintf(MaxBuf, len, format, (char*)(&format + 1));
		if (len > 0) break;
		delete []MaxBuf;
		if (len == 0) return 0;
	}

	if (!m_pString)
	{
		m_nLength = len;
		m_pString = new char[m_nLength + 1];
	    memset(m_pString,'\0',m_nLength + 1);
	}
	else if (m_nLength < len)
	{
		delete m_pString;
		m_nLength = len;
		m_pString = new char[m_nLength + 1];
		memset(m_pString,'\0',m_nLength + 1);
	}
	if (m_pString) 
		strcpy(m_pString, MaxBuf);
	else
		len = 0;
	delete []MaxBuf;

	return len;*/
	return 1;
}


double XString::toNum( )
{
	assert(m_pString != 0);
	char* pTmpStr = m_pString;

	// remove the leading ' ' and '\t' at the beginning
	while (*pTmpStr == ' ' || *pTmpStr == '\t')
		pTmpStr++;
	double d=0;
	d=atof(pTmpStr); //strtod()
	return d;	
}

int XString::toInt()
{
	return (int)toNum();	
}

short XString::toShort()
{
	return (short)toNum();
}

long XString::toLong()
{
	return (long)toNum();	
}

float XString::toFloat()
{
	return (float)toNum();	
}

double XString::toDouble()
{
	return toNum();
}

char numToChar(int i)
{
	switch (i)
	{
		case  0:return '0';
		case  1:return '1';
		case  2:return '2';
		case  3:return '3';
		case  4:return '4';
		case  5:return '5';
		case  6:return '6';
		case  7:return '7';
		case  8:return '8';
		case  9:return '9';
		default:return ' ';
	}
}

XString XString ::fromNum(double d)
{

	XString xstr("");
	char tmp[100];
	sprintf(tmp,"%f",d);
	xstr=tmp;
	if(xstr.find('.'))
	while(xstr.right(1) == '0')
		xstr=xstr.left(xstr.m_nLength-1);
	if(xstr.right(1) == '.')	
		xstr=xstr.left(xstr.m_nLength-1);
	
	return xstr;

	/*
	char buffer[50];
    _gcvt(d, 15, buffer );
	if( buffer[strlen(buffer) - 1] == '.' )
		buffer[strlen(buffer) - 1] = '\0';
	(*this)=buffer;
	*/

		
}

char* XString::latin1()
{
	return m_pString;
}

int XString::compare( const XString &s1, const XString &s2 )
{
	return strcmp(s1.m_pString,s2.m_pString);
}

int XString::compare( const char * s1, const XString &s2 )
{
	return strcmp(s1,s2.m_pString);	
}

int XString::compare( const XString &s1,  const char *s2 )
{
	return strcmp(s1.m_pString,s2);	
}

bool operator==( const XString & s1, const XString & s2 )
{
	if (XString::compare(s1, s2) == 0)return true;
	else return false;
}

bool operator==( const XString & s1, const char * s2 )
{
	if (XString::compare(s1, s2) == 0)return true;
	else return false;
}
bool operator==( const char * s1, const XString & s2 )
{
	if (XString::compare(s1, s2) == 0)return true;
	else return false;
}
bool operator!=( const XString & s1, const XString & s2 )
{
	if (XString::compare(s1, s2) != 0)return true;
	else return false;	
}
bool operator!=( const char * s1, const XString & s2 )
{
	if (XString::compare(s1, s2) != 0)return true;
	else return false;	
}
bool operator!=( const XString & s1, const char * s2 )
{
	if (XString::compare(s1, s2) != 0)return true;
	else return false;	
}

bool operator<( const XString & s1, const XString & s2 )
{
	if (XString::compare(s1, s2) < 0)return true;
	else return false;		
}
bool operator<( const XString & s1, const char * s2 )
{
	if (XString::compare(s1, s2) < 0)return true;
	else return false;		
}
bool operator<( const char * s1, const XString & s2 )
{
	if (XString::compare(s1, s2) < 0)return true;
	else return false;		
}


bool operator<=( const XString & s1, const XString & s2 )
{
	if (XString::compare(s1, s2) <= 0)return true;
	else return false;		
}
bool operator<=( const XString & s1, const char * s2 )
{
	if (XString::compare(s1, s2) <= 0)return true;
	else return false;		
}
bool operator<=( const char * s1, const XString & s2 )
{
	if (XString::compare(s1, s2) <= 0)return true;
	else return false;		
}




bool operator>( const XString & s1, const XString & s2 )
{
	if (XString::compare(s1, s2) > 0)return true;
	else return false;		
}
bool operator>( const XString & s1, const char * s2 )
{
	if (XString::compare(s1, s2) > 0)return true;
	else return false;		
}
bool operator>( const char * s1, const XString & s2 )
{
	if (XString::compare(s1, s2) > 0)return true;
	else return false;		
}
bool operator>=( const XString & s1, const XString & s2 )
{
	if (XString::compare(s1, s2) >= 0)return true;
	else return false;		
}
bool operator>=( const XString & s1, const char * s2 )
{
	if (XString::compare(s1, s2) >= 0)return true;
	else return false;		
}
bool operator>=( const char * s1, const XString & s2 )
{
	if (XString::compare(s1, s2) >= 0)return true;
	else return false;		
}






int XString::find( char c, int index  , bool cs   )
{
	char tmp[2];
	tmp[1] = '\0';
	tmp[0] = c;
	return 	find(tmp,index,cs);
}



int XString::find( const XString & str, int index  , bool cs   )
{
	return 	find(str.m_pString,index,cs);
}