stringa.cpp

自己改写的在WINCE上开发用的EVC++的FTP操作示例工程,希望能给相关人士提供帮助.

// Searching
//
//////////////////////////////////////////////////////////////////////

int CStringA::Find(char ch) const
{
	return Find(ch, 0);
}

int CStringA::Find(char ch, int nStart) const
{
	if (nStart >= GetLength())
		return -1;
	LPSTR lpsz = strchr(m_pszString + nStart, (_TUCHAR) ch);
	return (lpsz == NULL) ? -1 : (int)(lpsz - m_pszString);
}

int CStringA::Find(LPCSTR lpszSub)
{
	return Find(lpszSub, 0);
}

int CStringA::Find(LPCSTR lpszSub, int nStart)
{
	ATLASSERT(strlen(lpszSub) > 0);

	if (nStart > GetLength())
		return -1;

	LPSTR lpsz = strstr(m_pszString + nStart, lpszSub);
	return (lpsz == NULL) ? -1 : (int)(lpsz - m_pszString);
}

int CStringA::FindOneOf(LPCSTR lpszCharSet) const
{
	LPSTR lpsz = strpbrk(m_pszString, lpszCharSet);
	return (lpsz == NULL) ? -1 : (int)(lpsz - m_pszString);
}


//////////////////////////////////////////////////////////////////////
//
// Assignment Operations
//
//////////////////////////////////////////////////////////////////////

const CStringA& CStringA::operator=(CStringA& strSrc)
{
	if (m_pszString != strSrc.GetString())
		StringCopy(strSrc.GetLength(), strSrc.GetString());
	return *this;
}

const CStringA& CStringA::operator=(LPCSTR lpsz)
{
	ATLASSERT(lpsz != NULL);
	StringCopy(strlen(lpsz), lpsz);
	return *this;
}

const CStringA& CStringA::operator=(BSTR bstrStr)
{
	USES_CONVERSION;
	int nLen = _tcslen(OLE2T(bstrStr));
	StringCopy(nLen, W2A(bstrStr));

	return *this;
}


//////////////////////////////////////////////////////////////////////
//
// Concatenation
//
//////////////////////////////////////////////////////////////////////

CStringA operator+(CStringA& strSrc1, CStringA& strSrc2)
{
	CStringA s;
	s.ConcatCopy((LPCSTR) strSrc1, (LPCSTR) strSrc2);
	return s;
}

CStringA operator+(CStringA& strSrc, LPCSTR lpsz)
{
	CStringA s;
	s.ConcatCopy((LPCSTR) strSrc, lpsz);
	return s;
}

CStringA operator+(LPCSTR lpsz, CStringA& strSrc)
{
	CStringA s;
	s.ConcatCopy(lpsz, (LPCSTR) strSrc);
	return s;
}

CStringA operator+(CStringA& strSrc, BSTR bstrStr)
{
	USES_CONVERSION;
	CStringA s;
	s.ConcatCopy((LPCSTR) strSrc, W2A(bstrStr));
	return s;
}

CStringA operator+(BSTR bstrStr, CStringA& strSrc)
{
	USES_CONVERSION;
	CStringA s;
	s.ConcatCopy(W2A(bstrStr), (LPCSTR) strSrc);
	return s;
}

const CStringA& CStringA::operator+=(CStringA& strSrc)
{
	ConcatCopy((LPCSTR) strSrc);
	return *this;
}

const CStringA& CStringA::operator+=(LPCSTR lpsz)
{
	ConcatCopy(lpsz);
	return *this;
}

const CStringA& CStringA::operator+=(BSTR bstrStr)
{
	USES_CONVERSION;
	ConcatCopy(W2A(bstrStr));
	return *this;
}

const CStringA& CStringA::operator+=(char ch)
{
	USES_CONVERSION;
	ConcatCopy(ch);
	return *this;
}


//////////////////////////////////////////////////////////////////////
//
// Extraction
//
//////////////////////////////////////////////////////////////////////

CStringA CStringA::Mid(int nFirst) const
{
	return Mid(nFirst, GetLength() - nFirst);	
}

CStringA CStringA::Mid(int nFirst, int nCount) const
{
	if (nFirst < 0)
		nFirst = 0;
	if (nCount < 0)
		nCount = 0;

	if (nFirst + nCount > GetLength())
		nCount = GetLength() - nFirst;
	if (nFirst > GetLength())
		nCount = 0;

	ATLASSERT(nFirst >= 0);
	ATLASSERT(nFirst + nCount <= GetLength());

	if (nFirst == 0 && nFirst + nCount == GetLength())
		return *this;

	CStringA newStr;
	StringCopy(newStr, nCount, nFirst, 0);
	return newStr;
}

CStringA CStringA::Left(int nCount) const
{
	if (nCount < 0)
		nCount = 0;
	if (nCount >= GetLength())
		return *this;

	CStringA newStr;
	StringCopy(newStr, nCount, 0, 0);
	return newStr;
}

CStringA CStringA::Right(int nCount) const
{
	if (nCount < 0)
		nCount = 0;
	if (nCount >= GetLength())
		return *this;

	CStringA newStr;
	StringCopy(newStr, nCount, GetLength() - nCount, 0);
	return newStr;
}

CStringA CStringA::SpanIncluding(LPCSTR lpszCharSet) const
{
	ATLASSERT(lpszCharSet != NULL);
	//ATLASSERT(::IsBadReadPtr(lpszCharSet, -1) == 0);
	return Left(strspn(m_pszString, lpszCharSet));
}

CStringA CStringA::SpanExcluding(LPCSTR lpszCharSet) const
{
	ATLASSERT(lpszCharSet != NULL);
	//ATLASSERT(::IsBadReadPtr(lpszCharSet, -1) == 0);
	return Left(strcspn(m_pszString, lpszCharSet));
}


//////////////////////////////////////////////////////////////////////
//
// Comparison
//
//////////////////////////////////////////////////////////////////////
	
int CStringA::Compare(CStringA& str) const
{
	ATLASSERT((LPCSTR) str != NULL);
	//ATLASSERT(::IsBadReadPtr((LPCSTR) str, -1) == 0);
	return strcmp(m_pszString, (LPCSTR) str);	
}

int CStringA::Compare(LPCSTR lpsz) const
{
	ATLASSERT(lpsz != NULL);
	//ATLASSERT(::IsBadReadPtr(lpsz, -1) == 0);
	return strcmp(m_pszString, lpsz);	
}

int CStringA::CompareNoCase(CStringA& str) const
{
	ATLASSERT((LPCSTR) str != NULL);
	//ATLASSERT(::IsBadReadPtr((LPCSTR) str, -1) == 0);
	return _stricmp(m_pszString, (LPCSTR) str);	
}

int CStringA::CompareNoCase(LPCSTR lpsz) const
{
	ATLASSERT(lpsz != NULL);
	//ATLASSERT(::IsBadReadPtr(lpsz, -1) == 0);
	return _stricmp(m_pszString, lpsz);	
}

//////////////////////////////////////////////////////////////////////
//
// Formatting
//
//////////////////////////////////////////////////////////////////////
	
void CStringA::Format(LPCSTR pszCharSet, ...)
{
	va_list vl;
	va_start(vl, pszCharSet);

	char* pszTemp = NULL;
	int nBufferSize = 0;
	int nRetVal = -1;

	do {
		nBufferSize += 100;
		delete [] pszTemp;
		pszTemp = new char[nBufferSize];
		nRetVal = _vsnprintf(pszTemp, nBufferSize, pszCharSet, vl);
	} while (nRetVal < 0);

	int nNewLen = strlen(pszTemp);
	AllocString(nNewLen);
	strcpy(m_pszString, pszTemp);
	delete [] pszTemp;

	va_end(vl);
}


//////////////////////////////////////////////////////////////////////
//
// Replacing
//
//////////////////////////////////////////////////////////////////////

int CStringA::Replace(char chOld, char chNew)
{
	int nCount = 0;

	if (chOld != chNew)
	{
		LPSTR psz = m_pszString;
		LPSTR pszEnd = psz + GetLength();
		while(psz < pszEnd)
		{
			if (*psz == chOld)
			{
				*psz = chNew;
				nCount++;
			}
			psz ++;//= _tcsinc(psz);
		}
	}

	return nCount;
}

int CStringA::Replace(LPCSTR lpszOld, LPCSTR lpszNew)
{
	int nSourceLen = strlen(lpszOld);
	if (nSourceLen == 0)
		return 0;
	int nReplaceLen = strlen(lpszNew);

	int nCount = 0;
	LPSTR lpszStart = m_pszString;
	LPSTR lpszEnd = lpszStart + GetLength();
	LPSTR lpszTarget;

	// Check to see if any changes need to be made
	while (lpszStart < lpszEnd)
	{
		while ((lpszTarget = strstr(lpszStart, lpszOld)) != NULL)
		{
			lpszStart = lpszTarget + nSourceLen;
			nCount++;
		}
		lpszStart += strlen(lpszStart) + 1;
	}

	// Do the actual work
	if (nCount > 0)
	{
		int nOldLen = GetLength();
		int nNewLen = nOldLen + (nReplaceLen - nSourceLen) * nCount;
		if (GetLength() < nNewLen)
		{
			CStringA szTemp = m_pszString;
			ReAllocString(nNewLen);
			memcpy(m_pszString, (LPCSTR) szTemp, nOldLen * sizeof(char));
		}

		lpszStart = m_pszString;
		lpszEnd = lpszStart + GetLength();

		while (lpszStart < lpszEnd)
		{
			while ((lpszTarget = strstr(lpszStart, lpszOld)) != NULL)
			{
				int nBalance = nOldLen - (lpszTarget - m_pszString + nSourceLen);
				memmove(lpszTarget + nReplaceLen, lpszTarget + nSourceLen, nBalance * sizeof(char));
				memcpy(lpszTarget, lpszNew, nReplaceLen * sizeof(char));
				lpszStart = lpszTarget + nReplaceLen;
				lpszStart[nBalance] = '\0';
				nOldLen += (nReplaceLen - nSourceLen);
			}
			lpszStart += strlen(lpszStart) + 1;
		}
		ATLASSERT(m_pszString[GetLength()] == '\0');
	}
	return nCount;
}