string.cpp

这里将 Socket APIs 封装成一个类似 CAsyncSocket 接口的类

#include "StdAfx.h"
#include "String.h"

CString Data2HexString ( char *data, int size, int nBytesPerLine/*=16*/ )
{
	CString csHexString, csTemp;
	for ( int i=0; i<size; i++ )
	{
		csTemp.Format ( _T("%02X "), (BYTE)data[i] );
		csHexString += csTemp;
		if ( (i+1) % nBytesPerLine == 0 )
			csHexString += "\r\n";
	}
	return csHexString;
}

BYTE HexCharToData(TCHAR cChar)
{
	if ( cChar >= _T('0') && cChar <= _T('9') )
		return (BYTE)(cChar-_T('0'));
	if ( cChar >= _T('a') && cChar <= _T('f') )
		return (BYTE)(cChar-_T('a')+0x0a);
	if ( cChar >= _T('A') && cChar <= _T('F') )
		return (BYTE)(cChar-_T('A')+0x0A);
	return 0xff;
}

//
// 将一个16进制的字符串转换为16进制的数，返回数据长度
// 例如：将字符串“61 62 63 64 65 66 67 68”转换成数据 [0x61 0x62 0x63 0x64 0x65 0x66 0x67 0x68]
// 保存到 szOutBuffer 缓冲中
//
int ConvStringToHexData(CString csOrgStr, BYTE *szOutBuffer, int nOutBufferSize)
{
	ASSERT ( szOutBuffer && nOutBufferSize > 0 );
	// 先得到有效的16进制字符串，同时将表示16进制的标志“0x”去掉
	CString csLegalHexStr;
	csOrgStr.MakeLower();
	csOrgStr.Replace ( _T("0x"), _T("") );
	for ( int i=0; i<csOrgStr.GetLength(); i++ )
	{
		TCHAR c = csOrgStr.GetAt (i);
		if ( (c>=_T('0')&&c<=_T('9')) || (c>=_T('a') && c<= _T('f')) )
		{
			csLegalHexStr += c;
		}
	}

	if ( csLegalHexStr.GetLength() < 1 ) return 0;

	// 不是偶数个字符则在后面补“0”
	if ( (csLegalHexStr.GetLength() % 2) != 0 )
		csLegalHexStr += _T("0");

	int j=0;
	for ( int i=0; j<nOutBufferSize && i<csLegalHexStr.GetLength(); i+= 2 )
	{
		BYTE btData = 0;
		BYTE bLo = ( 0x0f & HexCharToData ( csLegalHexStr.GetAt(i+1) ) );
		BYTE bHi = ( 0x0f & HexCharToData ( csLegalHexStr.GetAt(i) ) );
		if ( bLo == 0xff || bHi == 0xff )
			return -1;
		btData = ( bHi << 4 ) | bLo;
		szOutBuffer[j++] = btData;
	}

	return j;
}

//
// 将字符串 lpszOrg 转换为多字节的字符串，如果还要使用多字符串的长度，可以用以下方式来使用这个类：
// CMultiByteString MultiByteString(_T("UNICODE字符串"));
// printf ( "ANSI 字符串为： %s， 长度为： %d 字节\n", MultiByteString.GetBuffer(), MultiByteString.GetLength() );
//
CMultiByteString::CMultiByteString( LPCTSTR lpszOrg, int nOrgStringEncodeType/*=STRING_IS_SOFTCODE*/, OUT char *buf/*=NULL*/, int size/*=0*/, OUT int *pnCount/*=NULL*/ )
{
	m_bNewBuffer = FALSE;
	m_pszData = "";
	if ( !lpszOrg ) return;

	int nCount = 0;
	BOOL bOrgIsUncode = FALSE;
	if ( nOrgStringEncodeType == STRING_IS_MULTICHARS ) bOrgIsUncode = FALSE;
	else if ( nOrgStringEncodeType == STRING_IS_UNICODE ) bOrgIsUncode = TRUE;
	else
	{
#ifdef UNICODE
		bOrgIsUncode = TRUE;
#else
		bOrgIsUncode = FALSE;
#endif
	}


	if ( buf && size > 0 )
	{
		m_pszData = buf;
	}
	else
	{
		int nLen = 0;
		if ( bOrgIsUncode ) nLen = (int)wcslen((WCHAR*)lpszOrg) * 2 + sizeof(WCHAR);
		else nLen = (int)strlen((const char*)lpszOrg) + sizeof(char);
		m_pszData = new char[nLen];
		if ( !m_pszData )
		{
			::AfxThrowMemoryException ();
			return;
		}
		size = nLen;
		m_bNewBuffer = TRUE;
	}
	memset ( m_pszData, 0, size );

	if ( bOrgIsUncode )
	{
		nCount = WideCharToMultiByte ( CP_ACP, 0, lpszOrg, (int)lstrlen(lpszOrg), (LPSTR)m_pszData, size, NULL, NULL );
	}
	else
	{
		nCount = (int)strlen((const char*)lpszOrg);
		nCount = MIN(nCount,size);
		memcpy ( m_pszData, lpszOrg, nCount );
	}

	if ( pnCount ) *pnCount = nCount;
}

CMultiByteString::~CMultiByteString ()
{
	if ( m_bNewBuffer && m_pszData )
	{
		delete[] m_pszData;
	}
}

//
// 将 lpszOrg 转换为该程序使用的编码字符串，如果该程序是 UNICODE 就转为 UNICODE，如果是 ANSI 就转为 ANSI 的
//
CString GetCompatibleString ( LPVOID lpszOrg, BOOL bOrgIsUncode )
{
	if ( !lpszOrg ) return _T("");

#ifdef UNICODE
	if ( bOrgIsUncode ) return (LPCTSTR)lpszOrg;

	int nOrgLen = (int)strlen((const char*)lpszOrg);
	int nWideCount = nOrgLen + 1;
	WCHAR *wchar = new WCHAR[nWideCount];
	if ( !wchar ) return _T("");
	memset ( wchar, 0, nWideCount*sizeof(WCHAR) );
	MultiByteToWideChar(CP_ACP, 0, (LPCSTR)lpszOrg, nOrgLen, wchar, nWideCount);
	CString csRet = wchar;
	delete[] wchar;
	return csRet;
#else
	if ( !bOrgIsUncode ) return (LPCTSTR)lpszOrg;

	int nOrgLen = (int)strlen((LPCTSTR)lpszOrg);
	int nMultiByteSize = nOrgLen / sizeof(WCHAR) + 2;
	CString csRet;
	CMultiByteString ( (LPCTSTR)lpszOrg, csRet.GetBuffer(nMultiByteSize), nMultiByteSize, 1 );
	csRet.ReleaseBuffer();
	return csRet;
#endif
}

int hwSnprintfA ( char* buffer, int count, char* format, ... )
{
	if ( count < 1 ) return 0;
	ASSERT_ADDRESS ( buffer, count*sizeof(char) );
	memset ( buffer, 0, count*sizeof(char) );
	// 格式化
	va_list  va;
	va_start (va, format);
	int nRet = _vsnprintf ( buffer, count, format, va);
	va_end(va);
	buffer [count-1] = '\0';

	int nLen = nRet;
	if ( nLen < 0 ) nLen = (int)strlen(buffer);
	if ( nLen > count ) nLen = count;

	return nLen;
}

//
// 注意： count 参数不能用 sizeof(buffer) 来求得，而是用 sizeof(buffer)/sizeof(WCHAR) 来求得
//
int hwSnprintfW ( WCHAR* buffer, int count, WCHAR* format, ... )
{
	if ( count < 1 ) return 0;
	ASSERT_ADDRESS ( buffer, count*sizeof(WCHAR) );
	memset ( buffer, 0, count*sizeof(WCHAR) );
	// 格式化
	va_list  va;
	va_start (va, format);
	int nRet = _vsnwprintf ( buffer, count, format, va);
	va_end(va);
	buffer [count-1] = L'\0';

	int nLen = nRet;
	if ( nLen < 0 ) nLen = (int)wcslen(buffer);
	if ( nLen > count ) nLen = count;

	return nLen;
}

BOOL StringToGUID ( LPCTSTR lpszGUID, GUID &Guid)
{
	if ( !lpszGUID ) return FALSE;
	int data1, data2, data3;
	int data4[8];

	if (11 ==  sscanf_hw(lpszGUID, _T("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n"),
					&data1, &data2, &data3,
					&data4[0], &data4[1], &data4[2], &data4[3], 
					&data4[4], &data4[5], &data4[6], &data4[7])) {
		Guid.Data1 = data1;
		Guid.Data2 = data2 & 0xffff;
		Guid.Data3 = data3 & 0xffff;

		for (int i = 0 ; i < 8 ; ++i)
			Guid.Data4[i] = data4[i] & 0xff;

		return TRUE;
	}
	return FALSE;
}

CString GUIDToString ( GUID &Guid )
{
	CString csGUID;

	csGUID.Format ( _T("%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X"), Guid.Data1, Guid.Data2, Guid.Data3,
		Guid.Data4[0], Guid.Data4[1], Guid.Data4[2], Guid.Data4[3],Guid.Data4[4],Guid.Data4[5], Guid.Data4[6], Guid.Data4[7] );
	return csGUID;
}

CString FormatString ( LPCTSTR lpszStr, ... )
{
	TCHAR szMsg[1024] = {0};
	va_list  va;
	va_start (va, lpszStr);
#ifdef UNICODE
	_vsnwprintf( szMsg, COUNT(szMsg)-sizeof(TCHAR), (const wchar_t*)lpszStr, va);
#else
	_vsnprintf (szMsg, COUNT(szMsg)-sizeof(TCHAR), (const char*)lpszStr, va);
#endif
	va_end(va);

	return CString ( szMsg );
}

//
// 计算字符串中某字符的个数
//
int CalcCharCount ( LPCTSTR lpszText, TCHAR chCalc )
{
	if ( !lpszText ) return 0;
	int nLen = (int)lstrlen(lpszText);
	int nCount = 0;
	for ( int i=0; i<nLen; i++ )
	{
		if ( (TCHAR)lpszText[i] == (TCHAR)chCalc )
			nCount ++;
	}
	return nCount;
}

//
// bEndAsClrf	-	遇到字符串结尾是否也当作换行符，如果为 TRUE 表示最后一行即使没有换行符也会当作一行来处理，原字符串会被清空
//
CString GetOneLine(CString &str, LPCTSTR lpszLineEndFlag/*=_T("\n")*/, BOOL bEndAsClrf/*=FALSE*/)
{
	if ( !lpszLineEndFlag )
		return _T("");
	int nEndFlagLength = (int)lstrlen(lpszLineEndFlag);
	if ( nEndFlagLength < 1 ) return _T("");
	if ( str.IsEmpty() ) return _T("");
	int nPos = str.Find ( lpszLineEndFlag, 0 );
	BOOL bFound = FALSE;
	CString csOneLine;
	if ( nPos < 0 )
	{
		if ( bEndAsClrf )
		{
			csOneLine = str;
			str.Empty ();
		}
	}
	else
	{
		csOneLine = str.Left ( nPos );
		str = str.Mid ( nPos + nEndFlagLength );
	}
	csOneLine.TrimLeft(); csOneLine.TrimRight ();

	return csOneLine;
}

//
// 查找可显示的字符位置，空格应该算做不可显示的
//
int FindGraphPos ( CString &csOrg, int nStartPos )
{
	for ( int i=nStartPos; i<csOrg.GetLength(); i++ )
	{
		if ( isgraph(csOrg[i]) )
			return i;
	}
	return -1;
}

//
// 查找不可显示的字符位置，空格应该算做不可显示的
//
int FindNonGraphPos ( CString &csOrg, int nStartPos )
{
	for ( int i=nStartPos; i<csOrg.GetLength(); i++ )
	{
		if ( !isgraph(csOrg[i]) )
			return i;
	}
	return -1;
}

//
// 以空格或其他不可显示的字符作为单词的分隔，取第一个单词，并将该单词从 csOrg 中删除
// 如果 nCaseChange=1 返回的字符串会被转为小写
// 如果 nCaseChange=2 返回的字符串会被转为大写
//
CString GetOneWord ( CString &csOrg, int nCaseChange/*=0*/ )
{
	int nPos = FindGraphPos ( csOrg, 0 );
	if ( nPos < 0 ) return _T("");
	csOrg = csOrg.Mid ( nPos );

	nPos = FindNonGraphPos ( csOrg, 0 );
	if ( nPos < 0 ) nPos = csOrg.GetLength();
	CString csRet = csOrg.Left ( nPos );
	csOrg = csOrg.Mid ( nPos );

	if ( nCaseChange == 1 ) csRet.MakeLower ();
	else if ( nCaseChange == 2 ) csRet.MakeUpper ();
	return csRet;
}

//
// 删除字符串某字符及后面的所有字符串，例如：删除 "abcdefg.123" 中 '.' 后面的所有字符串
// 结果为 "abcdefg"
//
void DeleteAfterChar ( CString &csOrg, TCHAR cDel )
{
	int nPos = csOrg.Find ( cDel, 0 );
	if ( nPos >= 0 )
	{
		csOrg = csOrg.Left ( nPos );
	}
}

//
// 将一个字符串按照 cPartChr 字符作为中间分割点分为两个字符串
//
BOOL PartTwoWord ( IN CString &csOrg, OUT CString &csWord1, OUT CString &csWord2, IN TCHAR cPartChr/*=_T(':')*/ )
{
	int nFindPos = csOrg.Find ( cPartChr, 0 );
	if ( nFindPos < 1 ) return FALSE;
	csWord1 = csOrg.Left ( nFindPos );
	csWord2 = csOrg.Mid ( nFindPos+1 );
	csWord1.Trim(); csWord2.Trim();
	return TRUE;
}

//
// 将数字转为字符串
//
CString IntToString ( int nValue, BOOL bUnsigned/*=TRUE*/ )
{
	CString csRet;
	if ( bUnsigned ) csRet.Format ( _T("%u"), (UINT)nValue );
	else csRet.Format ( _T("%d"), nValue );
	return csRet;
}