受不了STL的字符串了，决定自己实现一个。没有什么技术含量，无非就是简单易用。字符串与浮点数之间的转换，还没有实现。还有Unicode与多字节转换还没有实现。当然，这个网上有太多的实现办法，呵呵。这个字符串类分为两部分，一部分是通用函数实现，主要在string_utils名称空间中。 下面是字符串的实现代码。希望能给初学者提供一点学习的参考。 /*
* xstring.h
* 字符串类
* 字符串类未充分测试
*/
#ifndef X_STRING_H_
#define X_STRING_H_
#include <xconfig.h>
#include <xtype.h>
#include <xmemory.h>
#include <cassert>
#include <xutils.h>
#if CONFIG_WINDOWS
#include <windows.h>
#elif CONFIG_LINUX
#include <wchar.h>
#endif
#ifdef CONFIG_BCB
#include <stdio.h>
#include <stdarg.h>
#else
#include <cstdio>
#include <cstdarg>
#endif
#include <iostream>
namespace zdh
{
using namespace zdh::utils;
namespace string_utils
{
template<class T>
inline bool isSpaceTab( T paramCh )
{
return paramCh == ' ' || paramCh == '\t';
}
///检查是否为字母字符
template<class T>
inline bool isLetter( T paramCh )
{
return (paramCh >= 'a' && paramCh <='z') || (paramCh >='A' && paramCh <= 'Z');
}
///检查是否为数字字符
template<class T>
inline bool isDigit( T paramCh)
{
return paramCh >= '0' && paramCh <='9';
}
///检查是否为回车符
template<class T>
inline bool isEnter(T paramCh)
{
return paramCh == 13;
}
///检查是否为换行符
template<class T>
inline bool isNewLine(T paramCh)
{
return paramCh == 10;
}
///检查是否是空格符
template<class T>
inline bool isSpace(T paramCh)
{
return paramCh == ' ';
}
///检查是否是tab制表符
template<class T>
inline bool isTab(T paramCh)
{
return paramCh == 9;
}
///检查是否则0字符
template<class T>
inline bool isZero(T paramCh)
{
return paramCh == 0;
}
///检查是否则双引号
template<class T>
inline bool isQuote(T paramCh)
{
return paramCh == '\"';
}
///检查是否则单引号
template<class T>
inline bool isApos(T paramCh)
{
return paramCh == '\'';
}
///检查是否转定义符
template<class T>
inline bool isTransport(T paramCh)
{
return paramCh == '\\';
}
///检查是否为左中括号
template<class T>
inline bool isBracketLeft(T paramCh)
{
return paramCh == '[';
}
///检查是否为右中括号
template<class T>
inline bool isBracketRight(T paramCh)
{
return paramCh == ']';
}
///检查是否为#号
template<class T>
inline bool isNumbersign(T paramCh)
{
return paramCh == '#';
}
///检查是否为分号
template<class T>
inline bool isSemicolon(T paramCh)
{
return paramCh == ';';
}
///检查是否为=号
template<class C>
bool isEqual(C paramCh)
{
return paramCh == '=';
}
///检查是否为ini的空格
template<class C>
bool isIniSpaceChar(C paramCh)
{
return paramCh == ' ' || paramCh == 9;
}
///检查是否为ini的注释字符
template<class C>
bool isIniComment(C paramCh)
{
return paramCh =='#' || paramCh == ';';
}
///取字符串的长度
/**
@param [in] paramValue 要取得长度的字符串指针
@return 返回取得长度
*/
template<class T>
static XInt Length(const T * paramValue)
{
ZDH_ASSERT(paramValue != NULL);
XInt iRet = 0;
while( *paramValue != 0 )
{
paramValue ++;
iRet ++;
}
return iRet;
}
///比较两个字符串
/**
@param [in] paramValue1 字符串1
@param [in] paramValue2 字符串2
@return 返回字符串比较结果
- >0 表示paramValue1 > paramValue2
- 0 表示paramValue1等于paramValue2
- <0 表示paramValue1 < paramValue2
*/
template<class T>
static XInt Compare(const T * paramValue1, const T * paramValue2)
{
ZDH_ASSERT(paramValue1 != NULL);
ZDH_ASSERT(paramValue2 != NULL);
XInt iRet;
do
{
iRet = *paramValue1 - *paramValue2;
if( (iRet == 0) && (*paramValue1 != 0) && (*paramValue2 != 0) )
{
paramValue1 ++;
paramValue2 ++;
}
else break;
} while ( !iRet );
return iRet;
}
///不分大小写比较两个字符串
/**
@param [in] paramValue1 字符串1
@param [in] paramValue2 字符串2
@return 返回字符串比较结果
- >0 表示paramValue1 > paramValue2
- 0 表示paramValue1等于paramValue2
- <0 表示paramValue1 < paramValue2
*/
template<class T>
static XInt CompareIC(const T * paramValue1, const T * paramValue2)
{
ZDH_ASSERT(paramValue1 != NULL);
ZDH_ASSERT(paramValue2 != NULL);
XInt iRet;
do
{
T ch1 = *paramValue1;
T ch2 = *paramValue2;
if( ch1 <= 'Z' && ch1 >= 'A' ) ch1 += 32;
if( ch2 <= 'Z' && ch2 >= 'A' ) ch2 += 32;
iRet = ch1 - ch2;
if( (iRet == 0) && (ch1 != 0) && (ch2 != 0) )
{
paramValue1 ++;
paramValue2 ++;
}
else break;
} while ( !iRet );
return iRet;
}
///指定比较的字符数的字符串比较
/**
@param [in] paramValue1 字符串1
@param [in] paramValue2 字符串2
@param [in] paramN 要比较的字符数，要求该值大于等于0
@return 返回字符串比较结果
- >0 表示paramValue1 > paramValue2
- 0 表示paramValue1等于paramValue2
- <0 表示paramValue1 < paramValue2
*/
template<class T>
static XInt NCompare(const T * paramValue1, const T * paramValue2, XInt paramN)
{
ZDH_ASSERT(paramValue1 != NULL);
ZDH_ASSERT(paramValue2 != NULL);
ZDH_ASSERT(paramN >= 0);
if( paramN == 0 ) return 0;
XInt iRet;
do
{
iRet = *paramValue1 - *paramValue2;
paramN --;
if( (iRet == 0) && (*paramValue1 != 0) && (*paramValue2 != 0) && paramN > 0)
{
paramValue1 ++;
paramValue2 ++;
}
else break;
} while ( 1 );
return iRet;
}
///指定比较的字符数的字符串不分大小比较
/**
@param [in] paramValue1 字符串1
@param [in] paramValue2 字符串2
@param [in] paramN 要比较的字符数，要求该值大于等于0
@return 返回字符串比较结果
- >0 表示paramValue1 > paramValue2
- 0 表示paramValue1等于paramValue2
- <0 表示paramValue1 < paramValue2
*/
template<class T>
static XInt NCompareIC(const T * paramValue1, const T * paramValue2, XInt paramN)
{
ZDH_ASSERT(paramValue1 != NULL);
ZDH_ASSERT(paramValue2 != NULL);
ZDH_ASSERT(paramN >= 0);
if( paramN == 0 ) return 0;
XInt iRet;
do
{
T ch1 = *paramValue1;
T ch2 = *paramValue2;
if( ch1 <= 'Z' && ch1 >= 'A' ) ch1 += 32;
if( ch2 <= 'Z' && ch2 >= 'A' ) ch2 += 32;
iRet = ch1 - ch2;
paramN --;
if( (iRet == 0) && (*paramValue1 != 0) && (*paramValue2 != 0) && paramN > 0)
{
paramValue1 ++;
paramValue2 ++;
}
else break;
} while ( 1 );
return iRet;
}
///将32位无符号整数转换为16进制字符串
/**
将32位无符号整数转换为16进制字符串
@param [in] paramValue 被转换的整数
@param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
@param [in] paramHexWidth 16进制的宽度，有效宽度1～8
@param [in] paramHexStyle 十六进制的样式，A表示用大写，a表示用小写
@param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀，false表示不加该前缀
@return 返回转换后的串指针
*/
template<class T>
static T * DWordToHex(XDWord paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
ZDH_ASSERT( paramBuffer != NULL );
T * p = paramBuffer;
//确定十六进制数据的长度
XInt iWidth;
if( paramHexWidth > 8 )
{
iWidth = 8;
}
else if( paramHexWidth < 1)
{
iWidth = 1;
}
else
{
iWidth = paramHexWidth;
}
//确定值
XDWord dwValue = paramValue;
//
T charArray[8];
T * d = charArray;
XInt iRealWidth = 0;
do
{
*d++ = T(dwValue % 16);
iRealWidth ++;
dwValue >>= 4;
if( dwValue == 0 )
{
break;
}
} while (1);
//将不足宽度的地方补0
for(XInt i = iRealWidth; i < iWidth; i++)
{
*d++ = 0;
}
//如果有前缀
if( paramHexPrefix )
{
*p++ = '0';
*p++ = 'x';
}
T ch;
while (d != charArray)
{
--d;
ch = *d;
if( ch < 10 )
{
*p++ = ch + '0';
}
else
{
* p++ = T(ch - 10 + paramHexStyle);
}
}
*p = 0;
//
return paramBuffer;
}
///将32位有符号整数转换为16进制字符串
/**
将32位有符号整数转换为16进制字符串
@param [in] paramValue 被转换的整数
@param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
@param [in] paramHexWidth 16进制的宽度，有效宽度1～8
@param [in] paramHexStyle 十六进制的样式，A表示用大写，a表示用小写
@param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀，false表示不加该前缀
@return 返回转换后的串指针
*/
template<class T>
inline T * IntToHex(XInt paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
return DWordToHex((XDWord)paramValue, paramBuffer, paramHexWidth, paramHexStyle, paramHexPrefix);
}
///将64位无符号整数转换为16进制字符串
/**
将64位无符号整数转换为16进制字符串
@param [in] paramValue 被转换的整数
@param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
@param [in] paramHexWidth 16进制的宽度，有效宽度1～16
@param [in] paramHexStyle 十六进制的样式，A表示用大写，a表示用小写
@param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀，false表示不加该前缀
@return 返回转换后的串指针
*/
template<class T>
static T * DDWordToHex(XDDWord paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
ZDH_ASSERT( paramBuffer != NULL );
T * p = paramBuffer;
//确定十六进制数据的长度
XInt iWidth;
if( paramHexWidth > 16 )
{
iWidth = 16;
}
else if( paramHexWidth < 1)
{
iWidth = 1;
}
else
{
iWidth = paramHexWidth;
}
//确定值
XDDWord ddwValue = paramValue;
//
T charArray[16];
T * d = charArray;
XInt iRealWidth = 0;
do
{
*d++ = T(ddwValue % 16);
iRealWidth ++;
ddwValue >>= 4;
if( ddwValue == 0 )
{
break;
}
} while (1);
//将不足宽度的地方补0
for(XInt i = iRealWidth; i < iWidth; i++)
{
*d++ = 0;
}
//如果有前缀
if( paramHexPrefix )
{
*p++ = '0';
*p++ = 'x';
}
T ch;
while (d != charArray)
{
--d;
ch = *d;
if( ch < 10 )
{
*p++ = ch + '0';
}
else
{
* p++ = T(ch - 10 + paramHexStyle);
}
}
*p = 0;
//
return paramBuffer;
}
///将64位有符号整数转换为16进制字符串
/**
将64位有符号整数转换为16进制字符串
@param [in] paramValue 被转换的整数
@param [out] paramBuffer 保存结果的整数,要求大小至少要12字节
@param [in] paramHexWidth 16进制的宽度，有效宽度1～16
@param [in] paramHexStyle 十六进制的样式，A表示用大写，a表示用小写
@param [in] paramHexPrefix 表示是否要加0x前缀,true表示加该前缀，false表示不加该前缀
@return 返回转换后的串指针
*/
template<class T>
inline T * LongToHex(XLong paramValue, T * paramBuffer, XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
return DDWordToHex((XDDWord)paramValue, paramBuffer, paramHexWidth, paramHexStyle, paramHexPrefix);
}
///将32位无符号整数，转换为字符串
/**
@param [in] paramValue 将要被转换的无符号整数
@param [out] paramBuffer 用于保存结果的缓冲区，要求缓冲区至少33字节。
@param [in] paramRadix 表示转换的进制，默认为10进制,有效进制范围在2到36之间。
@param [in] paramHexStyle 表示大于9的数字表示方式。默认为'A'
- a 表示大于10的位数，都是小写字符
- A 表示大于10的位数，都是大写字符
@return T * 返回转换后的字符串，实际为paramBuffer的指针。
*/
template<class T>
static T * DWordToStr(XDWord paramValue, T * paramBuffer, XInt paramRadix = 10, T paramHexStyle = 'A')
{
T * p = paramBuffer;
XDWord dwV;
if( paramRadix >= 2 && paramRadix <= 36 )
{
T _buf[33];
T *bufp = _buf;
dwV = (XDWord)paramValue;
for(;;)
{
*bufp++ = T(dwV % paramRadix);
dwV /= paramRadix;
if( dwV == 0 ) break;
}
T ch;
while (bufp != _buf)
{
--bufp;
ch = *bufp;
if( ch < 10 ) *p++ = ch+'0';
else *p++ = T(ch - 10 + paramHexStyle);
}
}
*p = '\0';
return paramBuffer;
}
///将32位有符号整数，转换为字符串
/**
@param [in] paramValue 将要被转换的整数
@param [out] paramBuffer 用于保存结果的缓冲区，要求缓冲区至少33字节。
@param [in] paramRadix 表示转换的进制，默认为10进制,有效进制范围在2到36之间。
@param [in] paramHexStyle 表示大于9的数字表示方式。默认为'A'
- a 表示大于10的位数，都是小写字符
- A 表示大于10的位数，都是大写字符
@return T * 返回转换后的字符串，实际为paramBuffer的指针。
*/
template<class T>
static T * IntToStr(XInt paramValue, T * paramBuffer, XInt paramRadix = 10, T paramHexStyle = 'A')
{
ZDH_ASSERT(paramBuffer != NULL);
T * p = paramBuffer;
XDWord dwV;
if( paramRadix >= 2 && paramRadix <= 36 )
{
//如果整数
if( paramValue < 0 && paramRadix == 10 )
{
*p++ = '-';
dwV = (XDWord)(-paramValue);
}
else
{
dwV = (XDWord)paramValue;
}
T _buf[33];
T *bufp = _buf;
for(;;)
{
*bufp++ = T(dwV % paramRadix);
dwV /= paramRadix;
if( dwV == 0 ) break;
}
T ch;
while (bufp != _buf)
{
--bufp;
ch = *bufp;
if( ch < 10 ) *p++ = ch+'0';
else *p++ = T(ch - 10 + paramHexStyle);
}
}
*p = '\0';
return paramBuffer;
}
//----------------------------------------------------------------------------
///将64位有符号整数转换为字符串
/**
@param [in] paramValue 被转换的64位整数
@param [out] paramBuffer 存放转换后的字符串,要求至少要传入65个字符，否则有可能溢出。
@param [in] paramRadix 转换后的进制，2表示二进制，16表示十六进制，10表示十进制，该值范围是2到36。
@param [in] paramHexStyle
- a 表示大于10的位数，都是小写字符
- A 表示大于10的位数，都是大写字符
@return 返回转换的结果。实际上返回的是参数aBuff的值
*/
template<class T>
static T * LongToStr(XLong paramValue,T * paramBuffer,XInt paramRadix = 10,T paramHexStyle = 'A')
{
ZDH_ASSERT(paramBuffer!=NULL);
T * p = paramBuffer;
XDDWord ddwV;
//如果是有效的进制
if( paramRadix >= 2 && paramRadix <= 36 )
{
if( paramValue < 0 )
{
*p++ = '-';
ddwV = XDDWord(-paramValue);
}
else
{
ddwV = XDDWord(paramValue);
}
T _buf[65];
T *bufp = _buf;
for(;;)
{
*bufp++ = T(ddwV % paramRadix);
ddwV /= paramRadix;
if( ddwV == 0 )
{
break;
}
}
T ch;
while (bufp != _buf)
{
--bufp;
ch = *bufp;
if( ch < 10 ) *p++ = ch+'0';
else *p++ = T( ch - 10 + paramHexStyle);
}
}
*p = '\0';
return paramBuffer;
}
//----------------------------------------------------------------------------
///将64位有符号整数转换为字符串
/**
@param [in] paramValue 被转换的64位整数
@param [out] paramBuffer 存放转换后的字符串,要求至少要传入65个字符，否则有可能溢出。
@param [in] paramRadix 转换后的进制，2表示二进制，16表示十六进制，10表示十进制，该值范围是2到36。
@param [in] paramHexStyle
- a 表示大于10的位数，都是小写字符
- A 表示大于10的位数，都是大写字符
@return 返回转换的结果。实际上返回的是参数aBuff的值
*/
template<class T>
static T * DDWordToStr(XDDWord paramValue,T *paramBuffer,XInt paramRadix = 10,T paramHexStyle = 'A' )
{
ZDH_ASSERT(paramBuffer != NULL);
T * p = paramBuffer;
if( paramRadix >= 2 && paramRadix <=36 )
{
T _buf[65];
T *bufp = _buf;
for(;;)
{
*bufp++ = T( paramValue % paramRadix);
paramValue /= paramRadix;
if( paramValue == 0 )
{
break;
}
}
T ch;
while (bufp != _buf)
{
--bufp;
ch = *bufp;
if( ch < 10 )
{
*p++ = ch+'0';
}
else
{
*p++ = XChar(ch-10 + paramHexStyle);
}
}
}
*p = '\0';
return paramBuffer;
}
///尝试将字符串转换为32位有符号整数模板
/**
尝试将字符串转换为32位有符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [out] paramValue 用于保存转换后的数值
@return 返回尝试转换的状态
- true 表示转换成功
- false 表示转换失败，这个时候aValue的值为0
*/
template<class T>
static bool TryStringToInt(const T * paramNumberString, XInt & paramValue)
{
//先初始化为0
paramValue = 0;
if( isNULL(paramNumberString) )
{
return true;
}
bool bNegativeFlag = false; //负数标志
bool bHexFlag = false; //十六进制标志
const T *p = paramNumberString;
//跳过空格
while(*p == ' ')
{
p++;
}
//检查符号位
switch(*p)
{
case 0:
return false;
case '+':
++p;
break;
case '-':
bNegativeFlag = true;
++p;
break;
case '$': //if $..,x..,X..开头的数字为十六进制
case 'x':
case 'X':
bHexFlag = true;
++p;
break;
case '0': //if 0x..,0X..开头的数字为十六进制
bHexFlag = ((*(p+1) == 'x') || (*(p+1) == 'X')); //(Length(s) > I) and (UpCase(s[I+1]) = 'X');
if (bHexFlag)
{
p += 2;
}
break;
}
if (*p == 0)
{
return false;
}
if (bHexFlag)
{
// INT32的十六进制字符串最多有8个字节
if (Length(p) > 8)
{
return false;
}
XInt iValue = 0;
while (*p != 0)
{
XInt v;
T chNumber = *p;
if (chNumber >= '0' && chNumber <= '9') //如果是0..9
{
v = chNumber - '0';
}
else if (chNumber >= 'a' && chNumber <= 'f') //如果是a..f
{
v = chNumber - 'a' + 10;
}
else if (chNumber >= 'A' && chNumber <= 'F') //如果是A..F
{
v = chNumber - 'A' + 10;
}
else //遇到非法数字退出
{
return false;
}
iValue *= 16;
iValue += v;
++p;
}
paramValue = iValue;
}
else
{
// 整数最小值是 -2147483648 (0x80000000), 最大值是 2147483647 (0x7FFFFFFF)
const XInt ABS_MIN_INT_DIV10 = 214748364;
const XInt ABS_MIN_INT_MOD10 = 8;
const XInt ABS_MAX_INT_DIV10 = 214748364;
const XInt ABS_MAX_INT_MOD10 = 7;
XInt iValue = 0;
while (*p != 0)
{
T chNumber = *p;
if (chNumber < '0' ||chNumber > '9') //如果发现超出有效的字符，则表示转换失败
{
return false;
}
XInt v = chNumber - '0';
if (bNegativeFlag) //如果是负数
{
if (iValue > ABS_MIN_INT_DIV10)
{
return false;
}
if (iValue == ABS_MIN_INT_DIV10)
{
if (v > ABS_MIN_INT_MOD10)
{
return false;
}
// 因为需要intValue始终是正整数, 其最大值是 2147483647
// 如果此时v=8, 将导致其溢出
if (v == ABS_MIN_INT_MOD10)
{
// 如果后面没有字符了, 说明这个是最后一个字符, 那么这个数是整型最小值
// 之所以在这里退出, 是为了防止整型最大值溢出
if (*(p+1) == 0)
{
paramValue = 0x80000000;
return true;
}
else
{
return false;
}
}
}
}
else //如果是非负数
{
if (iValue > ABS_MAX_INT_DIV10)
{
return false;
}
if (iValue == ABS_MAX_INT_DIV10 && v > ABS_MAX_INT_MOD10)
{
return false;
}
}
iValue *= 10;
iValue += v;
++p;
}
if( bNegativeFlag )
{
paramValue = -iValue;
}
else
{
paramValue = iValue;
}
}
return true;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为32位无符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [out] paramValue 用于保存转换后的数值
@return 返回尝试转换的状态
- true 表示转换成功
- false 表示转换失败，这个时候aValue的值为0
*/
template<class T>
static bool TryStringToDWord(const T * paramNumberString, XDWord & paramValue)
{
paramValue = 0; //设置初始值
if( isNULL(paramNumberString) )
{
return true;
}
bool HexFlag = false;
const T *p = paramNumberString;
//跳过导前空格
while(*p == ' ')
{
p++;
}
switch(*p)
{
case 0:
return false;
case '$':
case 'x':
case 'X':
HexFlag = true;
++p;
break;
case '0':
HexFlag = ((*(p+1) == 'x') || (*(p+1) == 'X'));
if (HexFlag)
{
p += 2;
}
break;
}
if (*p == 0)
{
return false;
}
XDWord dwValue = 0;
if (HexFlag)
{
// DWord的十六进制字符串最多有8个字节
if (Length(p) > 8)
{
return false;
}
while (*p != 0)
{
XDWord v;
T chNumber = *p;
if (chNumber >= '0' && chNumber <= '9')
{
v = chNumber - '0';
}
else if (chNumber >= 'a' && chNumber <= 'f')
{
v = chNumber - 'a' + 10;
}
else if (chNumber >= 'A' && chNumber <= 'F')
{
v = chNumber - 'A' + 10;
}
else
{
return false;
}
dwValue *= 16;
dwValue += v;
++p;
}
}
else
{
// 最大值是 4294967295 (0xFFFFFFFF)
const XDWord ABS_MAX_DWORD_DIV10 = 429496729u;
const XDWord ABS_MAX_DWORD_MOD10 = 5u;
while (*p != 0)
{
T chNumber = *p;
//如果是无效数字
if (chNumber < '0' || chNumber > '9')
{
return false;
}
//如果将会超过最大除10整数
if( dwValue > ABS_MAX_DWORD_DIV10 )
{
return false;
}
XDWord v = chNumber - '0';
//如果将会超过最大整数
if (dwValue == ABS_MAX_DWORD_DIV10 && v > ABS_MAX_DWORD_MOD10)
{
return false;
}
//dwValue = dwValue * 10 + v;
dwValue *= 10;
dwValue += v;
++p;
}
}
paramValue = dwValue;
return true;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为64位有符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [out] paramValue 用于保存转换后的数值
@return 返回尝试转换的状态
- true 表示转换成功
- false 表示转换失败，这个时候aValue的值为0
*/
template<class T>
static bool TryStringToLong(const T * paramNumberString, XLong & paramValue)
{
paramValue = 0;
if( isNULL(paramNumberString) )
{
return true;
}
bool NegativeFlag = false;
bool HexFlag = false;
const T * p = paramNumberString;
//跳过空格
while(*p == ' ')
{
p++;
}
switch(*p)
{
case 0:
return false;
case '+':
++p;
break;
case '-':
NegativeFlag = true;
++p;
break;
case '$':
case 'x':
case 'X':
HexFlag = true;
++p;
break;
case '0':
HexFlag = ((*(p+1) == 'x') || (*(p+1) == 'X'));
if (HexFlag) p += 2;
break;
}
if (*p == 0)
{
return false;
}
XLong lngValue = 0;
if (HexFlag)
{
// INT64的十六进制字符串最多有16个字节
if (Length(p) > 16)
{
return false;
}
while (*p != 0)
{
XByte v;
T chNumber = * p;
if (chNumber >= '0' && chNumber <= '9')
{
v = chNumber - '0';
}
else if (chNumber >= 'a' && chNumber <= 'f')
{
v = chNumber - 'a' + 10;
}
else if (chNumber >= 'A' && chNumber <= 'F')
{
v = chNumber - 'A' + 10;
}
else
{
return false;
}
//lngValue = lngValue * 16 + v;
lngValue *= 16;
lngValue += v;
++p;
}
}
else
{
// 整数最小值是 -9223372036854775808LL (0x8000000000000000), 最大值是 9223372036854775807LL (0x7FFFFFFFFFFFFFFF)
const XLong ABS_MIN_LONG_INT_DIV10 = 922337203685477580LL;
const XLong ABS_MIN_LONG_INT_MOD10 = 8LL;
const XLong ABS_MAX_LONG_INT_DIV10 = 922337203685477580LL;
const XLong ABS_MAX_LONG_INT_MOD10 = 7LL;
const XLong ABS_MIN_LONG_INT_VALUE = 0x8000000000000000LL;
while (*p != 0)
{
T chNumber = * p;
if (chNumber < '0' || chNumber > '9')
{
return false;
}
XByte v = *p - '0';
if (NegativeFlag)
{
if (lngValue > ABS_MIN_LONG_INT_DIV10)
{
return false;
}
if (lngValue == ABS_MIN_LONG_INT_DIV10)
{
if (v > ABS_MIN_LONG_INT_MOD10)
{
return false;
}
// 因为需要intValue始终是正整数, 其最大值是 2147483647
// 如果此时v=8, 将导致其溢出
if (v == ABS_MIN_LONG_INT_MOD10)
{
// 如果后面没有字符了, 说明这个是最后一个字符, 那么这个数是整型最小值
// 之所以在这里退出, 是为了防止整型最大值溢出
if (*(p+1) == 0)
{
paramValue = ABS_MIN_LONG_INT_VALUE;
return true;
}
else return false;
}
}
}
else
{
if (lngValue > ABS_MAX_LONG_INT_DIV10)
{
return false;
}
if (lngValue == ABS_MAX_LONG_INT_DIV10 && v > ABS_MAX_LONG_INT_MOD10)
{
return false;
}
}
lngValue *= 10;
lngValue += v;
++p;
}
}
paramValue = NegativeFlag ? -lngValue : lngValue;
return true;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为64位无符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [out] paramValue 用于保存转换后的数值
@return 返回尝试转换的状态
- true 表示转换成功
- false 表示转换失败，这个时候aValue的值为0
*/
template<class T>
static bool TryStringToDDWord(const T * paramNumberString, XDDWord & paramValue)
{
paramValue = 0; //设置初始值为0
if( isNULL(paramNumberString) )
{
return true;
}
bool HexFlag = false; //定义十六进制标志符，默认为false。
const T *p = paramNumberString;
//跳过空格
while(*p == ' ')
{
p++;
}
//判断字符串为十进制的还是十六进制，并对hex赋值。
switch(*p)
{
case 0:
return false;
case '$':
case 'x':
case 'X':
HexFlag = true;
++p;
break;
case '0':
HexFlag = ((*(p+1) == 'x') || (*(p+1) == 'X'));
if (HexFlag) p += 2;
break;
}
if (*p == 0)
{
return false;
}
XDDWord ddwValue = 0;
if (HexFlag)// 对十六进制数的字符串进行转换。
{
// XDDWord的十六进制字符串最多有16个字节
if (Length(p) > 16)
{
return false;
}
while (*p != 0)
{
XByte v;
T chNumber = *p;
if (chNumber >= '0' && chNumber <= '9')
{
v = chNumber - '0';
}
else if (chNumber >= 'a' && chNumber <= 'f')
{
v = chNumber - 'a' + 10;
}
else if (chNumber >= 'A' && chNumber <= 'F')
{
v = chNumber - 'A' + 10;
}
else
{
return false;
}
ddwValue *= 16;
ddwValue += v;
++p;
}
}
else//对十进制的数的字符串进行转换。
{
// 最大值是 18446744073709551615LL (0xFFFFFFFFFFFFFFFF)
const XDDWord ABS_MAX_DDWORD_DIV10 = 1844674407370955161ULL;
const XDDWord ABS_MAX_DDWORD_MOD10 = 5ULL;
while (*p != 0)
{
T chNumber = *p;
if (chNumber < '0' || chNumber > '9')
{
return false;
}
XByte v = chNumber - '0';
if (ddwValue > ABS_MAX_DDWORD_DIV10)
{
return false;//转化后的整数值越界，则转化失败。
}
if (ddwValue == ABS_MAX_DDWORD_DIV10 && v > ABS_MAX_DDWORD_MOD10)
{
return false;
}
ddwValue *= 10;
ddwValue += v;
++p;
}
//paramValue = ddwValue;
}
paramValue = ddwValue;
return true;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为32位有符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [in] paramDefault 缺少数值
@return XInt 返回转换后的整数
*/
template<class T>
inline XInt StringToIntDef(const T * paramNumberString, XInt paramDefault = 0)
{
XInt iRet;
if( !TryStringToInt(paramNumberString,iRet) )
{
iRet = paramDefault;
}
return iRet;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为32位无符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [in] paramDefault 缺少数值
@return XDWord 返回转换后的整数
*/
template<class T>
inline XDWord StringToDWordDef(const T * paramNumberString, XDWord paramDefault = 0)
{
XDWord dwRet;
if( !TryStringToDWord(paramNumberString,dwRet) )
{
dwRet = paramDefault;
}
return dwRet;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为64位有符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [in] paramDefault 缺少数值
@return XLong 返回转换后的整数
*/
template<class T>
inline XLong StringToLongDef(const T * paramNumberString, XLong paramDefault = 0)
{
XLong lngRet;
if( !TryStringToLong(paramNumberString,lngRet) )
{
lngRet = paramDefault;
}
return lngRet;
}
//----------------------------------------------------------------------------
/**
尝试将字符串转换为64位无符号整数，能够自动识别十进制和十六进制数。
@param [in] paramNumberString 被转换的数值字符串
@param [in] paramDefault 缺少数值
@return XDDWord 返回转换后的整数
*/
template<class T>
inline XDDWord StringToDDWordDef(const T * paramNumberString, XDDWord paramDefault = 0)
{
XDDWord ddwRet;
if( !TryStringToDDWord(paramNumberString,ddwRet) )
{
ddwRet = paramDefault;
}
return ddwRet;
}
///将字符串中的小写字符转换为大写字符
/**
@param [in,out] 被转换的字符串
@return T * 转换后的字符串
这里转换后的字符串与参数中的字符串相同
*/
template<class T>
static T * UpperCase(T * paramString)
{
ZDH_ASSERT(paramString != NULL);
T * pString = paramString;
T ch;
do
{
ch = *pString;
if( ch <= 'z' && ch >= 'a' )
{
*pString = ch - 32;
}
pString++;
}while(ch != 0);
return paramString;
}
///将字符串中的大写字符转换为小写字符
/**
@param [in,out] 被转换的字符串
@return T * 转换后的字符串
这里转换后的字符串与参数中的字符串相同
*/
template<class T>
static T * LowerCase(T * paramString)
{
ZDH_ASSERT(paramString != NULL);
T * pString = paramString;
T ch;
do
{
ch = *pString;
if( ch <= 'Z' && ch >= 'A' )
{
*pString = ch + 32;
}
pString++;
}while(ch != 0);
return paramString;
}
///去除字符串的左边空格
/**
请注意,请正确传入字符串的长度
@param [in,out] paramString 被去除空格的字符串
@param [in] paramLength 传入字符串的长度
@return XInt 返回去除空格后，字符串的长度
*/
template<class T>
static XInt TrimLeft(T * paramString,XInt paramLength)
{
ZDH_ASSERT(Length(paramString) == paramLength);
XInt iRet = 0;
if( paramLength > 0)
{
T * pStart = paramString;
T * pEnd = paramString + paramLength - 1;
//找到第一个非空格字符串
while( pStart <= pEnd )
{
if( !isSpaceTab(*pStart) ) break;
pStart ++;
}
//复制数据,并计算新字符串的长度
T * pDest = paramString;
iRet = (XInt)(pEnd + 1 - pStart);
while( pStart <= pEnd )
{
*pDest ++ = *pStart ++;
}
//设置字符串结尾符
*pDest = 0;
}
return iRet;
}
///去除字符串的右边空格
/**
请注意,请正确传入字符串的长度
@param [in,out] paramString 被去除空格的字符串
@param [in] paramLength 传入字符串的长度
@return XInt 返回去除空格后，字符串的长度
*/
template<class T>
static XInt TrimRight(T * paramString,XInt paramLength)
{
ZDH_ASSERT(Length(paramString) == paramLength);
XInt iRet = 0;
if( paramLength > 0)
{
T * pStart = paramString;
T * pEnd = paramString + paramLength - 1;
//反向查找一个非空格字符
while( pStart <= pEnd )
{
if( !isSpaceTab(*pEnd) ) break;
pEnd --;
}
*(pEnd + 1) = 0;
iRet = (XInt)(pEnd + 1 - pStart);
}
//返回字符数
return iRet;
}
///清除左右两边的字符串
/**
请注意,请正确传入字符串的长度
@param [in,out] paramString 被去除空格的字符串
@param [in] paramLength 传入字符串的长度
@return XInt 返回去除空格后，字符串的长度
*/
template<class T>
static XInt Trim(T * paramString,XInt paramLength)
{
ZDH_ASSERT(Length(paramString) == paramLength);
XInt iRet = 0;
if( paramLength > 0)
{
T * pStart = paramString;
T * pEnd = paramString + paramLength - 1;
while( pStart <= pEnd )
{
if( !isSpaceTab(*pStart) ) break;
pStart ++;
}
while( pStart <= pEnd )
{
if( !isSpaceTab(*pEnd) ) break;
pEnd --;
}
T * pDest = paramString;
iRet = (XInt)(pEnd + 1 - pStart);
while( pStart <= pEnd )
{
*pDest ++ = *pStart ++;
}
*pDest = 0;
}
return iRet;
}
///去除字符串的左边空格
/**
@param [in,out] paramString 被去除空格的字符串
@return T * 返回去除空格后的字符串
*/
template<class T>
static T * TrimLeft(T * paramString)
{
XInt iLength = Length(paramString);
if( iLength > 0)
{
T * pStart = paramString;
T * pEnd = paramString + iLength - 1;
while( pStart <= pEnd )
{
if( !isSpaceTab(*pStart) ) break;
pStart ++;
}
T * pDest = paramString;
while( pStart <= pEnd )
{
*pDest ++ = *pStart ++;
}
*pDest = 0;
}
return paramString;
}
///去除字符串的右边空格
/**
@param [in,out] paramString 被去除空格的字符串
@return T * 返回去除空格后的字符串
*/
template<class T>
static T * TrimRight(T * paramString)
{
XInt iLength = Length(paramString);
if( iLength > 0)
{
T * pStart = paramString;
T * pEnd = paramString + iLength - 1;
while( pStart <= pEnd )
{
if( !isSpaceTab(*pEnd) ) break;
pEnd --;
}
*(pEnd + 1) = 0;
}
return paramString;
}
///去除字符串的左右两边空格
/**
@param [in,out] paramString 被去除空格的字符串
@return T * 返回去除空格后的字符串
*/
template<class T>
static T * Trim(T * paramString)
{
XInt iLength = Length(paramString);
if( iLength > 0)
{
T * pStart = paramString;
T * pEnd = paramString + iLength - 1;
while( pStart <= pEnd )
{
if( !isSpaceTab(*pStart) ) break;
pStart ++;
}
while( pStart <= pEnd )
{
if( !isSpaceTab(*pEnd)) break;
pEnd --;
}
T * pDest = paramString;
while( pStart <= pEnd )
{
*pDest ++ = *pStart ++;
}
*pDest = 0;
}
return paramString;
}
namespace private_impl
{
//请不要直接这里定义的函数
///复制内存
template<class T>
static T * _MemoryCopy(T * paramMemoryDest, const T* paramMemorySrc, XInt paramCopySize)
{
XInt iCopyBytes = paramCopySize;
const XDDWord * pS = (const XDDWord *)paramMemorySrc;
XDDWord * pD = (XDDWord *)paramMemoryDest;
for(XInt i = iCopyBytes / sizeof(XDDWord); i > 0; i--, pS ++, pD++ )
{
*pD = *pS;
}
XByte * pBS = (XByte *)pS;
XByte * pBD = (XByte *)pD;
for(XInt i = iCopyBytes % sizeof(XDDWord); i > 0; i--, pBS ++, pBD++ )
{
*pBD = *pBS;
}
return paramMemoryDest;
}
///初始化内存
template<class T>
static void * _MemorySet(T * paramMemory, XInt paramMemorySize, XInt paramValue)
{
if( paramMemorySize > 16) //如果大于16字节，就做优化,以8字节的速度复制
{
//初始化要复制的数据
union
{
XDDWord ddwV;
XByte btV[sizeof(XDDWord)];
}temp;
{
XByte * pDest = temp.btV;
for(XInt i = 0; i < sizeof(temp.btV); i++ )
{
*pDest ++ = (XByte)paramValue;
}
}
{
//复制
XInt iCopyCount = paramMemorySize / sizeof(XDDWord);
XDDWord * pDest = (XDDWord *)paramMemory;
while(iCopyCount > 0)
{
*pDest ++ = temp.ddwV;
iCopyCount --;
}
iCopyCount = paramMemorySize % sizeof(XLong);
XByte * pByteDest = (XByte *)pDest;
while(iCopyCount > 0)
{
*pByteDest ++ = (XByte)paramValue;
}
}
}
else if( paramMemorySize > 0 )
{
XByte * pDest = (XByte *)paramMemory;
XByte btValue = (XByte)paramValue;
for(XInt i = 0; i < paramMemorySize; i++)
{
*pDest ++ = btValue;
}
}
return paramMemory;
}
template<class T>
static T * _MemoryMove(T * paramMemoryDest, const T * paramMemorySrc, XInt paramMoveSize)
{
//检查是否有重叠
XInt iDis = XInt(((XByte *)paramMemoryDest) - ((XByte *)paramMemorySrc));
if( iDis > 0 && iDis < paramMoveSize ) //如果存在重叠现象
{
XDDWord * pS = (XDDWord *)(((XByte *)paramMemorySrc) + paramMoveSize);
XDDWord * pD = (XDDWord *)(((XByte *)paramMemoryDest) + paramMoveSize);
XInt iCopyCount = paramMoveSize / sizeof(XDDWord);
while(iCopyCount > 0)
{
pS--;
pD--;
*pD = *pS;
iCopyCount --;
}
iCopyCount = paramMoveSize % sizeof(XDDWord);
XByte * pBS = (XByte *)pS;
XByte * pBD = (XByte *)pD;
while(iCopyCount > 0)
{
pBS--;
pBD--;
*pBD = *pBS;
iCopyCount --;
}
}
else
{
return _MemoryCopy(paramMemoryDest, paramMemorySrc, paramMoveSize);
}
return paramMemoryDest;
}
}
///将内存初始化为0
inline void * MemoryZero(void * paramMemory, XInt paramSize)
{
ZDH_ASSERT(paramMemory != NULL);
ZDH_ASSERT(paramSize >= 0);
return private_impl::_MemorySet(paramMemory, paramSize, 0);
}
///重置内存
inline void * MemorySet(void * paramMemory, XInt paramSize, XInt paramValue)
{
ZDH_ASSERT(paramMemory != NULL);
ZDH_ASSERT(paramSize >= 0);
return private_impl::_MemorySet(paramMemory, paramSize, paramValue);
}
///复制内存
inline void * MemoryCopy(void * paramDest,const void * paramSrc, XInt paramCopySize)
{
ZDH_ASSERT(paramDest != NULL);
ZDH_ASSERT(paramSrc != NULL);
ZDH_ASSERT(paramCopySize >= 0);
return private_impl::_MemoryCopy(paramDest, paramSrc, paramCopySize);
}
///移动内存
inline void * MemoryMove(void * paramDest, const void * paramSrc, XInt paramMoveSize)
{
ZDH_ASSERT(paramDest != NULL);
ZDH_ASSERT(paramSrc != NULL);
ZDH_ASSERT(paramMoveSize >= 0);
return private_impl::_MemoryMove(paramDest, paramSrc, paramMoveSize);
}
///字符串复制
/**
@param [out] paramDest 存放要复制字符串的指针
@param [in] paramSrc 源字符串的指针
@reutrn T * 返回存放复制字符串后指针
*/
template<class T>
static T * StringCopy(T * paramDest, const T * paramSrc)
{
ZDH_ASSERT(paramDest != NULL);
ZDH_ASSERT(paramSrc != NULL);
T * pT = paramDest;
while( *paramSrc )
{
*pT ++ = * paramSrc++;
}
*pT = 0;
return paramDest;
}
///字符串复制(指定最大复制字符数
/**
@param [out] paramDest 存放要复制字符串的指针
@param [in] paramSrc 源字符串的指针
@param [in] paramN 最大复制的字符数
@reutrn T * 返回存放复制字符串后指针
*/
template<class T>
static T * StringCopy(T * paramDest, const T * paramSrc,const XInt paramN)
{
ZDH_ASSERT(paramDest != NULL);
ZDH_ASSERT(paramSrc != NULL);
ZDH_ASSERT(paramN >= 0);
XInt iN = paramN;
T * pT = paramDest;
while( *paramSrc && iN > 0 )
{
*pT ++ = * paramSrc++;
iN--;
}
*pT = 0;
return paramDest;
}
}; /* namespace string_utils */
///字符串基础模板
template<class T = XChar,class Alloctor = XMemory>
class XStringBase
{
public:
enum
{
npos = -1
};
public:
typedef T StringChar;
typedef T * TPointer;
typedef const T * ConstTPointer;
private:
///字符串结构结构体
struct SStringStruct
{
XInt Length; ///<尺寸
XInt Capacity; ///<当前字符串的容量
//Data ///<当前数据指针所在的位置
};
//字符串内的常量定义,不给外部使用的
enum
{
STRING_BLOCK_SIZE = 64, //单位块大小
CHAR_SIZE = sizeof(T), //每个字符串的大小
HEAD_SIZE = sizeof(SStringStruct), //字符串头的字节数
XSTRING_BASE_ENUM_FORCE_DWORD = 0x7FFFFFFF //强制该Enum为32位
}; //字符串最小内存块大小
public:
///默认构造函数
XStringBase()
:m_Data(NULL)
{}
///构造函数
XStringBase(const T * paramString)
:m_Data(NULL)
{
XInt iLength = string_utils::Length(paramString);
if( iLength > 0)
{
ensureCapacity(iLength);
CopyData(paramString, (T *)m_Data, iLength);
getOriData()->Length = iLength;
}
}
///默认拷贝构造函数
XStringBase(const XStringBase<T> & paramString)
:m_Data(NULL)
{
XInt iLength = paramString.getLength();
if( iLength > 0)
{
ensureCapacity(iLength);
CopyData(paramString.c_str(), (T *)m_Data, iLength);
getOriData()->Length = iLength;
}
}
///构造函数
XStringBase(const T & paramChar)
:m_Data(NULL)
{
ensureCapacity(1);
*((T *)m_Data) = paramChar;
*(((T *)m_Data) + 1) = 0;
getOriData()->Length = 1;
}
///析构函数
~XStringBase()
{
if( isNotNULL(m_Data) )
{
Alloctor::Free(getOriData());
m_Data = NULL;
}
}
///取字符串最小块的字节数
XInt getBlockBytes() const { return STRING_BLOCK_SIZE; }
///取字符的字节数
XInt getCharBytes() const { return CHAR_SIZE; }
///取当前容量
XInt getCapacity() const
{
XInt iRet = 0;
if( isNotNULL(m_Data) )
{
iRet = getOriData()->Capacity;
}
return iRet;
}
///取当前字符串的长度
XInt getLength() const
{
XInt iRet = 0;
if( isNotNULL(m_Data) )
{
iRet = getOriData()->Length;
}
return iRet;
}
///取数组的最大容量
XInt getMaxCapacity() const { return (0x7ffffff0 - HEAD_SIZE) / CHAR_SIZE; }
///确定装载字符容量(会自动增加0结尾)
void ensureCapacity(XInt paramCharCapacity)
{
if( paramCharCapacity > 0)
{
expandCapacity(paramCharCapacity + 1); //增加一个字符0的位置
}
}
///取字符串的内容
const T * c_str() const
{
static T sNullString[1] = {0};
if( isNULL(m_Data) )
{
return sNullString;
}
else
{
return (const T *)m_Data;
}
}
///判断当前字符串是否为空
bool isEmpty() const { return getLength() == 0; }
bool isNotEmpty() const { return getLength() != 0; }
///取字符串指针函数
const void * Data() const { return m_Data; }
///赋值函数
/**
将当前串设为指定的串
*/
void Assign(const XStringBase<T> & paramR)
{
if( ¶mR != this )
{
Assign(paramR.c_str(), paramR.getLength());
}
}
///赋值函数
/**
将当前串设为指定的串
*/
void Assign(const T * paramR)
{
ZDH_ASSERT(paramR != NULL);
XInt iLength = string_utils::Length(paramR);
Assign(paramR, iLength);
}
///赋值函数
/**
将当前串设为指定的串
@param [in] paramR 指定的串
@param [in] paramLength 指定串的长度
*/
void Assign(const T * paramR, XInt paramLength)
{
if( c_str() == paramR ) return;
XInt iLength = paramLength;
if( iLength > 0)
{
ensureCapacity(iLength+1);
CopyData(paramR, (T *)m_Data, iLength);
getOriData()->Length = iLength;
}
else
{
ToEmptyString();
}
}
///赋值函数
/**
将当前串设为只有指定字符的串
*/
void Assign(const T & paramR)
{
if( paramR != 0 )
{
ensureCapacity(1);
*((T *)m_Data) = paramR;
*(((T *)m_Data) + 1) = 0;
getOriData()->Length = 1;
}
else
{
ToEmptyString();
}
}
///追加指定的字符串
void AppendString(const XStringBase<T> & paramR)
{
XInt iLength = paramR.getLength();
if( iLength > 0)
{
XInt iThisLength = getLength();
ensureCapacity(iThisLength + iLength);
CopyData(paramR.c_str(), ((T *)m_Data) + iThisLength, iLength);
getOriData()->Length = iLength + iThisLength;
}
}
///追加指定的字符串
void AppendString(const XStringBase<T> & paramR,XInt paramCount)
{
XInt iLength = paramR.getLength();
if( iLength > 0 && paramCount > 0)
{
XInt iThisLength = getLength();
ensureCapacity(iThisLength + (iLength * paramCount));
T * p = ((T *)m_Data) + iThisLength;
const T * s = paramR.c_str();
for(XInt i = 0; i < paramCount; i++)
{
CopyData(s, p, iLength);
p += iLength;
}
getOriData()->Length = (iLength * paramCount )+ iThisLength ;
}
}
///追加指定的字符串
void AppendString(const T * paramR)
{
AppendString(paramR, string_utils::Length(paramR));
}
///追加指定长度的字符串
void AppendString(const T * paramR, XInt paramLength)
{
XInt iLength = paramLength;//string_utils::Length(paramR);
if( iLength > 0 && paramR != NULL )
{
XInt iThisLength = getLength();
ensureCapacity(iThisLength + iLength);
CopyData(paramR, ((T *)m_Data) + iThisLength, iLength);
getOriData()->Length = iLength + iThisLength;
}
}
void AppendString(const T * paramR, XInt paramLength, XInt paramCount)
{
XInt iLength = paramLength;
if( iLength > 0 && paramR != NULL && paramCount > 0 )
{
XInt iThisLength = getLength();
ensureCapacity(iThisLength + (iLength * paramCount));
T * p = ((T *)m_Data) + iThisLength;
for(XInt i = 0; i < paramCount; i++)
{
CopyData(paramR, p, iLength);
p += iLength;
}
getOriData()->Length = (iLength * paramCount)+ iThisLength;
}
}
///追加一个字符
void AppendChar(const T paramR)
{
AppendChar(paramR,1);
}
///追加指定个数的字符
/**
字符'\0'不能被加入
@param [in] paramR 要追加的字符
@param [in] paramCount 要追加的个数
*/
void AppendChar(const T paramR, XInt paramCount)
{
if( paramR != 0 && paramCount > 0 )
{
XInt iThisLength = getLength();
ensureCapacity(iThisLength + paramCount);
T * p = ((T *)m_Data) + iThisLength;
for(XInt i = 0; i < paramCount; i++)
{
*p++ = paramR;
}
*p = 0;
getOriData()->Length = iThisLength + paramCount;
}
}
///取指定下标的字符
/**
@param [in] paramIndex 指定的下标，有效范围是[0,getLength()-1];
*/
T at(XInt paramIndex) const;
///取指定下标的字符引用
/**
@param [in] paramIndex 指定的下标，有效范围是[0,getLength()-1];
*/
T & at(XInt paramIndex);
///检查指定的下标是否有效
bool CheckIndex(XInt iIndex) const
{
return iIndex >= 0 && iIndex < getLength();
}
///查找子串的位置
/**
如果子串存在，则返回子串的下标，有效下标在[0,getLength()-1]之间;
如果子串为空，则返回-1;
@param [in] paramSubString 子串
@return XInt 返回子串的下标
- -1 表示未找到子串
- >=0 表示返回对应子串的下标
*/
XInt Pos(const XStringBase<T> & paramSubString) const
{
return Pos(0,paramSubString);
}
///查找子串的位置
/**
如果子串存在，则返回子串的下标，有效下标在[0,getLength()-1]之间;
如果子串为空，则返回-1;
@param [in] paramSubString 子串
@return XInt 返回子串的下标
- -1 表示未找到子串
- >=0 表示返回对应子串的下标
*/
XInt Pos(const T * paramSubString) const
{
return Pos(0, paramSubString, string_utils::Length(paramSubString));
}
///查找子串的位置
/**
如果子串存在，则返回子串的下标，有效下标在[0,getLength()-1]之间;
如果子串为空，则返回-1;
@param [in] paramSubString 子串
@param [in] paramSubStringLength 子串的长度
@return XInt 返回子串的下标
- -1 表示未找到子串
- >=0 表示返回对应子串的下标
*/
XInt Pos(const T * paramSubString, XInt paramSubStringLength) const
{
return Pos(0, paramSubString, paramSubStringLength);
}
///查找子串的位置
/**
如果子串存在，则返回子串的下标，有效下标在[0,getLength()-1]之间;
如果子串为空，则返回-1;
@param [in] paramStartPos 开始的下标
@param [in] paramSubString 子串
@param [in] paramSubStringLength 子串的长度
@return XInt 返回子串的下标
- -1 表示未找到子串
- >=0 表示返回对应子串的下标
*/
XInt Pos(XInt paramStartPos, const T * paramSubString, XInt paramSubStringLength) const
{
ZDH_ASSERT(paramSubString != NULL);
ZDH_ASSERT(paramSubStringLength == string_utils::Length(paramSubString));
if(isEmpty() || paramSubStringLength== 0)
{
return -1;
}
if( paramStartPos < 0 )
{
paramStartPos = 0;
}
else if( paramStartPos >= getLength() )
{
return -1;
}
const T * s1 = c_str() + paramStartPos;
const T * s2 = paramSubString;
const T * pFind = FindString( s1, s2 );
if( isNULL(pFind) )
{
return -1;
}
return (XInt(pFind - s1) + paramStartPos);
}
///从指定开始的位置，查找子串的位置
/**
如果子串存在，则返回子串的下标，有效下标在[0,getLength()-1]之间;
如果子串为空，则返回-1;
@param [in] paramStartPos 开始的位置
@param [in] paramSubString 子串
@return XInt 返回子串的下标
- -1 表示未找到子串
- >=0 表示返回对应子串的下标
*/
XInt Pos(const XInt paramStartPos, const XStringBase<T> & paramSubString) const
{
return Pos(paramStartPos, paramSubString.c_str(), paramSubString.getLength());
}
///确定字符的位置
/**
如果字符为0,则返回-1
如果字符存在，则返回字符的下标，有效下标在[0,getLength()-1]之间;
@param [in] paramChar 要查找的字符
@return XInt 返回字符的下标
- -1 表示未找到字符
- >=0 表示返回对应字符的下标
*/
XInt Pos(const T & paramChar) const
{
if( isEmpty() ) return -1;
if( paramChar == 0 ) return -1;
const T * s1 = c_str();
T s2[2];
s2[0] = paramChar;
s2[1] = 0;
const T * pFind = FindString( s1, s2 );
if( isNULL(pFind) ) return -1;
return XInt(pFind - s1);
}
///从指定开始的位置，查找字符
/**
@param [in] paramStartPos 指定开始的位置，从0开始
@param [in] paramChar 查找的字符
@return XInt 返回字符的下标
- -1 表示未找到字符
- >=0 表示返回对应字符的下标
*/
XInt Pos(const XInt paramStartPos, const T & paramChar) const
{
if( paramStartPos < 0 )
{
return Pos(paramChar);
}
else if( paramStartPos >= getLength() )
{
return -1;
}
const T * s1 = c_str() + paramStartPos;
T s2[2];
s2[0] = paramChar;
s2[1] = 0;
const T * pFind = FindString( s1, s2 );
if( isNULL(pFind) ) return -1;
return ((XInt)(pFind - s1)) + paramStartPos;
}
///替换字符
/**
@param [in] paramFindChar 查找的字符
@param [in] paramDestChar 要被替换成的字符
@return XInt 被替换的字符个数
*/
XInt ReplaceChar(const T ¶mFindChar, const T & paramDestChar)
{
ZDH_ASSERT(paramFindChar != paramDestChar);
XInt iRetReplaceCount = 0;
XInt iLength = getLength();
if( paramDestChar != paramFindChar && iLength > 0 )
{
T * pData = (T *)m_Data;
for(XInt i = 0; i < iLength; i++, pData ++)
{
if( * pData == paramFindChar )
{
iRetReplaceCount ++;
*pData = paramDestChar;
}
}
}
return iRetReplaceCount;
}
///指定位置字符串
/**
@param [in] paramPos 插入的位置
@param [in] paramInsertString 插入的字符串
*/
void InsertString(XInt paramPos, const XStringBase<T> & paramInsertString, XInt paramInsertCount = 1)
{
InsertString(paramPos, paramInsertString.c_str(), paramInsertString.getLength(),paramInsertCount);
}
///指定位置字符串
/**
@param [in] paramPos 插入的位置
@param [in] paramInsertString 插入的字符串
*/
void InsertString(XInt paramPos, const T * paramInsertString, XInt paramInsertCount = 1)
{
InsertString(paramPos, paramInsertString, string_utils::Length(paramInsertString),paramInsertCount);
}
///指定位置字符串
/**
@param [in] paramPos 插入的位置
@param [in] paramInsertString 插入的字符串
@param [in] paramInsertLength 要插入的字符串的长度
@param [in] paramInsertCount 反复插入串的次数，默认为1
*/
void InsertString(XInt paramPos, const T * paramInsertString, XInt paramInsertLength, XInt paramInsertCount)
{
ZDH_ASSERT(paramInsertString != NULL);
ZDH_ASSERT(paramInsertLength >= 0);
ZDH_ASSERT(paramInsertLength == string_utils::Length(paramInsertString));
if( paramInsertCount <=0 ) return;
XInt iLength = getLength();
XInt iInsertLength = paramInsertLength;
XInt iAllInsertLength = iInsertLength * paramInsertCount;
if( iInsertLength > 0) //如果有要插入的数据
{
if( paramPos < 0 ) paramPos = 0;
ensureCapacity(iLength + iAllInsertLength);
if( paramPos >= iLength )
{
for(XInt i = 0; i < paramInsertCount; i++)
{
AppendString(paramInsertString, iInsertLength);
}
}
else
{
T * p = (T *)Data();
//移动
T * pDest = p + iLength + iAllInsertLength; //最后的地址
T * pSrc = p + iLength;
T * pMove = p + paramPos;
while( pSrc >= pMove )
{
*pDest-- = *pSrc --;
}
//插入
for(XInt j = 0; j < paramInsertCount; j++)
{
const T * pInsert = paramInsertString;
for(XInt i = 0; i < iInsertLength; i++)
{
*pMove ++ = *pInsert++;
}
}
getOriData()->Length = iLength + iAllInsertLength;
}
}
}
///查询替换子串
/**
@param [in] paramSubString 要被替换的子串
@param [in] paramDestString 要被换成的字符串
@param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
@return XInt 实际替换的次数
*/
XInt ReplaceString(const T * paramSubString, const T * paramDestString, XInt paramMaxReplaceCount = -1)
{
ZDH_ASSERT(paramSubString != NULL );
ZDH_ASSERT(paramDestString != NULL );
return ReplaceString( 0, paramSubString, string_utils::Length(paramSubString), paramDestString, string_utils::Length( paramDestString), paramMaxReplaceCount );
}
///查询替换子串
/**
@param [in] paramSubString 要被替换的子串
@param [in] paramDestString 要被换成的字符串
@param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
@return XInt 实际替换的次数
*/
XInt ReplaceString(const XStringBase<T> & paramSubString, const XStringBase<T> & paramDestString, XInt paramMaxReplaceCount = -1)
{
return ReplaceString( 0, paramSubString.c_str(), paramSubString.getLength(), paramDestString.c_str(), paramDestString.getLength(), paramMaxReplaceCount);
}
///查询替换子串
/**
@param [in] paramStartPos 开始查找替换的位置
@param [in] paramSubString 要被替换的子串
@param [in] paramDestString 要被换成的字符串
@param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
@return XInt 实际替换的次数
*/
XInt ReplaceString(XInt paramStartPos, const T * paramSubString, const T * paramDestString, XInt paramMaxReplaceCount = -1)
{
ZDH_ASSERT(paramSubString != NULL );
ZDH_ASSERT(paramDestString != NULL );
return ReplaceString( paramStartPos, paramSubString, string_utils::Length(paramSubString), paramDestString, string_utils::Length( paramDestString), paramMaxReplaceCount );
}
///查询替换子串
/**
@param [in] paramStartPos 开始查找替换的位置
@param [in] paramSubString 要被替换的子串
@param [in] paramDestString 要被换成的字符串
@param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
@return XInt 实际替换的次数
*/
XInt ReplaceString(XInt paramStartPos, const XStringBase<T> & paramSubString, const XStringBase<T> & paramDestString, XInt paramMaxReplaceCount = -1)
{
return ReplaceString( paramStartPos, paramSubString.c_str(), paramSubString.getLength(), paramDestString.c_str(), paramDestString.getLength(), paramMaxReplaceCount);
}
///查询替换子串
/**
@param [in] paramStartPos 开始查找替换的位置
@param [in] paramSubString 要被替换的子串
@param [in] paramSubStringLength 子串的长度
@param [in] paramDestString 要被换成的字符串
@param [in] paramDestStringLength 要被换成的字符串的长度
@param [in] paramMaxReplaceCount 最大替换的次数,如果该值小于0,则不限次数
@return XInt 实际替换的次数
*/
XInt ReplaceString(XInt paramStartPos, const T * paramSubString, XInt paramSubStringLength, const T * paramDestString, XInt paramDestStringLength, XInt paramMaxReplaceCount = -1)
{
ZDH_ASSERT(paramSubString != NULL);
ZDH_ASSERT(paramDestString != NULL);
ZDH_ASSERT(paramSubStringLength == string_utils::Length(paramSubString));
ZDH_ASSERT(paramDestStringLength == string_utils::Length(paramDestString));
XInt iRet = 0; //返回替换的次数
XInt iStart = paramStartPos; //开始替换的位置
XInt iBegin = 0; //要保留字符串的起始位置
XStringBase<T> strTemp; //临时用的字符串
XInt iLocalLength = getLength(); //当前字符串的长度
strTemp.ensureCapacity( iLocalLength );
XInt iPos = Pos(iStart, paramSubString, paramSubStringLength ); //第一次查找
//当找到子串，并且替换次数小于最大替换次数或者无限替换次数
while(iPos >= 0 && ((paramMaxReplaceCount > 0 && iRet < paramMaxReplaceCount) || paramMaxReplaceCount < 0) )
{
iRet ++;
XInt iCopyLength = iPos - iBegin; //确定要复制的字符串
if( iCopyLength > 0 )
{
strTemp.AppendString( c_str() + iBegin, iCopyLength, 1);
}
if( paramDestStringLength > 0)
{
strTemp.AppendString( paramDestString, paramDestStringLength, 1);
}
iStart = iBegin = iPos + paramSubStringLength;
iPos = Pos(iStart, paramSubString, paramSubStringLength);
}
if( iRet > 0) //如果发生了替换
{
XInt iCopyLength = iLocalLength - iBegin;
if( iCopyLength > 0 )
{
strTemp.AppendString( c_str() + iBegin, iCopyLength, 1);
}
Swap(strTemp);
}
return iRet;
}
///将字符转换成32位有符号整数
/**
如果字符串是无效整数，将会抛出异常XEConvert。
字符串支持8,10,16进制整数
*/
XInt ToInt() const;
///将字符转换成32位有符号整数
/**
字符串支持8,10,16进制整数
@param [out] paramResult 存放转换的结果
@return bool 转换结果
- true 表示转换成功
- false 表示转换失败
*/
bool ToInt(XInt & paramResult) const
{
return string_utils::TryStringToInt(c_str(),paramResult);
}
///将字符转换成32位有符号整数
/**
如果字符串是无效整数，将会返回指定的缺省值。
字符串支持8,10,16进制整数
@param [in] paramDefault 转换失败的缺省值
*/
XInt ToIntDef(XInt paramDefault) const
{
return string_utils::StringToIntDef(c_str(),paramDefault);
}
///将字符转换成32位无符号整数
/**
如果字符串是无效整数，将会抛出异常XEConvert。
字符串支持8,10,16进制整数
*/
XDWord ToDWord() const;
///将字符转换成32位无符号整数
/**
字符串支持8,10,16进制整数
@param [out] paramResult 存放转换的结果
@return bool 转换结果
- true 表示转换成功
- false 表示转换失败
*/
bool ToDWord(XDWord & paramResult) const
{
return string_utils::TryStringToDWord(c_str(), paramResult);
}
///将字符转换成32位无符号整数
/**
如果字符串是无效整数，将会返回指定的缺省值。
字符串支持8,10,16进制整数
@param [in] paramDefault 转换失败的缺省值
*/
XDWord ToDWordDef(XDWord paramDefault) const
{
return string_utils::StringToDWordDef(c_str(),paramDefault);
}
///将字符转换成64位有符号整数
/**
如果字符串是无效整数，将会抛出异常XEConvert。
字符串支持8,10,16进制整数
*/
XLong ToLong() const;
///将字符转换成64位有符号整数
/**
字符串支持8,10,16进制整数
@param [out] paramResult 存放转换的结果
@return bool 转换结果
- true 表示转换成功
- false 表示转换失败
*/
bool ToLong(XLong & paramResult) const
{
return string_utils::TryStringToLong(c_str(), paramResult);
}
///将字符转换成64位有符号整数
/**
如果字符串是无效整数，将会返回指定的缺省值。
字符串支持8,10,16进制整数
@param [in] paramDefault 转换失败的缺省值
*/
XLong ToLongDef(XLong paramDefault) const
{
return string_utils::StringToLongDef(c_str(),paramDefault);
}
///将字符转换成64位无符号整数
/**
如果字符串是无效整数，将会抛出异常XEConvert。
字符串支持8,10,16进制整数
*/
XDDWord ToDDWord() const;
///将字符转换成64位无符号整数
/**
字符串支持8,10,16进制整数
@param [out] paramResult 存放转换的结果
@return bool 转换结果
- true 表示转换成功
- false 表示转换失败
*/
bool ToDDWord(XDWord & paramResult) const
{
return string_utils::TryStringToDDWord(c_str(), paramResult);
}
///将字符转换成64位无符号整数
/**
如果字符串是无效整数，将会返回指定的缺省值。
字符串支持8,10,16进制整数
@param [in] paramDefault 转换失败的缺省值
*/
XDDWord ToDDWordDef(XDDWord paramDefault) const
{
return string_utils::StringToDDWordDef(c_str(), paramDefault);
}
///比较函数
/**
@param [in] paramR 参考比较的函数
@return XInt 返回比较结果
- 0 表示this == paramR
> 0 表示this > paramR
< 0 表示this < paramR
*/
XInt Compare(const XStringBase<T>& paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str());
}
///忽略大小写比较函数
/**
@param [in] paramR 参考比较的函数
@return XInt 返回比较结果
- 0 表示this == paramR
> 0 表示this > paramR
< 0 表示this < paramR
*/
XInt CompareIC(const XStringBase<T>& paramR) const //ignorecase
{
return string_utils::CompareIC(c_str(),paramR.c_str());
}
///设为空串
void ToEmptyString()
{
if( getCapacity() > 0)
{
*((T *)m_Data) = 0;
getOriData()->Length = 0;
}
}
///字符串交换
void Swap(XStringBase<T> & paramR)
{
void * pTemp = m_Data;
m_Data = paramR.m_Data;
paramR.m_Data = pTemp;
}
///在当前的字符串中，删除指定的字符
/**
@param [in] paramCh 要删除的字符
@return XInt 删除字符的个数
*/
XInt RemoveChar(T paramCh)
{
XInt iFoundCount = 0;
if( isNotEmpty() )
{
T * pSrc = (T *)c_str();
T * pDest = pSrc;
XInt iLength = getLength();
while(iLength > 0)
{
T ch = *pSrc++;
if( ch == paramCh )
{
iFoundCount ++;
}
else
{
*pDest++ = ch;
}
iLength --;
}
*pDest = 0;
getOriData()->Length = getOriData()->Length - iFoundCount;
}
return iFoundCount;
}
//一组删除子串的函数
///删除子串
/**
这个函数指定的要删除的子串和要删除子串的次数
@param [in] paramRemoveString 要删除的子串
@param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
@return XInt 实际删除的次数
*/
XInt RemoveString(const XStringBase<T> & paramRemoveString, XInt paramMaxRemoveCount)
{
return RemoveString(0, paramRemoveString.c_str(), paramRemoveString.getLength(), paramMaxRemoveCount);
}
///删除子串
/**
这个函数指定的要删除的子串和要删除子串的次数
@param [in] paramStartPos 指定开始删除的位置
@param [in] paramRemoveString 要删除的子串
@param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
@return XInt 实际删除的次数
*/
XInt RemoveString(XInt paramStartPos, const XStringBase<T> & paramRemoveString, XInt paramMaxRemoveCount)
{
return RemoveString(paramStartPos, paramRemoveString.c_str(), paramRemoveString.getLength(), paramMaxRemoveCount);
}
///删除子串
/**
这个函数指定的要删除的子串和要删除子串的次数
@param [in] paramRemoveString 要删除的子串
@param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
@return XInt 实际删除的次数
*/
XInt RemoveString(const T * paramRemoveString, XInt paramMaxRemoveCount)
{
return RemoveString(0, paramRemoveString, string_utils::Length(paramRemoveString), paramMaxRemoveCount);
}
///删除子串
/**
这个函数指定的要删除的子串和要删除子串的次数
@param [in] paramStartPos 指定开始删除的位置
@param [in] paramRemoveString 要删除的子串
@param [in] paramMaxRemoveCount 要删除子串的最大删除次数,-1表示不限制次数
@return XInt 实际删除的次数
*/
XInt RemoveString(XInt paramStartPos, T * paramRemoveString, XInt paramMaxRemoveCount)
{
return RemoveString(paramStartPos, paramRemoveString, string_utils::Length(paramRemoveString), paramMaxRemoveCount);
}
///删除子串
/**
这个函数指定的要删除的子串
@param [in] paramRemoveString 要删除的子串
@return XInt 实际删除的次数
*/
XInt RemoveString(const XStringBase<T> & paramRemoveString)
{
return RemoveString(0, paramRemoveString.c_str(), paramRemoveString.getLength(), -1);
}
///删除子串
/**
这个函数指定的要删除的子串
@param [in] paramStartPos 指定开始删除的位置
@param [in] paramRemoveString 要删除的子串
@return XInt 实际删除的次数
*/
XInt RemoveString(XInt paramStartPos, const XStringBase<T> & paramRemoveString)
{
return RemoveString(paramStartPos, paramRemoveString.c_str(), paramRemoveString.getLength(), -1);
}
///删除子串
/**
这个函数指定的要删除的子串
@param [in] paramRemoveString 要删除的子串
@return XInt 实际删除的次数
*/
XInt RemoveString(const T * paramRemoveString)
{
return RemoveString(0, paramRemoveString, string_utils::Length(paramRemoveString), -1);
}
///删除子串
/**
这个函数指定的要删除的子串
@param [in] paramStartPos 指定开始删除的位置
@param [in] paramRemoveString 要删除的子串
@return XInt 实际删除的次数
*/
XInt RemoveString(XInt paramStartPos, T * paramRemoveString)
{
return RemoveString(paramStartPos, paramRemoveString, string_utils::Length(paramRemoveString), -1);
}
///删除指定的子串
/**
@param [in] paramStartPos 开始删除的下标
@param [in] paramRemoveString 要删除的子串
@param [in] paramRemoveStringLength 要删除子串的长度
@param [in] paramMaxRemoveCount 要删除的次数，-1表示不限次数
@return XInt 实际删除子串的次数
*/
XInt RemoveString(XInt paramStartPos, const T * paramRemoveString, XInt paramRemoveStringLength, XInt paramMaxRemoveCount)
{
ZDH_ASSERT(paramRemoveString != NULL);
ZDH_ASSERT(paramRemoveStringLength == string_utils::Length(paramRemoveString));
XInt iLocalLength = getLength();
if( paramStartPos < 0)
{
paramStartPos = 0;
}
else if( paramStartPos >= iLocalLength )
{
return 0;
}
XInt iFoundCount = 0;
if( paramRemoveStringLength > 0 && iLocalLength >= paramRemoveStringLength )
{
XInt iPos = Pos(paramStartPos, paramRemoveString);
XChar * pDest = (XChar *)c_str();
const XChar * pSrc = c_str();
while(iPos >= 0 &&( paramMaxRemoveCount < 0|| (paramMaxRemoveCount > iFoundCount) ))
{
const XChar * pFound = c_str() + iPos;
iFoundCount ++;
while( pSrc < pFound )
{
*pDest++ = *pSrc++;
}
pSrc = pFound + paramRemoveStringLength;
iPos = Pos(iPos + paramRemoveStringLength, paramRemoveString);
}
if( iFoundCount > 0)
{
const XChar * pLast = c_str() + iLocalLength;
while(pSrc < pLast)
{
*pDest ++ = *pSrc++;
}
*pDest = 0;
getOriData()->Length = iLocalLength - paramRemoveStringLength * iFoundCount;
}
}
return iFoundCount;
}
///将当前字符串小写转换成大写
void UpperCase()
{
string_utils::UpperCase((T *)Data());
}
///将字符串大写转换成小写
void LowerCase()
{
string_utils::LowerCase((T *)Data());
}
///将整数转换为16进制串
/**
@param [in] paramValue 要转换的值
@param [in] paramHexWidth 16进制数字的宽度
@param [in] paramHexStyle 16进制的样式
@param [in] paramHexPrefix 是否要0x前缀
*/
void NumberToHex(XInt paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
NumberToHex((XDWord)paramValue, paramHexWidth, paramHexStyle, paramHexPrefix);
}
///将整数转换为16进制串
/**
@param [in] paramValue 要转换的值
@param [in] paramHexWidth 16进制数字的宽度
@param [in] paramHexStyle 16进制的样式
@param [in] paramHexPrefix 是否要0x前缀
*/
void NumberToHex(XDWord paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
if( paramHexWidth > 8)
{
ensureCapacity(paramHexWidth + 4);
}
else
{
ensureCapacity(12);
}
string_utils::DWordToHex(paramValue, (T *)Data(), paramHexWidth, paramHexStyle, paramHexPrefix);
}
///将整数转换为16进制串
/**
@param [in] paramValue 要转换的值
@param [in] paramHexWidth 16进制数字的宽度
@param [in] paramHexStyle 16进制的样式
@param [in] paramHexPrefix 是否要0x前缀
*/
void NumberToHex(XLong paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
NumberToHex((XDDWord)paramValue, paramHexWidth, paramHexStyle, paramHexPrefix);
}
///将整数转换为16进制串
/**
@param [in] paramValue 要转换的值
@param [in] paramHexWidth 16进制数字的宽度
@param [in] paramHexStyle 16进制的样式
@param [in] paramHexPrefix 是否要0x前缀
*/
void NumberToHex(XDDWord paramValue,XInt paramHexWidth = 1, T paramHexStyle = 'A', bool paramHexPrefix = true)
{
if( paramHexWidth > 16)
{
ensureCapacity(paramHexWidth + 4);
}
else
{
ensureCapacity(20);
}
string_utils::DDWordToHex(paramValue, (T *)Data(), paramHexWidth, paramHexStyle, paramHexPrefix);
}
protected:
///扩展容量
/**
注意:这个函数，并不会做安全检查
@param [in] paramMinimumCapacity 指定的最小容量，这个容量是字符个数
*/
void expandCapacity(XInt paramMinimumCapacity);
///取实际字符串指针
/**
注意:这里不会做越界检查,
*/
const SStringStruct * getOriData() const { return ((const SStringStruct *)m_Data) - 1; }
///取实际字符串指针
/**
注意:这里不会做越界检查
*/
SStringStruct * getOriData() { return ((SStringStruct *)m_Data) - 1;}
///复制字符串
/**
@param [in] paramSrc 源字符串地址
@param [out] paramDest 目标串地址
@param [in] paramCopyCharNumber 要复制的字符个数
*/
static void CopyData(const T * paramSrc, T * paramDest, XInt paramCopyCharNumber)
{
//ZDH_ASSERT(paramCopyCharNumber > 0);
XInt iCopyBytes = paramCopyCharNumber * sizeof(T);
XInt iCopyCount = iCopyBytes / sizeof(XDDWord);
XDDWord * pS = (XDDWord *)paramSrc;
XDDWord * pD = (XDDWord *)paramDest;
for(XInt i = iCopyCount; i > 0; i--, pS ++, pD++ )
{
*pD = *pS;
}
XByte * pBS = (XByte *)pS;
XByte * pBD = (XByte *)pD;
for(XInt i = iCopyBytes - iCopyCount * sizeof(XDDWord);i > 0; i--, pBS ++, pBD++ )
{
*pBD = *pBS;
}
*((T *)pBD) = 0;
}
///查找子串是否存在
/**
@param [in] paramString 查找的字符串
@param [in] paramSubString 被查找的子串
@return T * 返回结果
- NULL 表示未找到该子串
- not NULL 表示找到了该子串，并返回该子串的地址
*/
static const T * FindString(const T * paramString, const T * paramSubString)
{
if( isNULL(paramSubString) ) return paramString;
if( isNULL(paramString) ) return NULL;
const T * s = paramString;
T c = *s;
T c2 = *paramSubString;
while( c )
{
if( c == c2 ) //如果找到了第一个字符，那么开始找子串
{
const T * s1 = s;
const T * s2 = paramSubString;
T t1 = c;
T t2 = c2;
while( t1 && t2 && (!(t2 - t1)))
{
t1 = *++s1;
t2 = *++s2;
}
if( !t2 ) return s;
}
c = *++s;
}
return NULL;
}
private:
T * m_Data; ///<数据指针
};
// ///替换字符串
// /**
// @param [in] paramSrc 源字符串
// @param [out] paramResult 目标存放字符串
// @param [in] paramFindString 查询的内容
// @param [in] paramReplaceString 被替换的内容
// @return XInt 被替换的次数
//
// */
// template<class T>
// inline XInt ReplaceString(const T & paramSrc, T & paramResult, const T & paramFindString,const T & paramReplaceString)
// {
// const T * pSrc = ¶mSrc;
// T strTmp;
// if( pSrc == ¶mResult )
// {
// strTmp = paramSrc;
// pSrc = &strTmp;
// }
// XInt iReplaceCount = 0;
// T & strSource = &pSrc;
// XInt iPos = strSource.Pos(0,paramFindString);
//
// XInt iLastPos = 0;
//
// while(iPos != -1)
// {
//
// }
//
// };
///单字符字符串
class XAnsiString : public XStringBase<XChar>
{
public:
typedef XStringBase<XChar> Inherited;
public:
///默认构造函数
XAnsiString(){}
///指定初始值的构造函数
XAnsiString(const XChar * paramString)
:Inherited(paramString)
{}
///默认拷贝构造函数
XAnsiString(const XAnsiString & paramString)
:Inherited(paramString)
{}
///指定初始字符构造函数
XAnsiString(XChar paramChar)
:Inherited(paramChar)
{}
///指定8位无符号整数构造函数
XAnsiString(const XByte & paramByte)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramByte,TempBuffer));
}
///指定16位有符号整数构造函数
XAnsiString(const XShort & paramNumber)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramNumber,TempBuffer));
}
///指定16位无符号整数构造函数
XAnsiString(const XWord & paramNumber)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramNumber,TempBuffer));
}
///指定32位有符号整数构造函数
XAnsiString(const XInt & paramNumber)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramNumber,TempBuffer));
}
///指定32位无符号整数构造函数
XAnsiString(const XDWord & paramNumber)
{
XChar TempBuffer[32];
Assign(string_utils::DWordToStr(paramNumber,TempBuffer));
}
///指定64位有符号整数构造函数
XAnsiString(const XLong & paramNumber)
{
XChar TempBuffer[32];
Assign(string_utils::LongToStr(paramNumber,TempBuffer));
}
///指定64位无符号整数构造函数
XAnsiString(const XDDWord & paramNumber)
{
XChar TempBuffer[32];
Assign(string_utils::DDWordToStr(paramNumber,TempBuffer));
}
XAnsiString & operator = (const XChar * paramValue)
{
Assign(paramValue);
return *this;
}
///指定字符赋值函数
XAnsiString & operator = (const XChar & paramValue)
{
Assign(paramValue);
return *this;
}
///指定8位无符号整数赋值函数
XAnsiString & operator = (const XByte & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定16位有符号整数赋值函数
XAnsiString & operator = (const XShort & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定16位无符号整数赋值函数
XAnsiString & operator = (const XWord & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定32位有符号整数赋值函数
XAnsiString & operator = (const XInt & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定32位无符号整数赋值函数
XAnsiString & operator = (const XDWord & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///指定64位有符号整数赋值函数
XAnsiString & operator = (const XLong & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///指定64位无符号整数赋值函数
XAnsiString & operator = (const XDDWord & paramValue)
{
XChar TempBuffer[32];
Assign(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///指定字符串赋值函数
XAnsiString & operator = (const XAnsiString & paramValue)
{
if( ¶mValue != this)
{
Assign(paramValue);
}
return *this;
}
///追加一个字符串
XAnsiString & operator += (const XChar * paramValue)
{
AppendString(paramValue);//,::strlen(paramValue));
return *this;
}
///追加一个字符
XAnsiString & operator += (const XChar & paramValue)
{
AppendChar(paramValue);
return *this;
}
///追加8位无符号整数
XAnsiString & operator += (const XByte & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位有符号整数
XAnsiString & operator += (const XShort & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位无符号整数
XAnsiString & operator += (const XWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位有符号整数
XAnsiString & operator += (const XInt & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位无符号整数
XAnsiString & operator += (const XDWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///追加64位有符号整数
XAnsiString & operator += (const XLong & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///追加64位无符号整数
XAnsiString & operator += (const XDDWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///追加一个字符串
XAnsiString & operator += (const XAnsiString & paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符串
XAnsiString & operator << (const XChar * paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符
XAnsiString & operator << (const XChar & paramValue)
{
AppendChar(paramValue);
return *this;
}
///追加8位无符号整数
XAnsiString & operator << (const XByte & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位有符号整数
XAnsiString & operator << (const XShort & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位无符号整数
XAnsiString & operator << (const XWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位有符号整数
XAnsiString & operator << (const XInt & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位无符号整数
XAnsiString & operator << (const XDWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///追加64位有符号整数
XAnsiString & operator << (const XLong & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///追加64位无符号整数
XAnsiString & operator << (const XDDWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///追加一个字符串
XAnsiString & operator << (const XAnsiString & paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符串
XAnsiString & operator , (const XChar * paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符
XAnsiString & operator , (const XChar & paramValue)
{
AppendChar(paramValue);
return *this;
}
///追加8位无符号整数
XAnsiString & operator , (const XByte & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位有符号整数
XAnsiString & operator , (const XShort & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位无符号整数
XAnsiString & operator , (const XWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位有符号整数
XAnsiString & operator , (const XInt & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位无符号整数
XAnsiString & operator , (const XDWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///追加64位有符号整数
XAnsiString & operator , (const XLong & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///追加64位无符号整数
XAnsiString & operator , (const XDDWord & paramValue)
{
XChar TempBuffer[32];
AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///追加一个字符串
XAnsiString & operator , (const XAnsiString & paramValue)
{
AppendString(paramValue);
return *this;
}
///重载[]运算符
XChar operator[](XInt paramIndex) const
{
return at(paramIndex);
}
///重载[]运算符
XChar & operator[](XInt paramIndex)
{
return at(paramIndex);
}
///连接一个字符
XAnsiString operator + (const XChar & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接8位无符整数
XAnsiString operator + (const XByte & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接16位有符整数
XAnsiString operator + (const XShort & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接16位无符整数
XAnsiString operator + (const XWord & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接32位有符整数
XAnsiString operator + (const XInt & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接32位无符整数
XAnsiString operator + (const XDWord & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接64位有符整数
XAnsiString operator + (const XLong & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接64位无符整数
XAnsiString operator + (const XDDWord & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接一个字符串
XAnsiString operator + (const XAnsiString & paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接一个字符串
XAnsiString operator + (const XChar * paramValue) const
{
XAnsiString strRet(*this);
strRet += paramValue;
return strRet;
}
//一组比较函数
bool operator == (const XAnsiString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) == 0;
}
bool operator != (const XAnsiString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) != 0;
}
bool operator >= (const XAnsiString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) >= 0;
}
bool operator <= (const XAnsiString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) <= 0;
}
bool operator > (const XAnsiString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) > 0;
}
bool operator < (const XAnsiString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) < 0;
}
//一组比较函数
bool operator == (const XChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) == 0;
}
bool operator != (const XChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) != 0;
}
bool operator >= (const XChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) >= 0;
}
bool operator <= (const XChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) <= 0;
}
bool operator > (const XChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) > 0;
}
bool operator < (const XChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) < 0;
}
///指定格式化生成字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XAnsiString & 返回当前字符串
*/
XAnsiString& sprintf(const XChar* paramFormat,  ) // Returns *this
{
va_list argptr;
va_start(argptr, paramFormat);
vprintf(paramFormat,argptr);
return *this;
}
///指定格式化生成字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt printf(const XChar* paramFormat, ) // Returns formatted length
{
va_list argptr;
va_start(argptr, paramFormat);
return vprintf(paramFormat,argptr);
}
///指定格式化生成字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt vprintf(const XChar* paramFormat, va_list paramList) // Returns formatted length
{
#ifdef CONFIG_VC
XInt iLength = _vscprintf(paramFormat,paramList);
#else
XInt iLength = snprintf(NULL,0,paramFormat,paramList);
#endif
if( iLength > 0)
{
ensureCapacity(iLength);
vsprintf((XChar *)Data(),paramFormat,paramList);
getOriData()->Length = iLength;
}
return iLength;
}
///指定连接格式化生成的字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XAnsiString & 返回当前字符串
*/
XAnsiString& cat_sprintf(const char* paramFormat, ) // Returns *this
{
va_list argptr;
va_start(argptr, paramFormat);
cat_vprintf(paramFormat,argptr);
return *this;
}
///指定连接格式化生成的字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt cat_printf(const char* paramFormat, ) // Returns formatted length
{
va_list argptr;
va_start(argptr, paramFormat);
return cat_vprintf(paramFormat,argptr);
}
///指定连接格式化生成的字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt cat_vprintf(const char* paramFormat, va_list paramList) // Returns formatted length
{
#ifdef CONFIG_VC
XInt iLength = _vscprintf(paramFormat,paramList);
#else
XInt iLength = snprintf(NULL,0,paramFormat,paramList);
#endif
if( iLength > 0)
{
XInt iLocalLength = getLength();
ensureCapacity(iLength + iLocalLength);
vsprintf(((XChar *)Data()) + iLocalLength,paramFormat,paramList);
getOriData()->Length = iLength + iLocalLength;
}
return iLength;
}
///清空字符串左右两边空格字符
XAnsiString Trim() const
{
XAnsiString strRet(*this);
if( strRet.isNotEmpty() )
{
strRet.getOriData()->Length = string_utils::Trim((XChar *)strRet.Data(),strRet.getLength());
}
return strRet;
}
XAnsiString & Trim(XAnsiString & paramStore) const
{
paramStore = *this;
if( paramStore.isNotEmpty() )
{
paramStore.getOriData()->Length = string_utils::Trim((XChar *)paramStore.Data(),paramStore.getLength());
}
return paramStore;
}
///清空字符串左边空格字符串
XAnsiString TrimLeft() const
{
XAnsiString strRet(*this);
if( strRet.isNotEmpty() )
{
strRet.getOriData()->Length = string_utils::TrimLeft((XChar *)strRet.Data(),strRet.getLength());
}
return strRet;
}
XAnsiString & TrimLeft(XAnsiString & paramStore) const
{
paramStore = *this;
if( paramStore.isNotEmpty() )
{
paramStore.getOriData()->Length = string_utils::TrimLeft((XChar *)paramStore.Data(),paramStore.getLength());
}
return paramStore;
}
///清空字符串右边空格字符串
XAnsiString TrimRight() const
{
XAnsiString strRet(*this);
if( strRet.isNotEmpty() )
{
strRet.getOriData()->Length = string_utils::TrimRight((XChar *)strRet.Data(),strRet.getLength());
}
return strRet;
}
XAnsiString & TrimRight(XAnsiString & paramStore) const
{
paramStore = *this;
if( paramStore.isNotEmpty() )
{
paramStore.getOriData()->Length = string_utils::TrimRight((XChar *)paramStore.Data(),paramStore.getLength());
}
return paramStore;
}
///取指定的子串
XAnsiString & SubString(const XInt paramStartPos, const XInt paramSubLength, XAnsiString & paramStore ) const
{
XAnsiString & strRet = paramStore;
XInt iLength = getLength();
if( paramStartPos >= 0 && paramSubLength > 0 && paramStartPos < iLength )
{
XInt iMaxLength = iLength - paramStartPos;
if( iMaxLength > paramSubLength) iMaxLength = paramSubLength;
strRet.ensureCapacity( iMaxLength );
const XChar * pSrc = c_str() + paramStartPos;
while( iMaxLength > 0)
{
strRet += *pSrc ++;
iMaxLength --;
}
}
return paramStore;
}
///取指定的子串
/**
@param [in] paramStartPos 指定的位置
@param [in] paramSubLength 子串的长度
@return XAnsiString 取得的子串
*/
XAnsiString SubString(const XInt paramStartPos, const XInt paramSubLength) const
{
XAnsiString strRet;
SubString(paramStartPos,paramSubLength,strRet);
return strRet;
}
///取空串
static const XAnsiString & EmptyString()
{
static XAnsiString sEmptyString;
return sEmptyString;
}
};
//---------------------------------------------------------------------------------------------------
///双字符字符串
class XWideString : public XStringBase<XWideChar>
{
public:
typedef XStringBase<XWideChar> Inherited;
public:
///默认构造函数
XWideString(){}
///指定初始值的构造函数
XWideString(const XWideChar * paramString)
:Inherited(paramString)
{}
///默认拷贝构造函数
XWideString(const XWideString & paramString)
:Inherited(paramString)
{}
///指定初始字符构造函数
XWideString(XWideChar paramChar)
:Inherited(paramChar)
{}
///指定8位无符号整数构造函数
XWideString(const XByte & paramByte)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramByte,TempBuffer));
}
///指定16位有符号整数构造函数
XWideString(const XShort & paramNumber)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramNumber,TempBuffer));
}
///指定16位无符号整数构造函数
XWideString(const XWord & paramNumber)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramNumber,TempBuffer));
}
///指定32位有符号整数构造函数
XWideString(const XInt & paramNumber)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramNumber,TempBuffer));
}
///指定32位无符号整数构造函数
XWideString(const XDWord & paramNumber)
{
XWideChar TempBuffer[32];
Assign(string_utils::DWordToStr(paramNumber,TempBuffer));
}
///指定64位有符号整数构造函数
XWideString(const XLong & paramNumber)
{
XWideChar TempBuffer[32];
Assign(string_utils::LongToStr(paramNumber,TempBuffer));
}
///指定64位无符号整数构造函数
XWideString(const XDDWord & paramNumber)
{
XWideChar TempBuffer[32];
Assign(string_utils::DDWordToStr(paramNumber,TempBuffer));
}
XWideString & operator = (const XWideChar * paramValue)
{
Assign(paramValue);
return *this;
}
///指定字符赋值函数
XWideString & operator = (const XWideChar & paramValue)
{
Assign(paramValue);
return *this;
}
///指定8位无符号整数赋值函数
XWideString & operator = (const XByte & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定16位有符号整数赋值函数
XWideString & operator = (const XShort & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定16位无符号整数赋值函数
XWideString & operator = (const XWord & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定32位有符号整数赋值函数
XWideString & operator = (const XInt & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///指定32位无符号整数赋值函数
XWideString & operator = (const XDWord & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///指定64位有符号整数赋值函数
XWideString & operator = (const XLong & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///指定64位无符号整数赋值函数
XWideString & operator = (const XDDWord & paramValue)
{
XWideChar TempBuffer[32];
Assign(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///指定字符串赋值函数
XWideString & operator = (const XWideString & paramValue)
{
if( ¶mValue != this)
{
Assign(paramValue);
}
return *this;
}
///追加一个字符串
XWideString & operator += (const XWideChar * paramValue)
{
AppendString(paramValue);//,::strlen(paramValue));
return *this;
}
///追加一个字符
XWideString & operator += (const XWideChar & paramValue)
{
AppendChar(paramValue);
return *this;
}
///追加8位无符号整数
XWideString & operator += (const XByte & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位有符号整数
XWideString & operator += (const XShort & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位无符号整数
XWideString & operator += (const XWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位有符号整数
XWideString & operator += (const XInt & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位无符号整数
XWideString & operator += (const XDWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///追加64位有符号整数
XWideString & operator += (const XLong & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///追加64位无符号整数
XWideString & operator += (const XDDWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///追加一个字符串
XWideString & operator += (const XWideString & paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符串
XWideString & operator << (const XWideChar * paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符
XWideString & operator << (const XWideChar & paramValue)
{
AppendChar(paramValue);
return *this;
}
///追加8位无符号整数
XWideString & operator << (const XByte & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位有符号整数
XWideString & operator << (const XShort & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位无符号整数
XWideString & operator << (const XWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位有符号整数
XWideString & operator << (const XInt & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位无符号整数
XWideString & operator << (const XDWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///追加64位有符号整数
XWideString & operator << (const XLong & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///追加64位无符号整数
XWideString & operator << (const XDDWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///追加一个字符串
XWideString & operator << (const XWideString & paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符串
XWideString & operator , (const XWideChar * paramValue)
{
AppendString(paramValue);
return *this;
}
///追加一个字符
XWideString & operator , (const XWideChar & paramValue)
{
AppendChar(paramValue);
return *this;
}
///追加8位无符号整数
XWideString & operator , (const XByte & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位有符号整数
XWideString & operator , (const XShort & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加16位无符号整数
XWideString & operator , (const XWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位有符号整数
XWideString & operator , (const XInt & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::IntToStr(paramValue,TempBuffer));
return *this;
}
///追加32位无符号整数
XWideString & operator , (const XDWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::DWordToStr(paramValue,TempBuffer));
return *this;
}
///追加64位有符号整数
XWideString & operator , (const XLong & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::LongToStr(paramValue,TempBuffer));
return *this;
}
///追加64位无符号整数
XWideString & operator , (const XDDWord & paramValue)
{
XWideChar TempBuffer[32];
AppendString(string_utils::DDWordToStr(paramValue,TempBuffer));
return *this;
}
///追加一个字符串
XWideString & operator , (const XWideString & paramValue)
{
AppendString(paramValue);
return *this;
}
///重载[]运算符
XWideChar operator[](XInt paramIndex) const
{
return at(paramIndex);
}
///重载[]运算符
XWideChar & operator[](XInt paramIndex)
{
return at(paramIndex);
}
///连接一个字符
XWideString operator + (const XWideChar & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接8位无符整数
XWideString operator + (const XByte & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接16位有符整数
XWideString operator + (const XShort & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接16位无符整数
XWideString operator + (const XWord & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接32位有符整数
XWideString operator + (const XInt & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接32位无符整数
XWideString operator + (const XDWord & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接64位有符整数
XWideString operator + (const XLong & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接64位无符整数
XWideString operator + (const XDDWord & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接一个字符串
XWideString operator + (const XWideString & paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
///连接一个字符串
XWideString operator + (const XWideChar * paramValue) const
{
XWideString strRet(*this);
strRet += paramValue;
return strRet;
}
//一组比较函数
bool operator == (const XWideString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) == 0;
}
bool operator != (const XWideString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) != 0;
}
bool operator >= (const XWideString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) >= 0;
}
bool operator <= (const XWideString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) <= 0;
}
bool operator > (const XWideString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) > 0;
}
bool operator < (const XWideString & paramR) const
{
return string_utils::Compare(c_str(),paramR.c_str()) < 0;
}
//一组比较函数
bool operator == (const XWideChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) == 0;
}
bool operator != (const XWideChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) != 0;
}
bool operator >= (const XWideChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) >= 0;
}
bool operator <= (const XWideChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) <= 0;
}
bool operator > (const XWideChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) > 0;
}
bool operator < (const XWideChar * paramR) const
{
return string_utils::Compare(c_str(),paramR) < 0;
}
///指定格式化生成字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XWideString & 返回当前字符串
*/
XWideString& sprintf(const XWideChar* paramFormat, ) // Returns *this
{
va_list argptr;
va_start(argptr, paramFormat);
vprintf(paramFormat,argptr);
return *this;
}
///指定格式化生成字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt printf(const XWideChar* paramFormat, ) // Returns formatted length
{
va_list argptr;
va_start(argptr, paramFormat);
return vprintf(paramFormat,argptr);
}
///指定格式化生成字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt vprintf(const XWideChar* paramFormat, va_list paramList) // Returns formatted length
{
#ifdef CONFIG_VC
XInt iLength = _vscwprintf(paramFormat,paramList);
#else
XInt iLength = snwprintf(NULL,0,paramFormat,paramList);
#endif
if( iLength > 0)
{
ensureCapacity(iLength);
#ifdef CONFIG_VC
vswprintf_s((XWideChar *)Data(),iLength+1,paramFormat,paramList);
#else
vswprintf((XWideChar *)Data(),paramFormat,paramList);
#endif
getOriData()->Length = iLength;
}
return iLength;
}
///指定连接格式化生成的字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XWideString & 返回当前字符串
*/
XWideString& cat_sprintf(const XWideChar* paramFormat, ) // Returns *this
{
va_list argptr;
va_start(argptr, paramFormat);
cat_vprintf(paramFormat,argptr);
return *this;
}
///指定连接格式化生成的字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt cat_printf(const XWideChar* paramFormat, ) // Returns formatted length
{
va_list argptr;
va_start(argptr, paramFormat);
return cat_vprintf(paramFormat,argptr);
}
///指定连接格式化生成的字符串
/**
@param [in] 格式化串,参考标准C的格式化串
@return XInt 返回格式化字符串的长度
*/
XInt cat_vprintf(const XWideChar* paramFormat, va_list paramList) // Returns formatted length
{
#ifdef CONFIG_VC
XInt iLength = _vscwprintf(paramFormat,paramList);
#else
XInt iLength = snwprintf(NULL,0,paramFormat,paramList);
#endif
if( iLength > 0)
{
XInt iLocalLength = getLength();
ensureCapacity(iLength + iLocalLength);
#ifdef CONFIG_VC
vswprintf_s((XWideChar *)Data() + iLocalLength,iLength+1,paramFormat,paramList);
#else
vswprintf(((XWideChar *)Data()) + iLocalLength,paramFormat,paramList);
#endif
getOriData()->Length = iLength + iLocalLength;
}
return iLength;
}
///清空字符串左右两边空格字符
XWideString Trim() const
{
XWideString strRet(*this);
if( strRet.isNotEmpty() )
{
strRet.getOriData()->Length = string_utils::Trim((XWideChar *)strRet.Data(),strRet.getLength());
}
return strRet;
}
XWideString & Trim(XWideString & paramStore) const
{
paramStore = *this;
if( paramStore.isNotEmpty() )
{
paramStore.getOriData()->Length = string_utils::Trim((XWideChar *)paramStore.Data(),paramStore.getLength());
}
return paramStore;
}
///清空字符串左边空格字符串
XWideString TrimLeft() const
{
XWideString strRet(*this);
if( strRet.isNotEmpty() )
{
strRet.getOriData()->Length = string_utils::TrimLeft((XWideChar *)strRet.Data(),strRet.getLength());
}
return strRet;
}
XWideString & TrimLeft(XWideString & paramStore) const
{
paramStore = *this;
if( paramStore.isNotEmpty() )
{
paramStore.getOriData()->Length = string_utils::TrimLeft((XWideChar *)paramStore.Data(),paramStore.getLength());
}
return paramStore;
}
///清空字符串右边空格字符串
XWideString TrimRight() const
{
XWideString strRet(*this);
if( strRet.isNotEmpty() )
{
strRet.getOriData()->Length = string_utils::TrimRight((XWideChar *)strRet.Data(),strRet.getLength());
}
return strRet;
}
XWideString & TrimRight(XWideString & paramStore) const
{
paramStore = *this;
if( paramStore.isNotEmpty() )
{
paramStore.getOriData()->Length = string_utils::TrimRight((XWideChar *)paramStore.Data(),paramStore.getLength());
}
return paramStore;
}
///取指定的子串
XWideString & SubString(const XInt paramStartPos, const XInt paramSubLength, XWideString & paramStore ) const
{
XWideString & strRet = paramStore;
XInt iLength = getLength();
if( paramStartPos >= 0 && paramSubLength > 0 && paramStartPos < iLength )
{
XInt iMaxLength = iLength - paramStartPos;
if( iMaxLength > paramSubLength) iMaxLength = paramSubLength;
strRet.ensureCapacity( iMaxLength );
const XWideChar * pSrc = c_str() + paramStartPos;
while( iMaxLength > 0)
{
strRet += *pSrc ++;
iMaxLength --;
}
}
return paramStore;
}
///取指定的子串
/**
@param [in] paramStartPos 指定的位置
@param [in] paramSubLength 子串的长度
@return XWideString 取得的子串
*/
XWideString SubString(const XInt paramStartPos, const XInt paramSubLength) const
{
XWideString strRet;
SubString(paramStartPos,paramSubLength,strRet);
return strRet;
}
///取空串
static const XWideString & EmptyString()
{
static XWideString sEmptyString;
return sEmptyString;
}
};
//---------------------------------------------------------------------------------------------------
///异常类基类
class XException
{
public:
///默认构造函数
XException()
:m_HelpContext(0)
{}
///指定异常信息的构造函数
/**
@param [in] paramMessage 异常信息
@param [in] paramHelpContext 帮助信息ID
*/
XException(const XAnsiString & paramMessage, XInt paramHelpContext = 0)
:m_Message(paramMessage),
m_HelpContext(paramHelpContext)
{}
///指定异常信息的构造函数
/**
@param [in] paramMessage 异常信息
@param [in] paramHelpContext 帮助信息ID
*/
XException(const XChar* paramMessage, XInt paramHelpContext = 0)
:m_Message(paramMessage),
m_HelpContext(paramHelpContext)
{}
///析构函数
virtual ~XException()
{}
///取异常信息
const XAnsiString getMessage() const
{
return m_Message;
}
///设置异常信息
void setMessage(const XChar * paramMessage)
{
m_Message = paramMessage;
}
///设置异常信息
void setMessage(const XAnsiString & paramMessage)
{
m_Message = paramMessage;
}
///取帮助信息ID
XInt getHelpContext() const
{
return m_HelpContext;
}
///设置帮助信息ID
void setHelpContext(XInt paramHelpContext)
{
m_HelpContext = paramHelpContext;
}
///转换成字符串指针
operator const XChar *() const
{
return m_Message.c_str();
}
private:
XAnsiString m_Message; ///<异常信息
XInt m_HelpContext; ///<帮助信息ID
};
#define MESSAGE_OUT_OF_MEMORY "out of memory"
#define MESSAGE_NOT_EXISTS "not exists object!"
#define MESSAGE_IS_ZERO "is zero"
#define MESSAGE_LESS_THAN_ZERO "less than zero"
#define MESSAGE_CONVERT_FAIL "Type convert fail"
#define MESSAGE_GREATER_THAN_ZERO "greater than zero"
#define MESSAGE_OUT_OF_RANGE "out of range:index=%d,length=%d"
///内存溢出异常
class XEOutOfMemory : public XException
{
public:
///默认构造函数
XEOutOfMemory()
:XException(MESSAGE_OUT_OF_MEMORY)
{}
///指定异常信息的构造函数
/**
@param [in] paramMessage 异常信息
@param [in] paramHelpContext 帮助信息ID
*/
XEOutOfMemory(const XAnsiString & paramMessage, XInt paramHelpContext = 0)
:XException(paramMessage,paramHelpContext)
{}
///指定异常信息的构造函数
/**
@param [in] paramMessage 异常信息
@param [in] paramHelpContext 帮助信息ID
*/
XEOutOfMemory(const XChar* paramMessage, XInt paramHelpContext = 0)
:XException(paramMessage,paramHelpContext)
{}
///析构函数
~XEOutOfMemory()
{
}
};
//---------------------------------------------------------------------
class XEConvert : public XException
{
public:
///默认构造函数
XEConvert()
:XException(MESSAGE_CONVERT_FAIL)
{}
///指定异常信息的构造函数
/**
@param [in] paramMessage 异常信息
@param [in] paramHelpContext 帮助信息ID
*/
XEConvert(const XAnsiString & paramMessage, XInt paramHelpContext = 0)
:XException(paramMessage,paramHelpContext)
{}
///指定异常信息的构造函数
/**
@param [in] paramMessage 异常信息
@param [in] paramHelpContext 帮助信息ID
*/
XEConvert(const XChar* paramMessage, XInt paramHelpContext = 0)
:XException(paramMessage,paramHelpContext)
{}
///析构函数
~XEConvert()
{
}
};
///数组越界异常
class XEOutOfRange : public XException
{
public:
///数组越界异常构造函数
/**
@param [in] paramIndex 越界的下标值
@param [in] aLength 被越界的数组的长度
*/
XEOutOfRange(XInt paramIndex = 0,XInt aLength = 0)
:m_Index(paramIndex),m_Length(aLength)
{
MakeMsg();
}
///析构函数
~XEOutOfRange(){}
///设置越界信息
/**
@param [in] paramIndex 越界的下标值
@param [in] aLength 被越界的数组的长度
*/
void setInfo(XInt paramIndex,XInt aLength)
{
m_Index = paramIndex;
m_Length = aLength;
MakeMsg();
}
///取越界的下标值
/**
@return 返回越界的下标值
*/
XInt getIndex() const { return m_Index; }
///取被越界的数组的长度
/**
@return 返回被越界的长度
*/
XInt getLength() const { return m_Length; }
protected:
///生成异常信息
void MakeMsg()
{
XAnsiString strMsg;
strMsg.printf(MESSAGE_OUT_OF_RANGE,m_Index,m_Length);
setMessage(strMsg);
}
private:
XInt m_Index; ///<越界的下标
XInt m_Length; ///<被越界的数组的下标
};
///值为零异常类
class XEIsZero : public XException
{
public:
XEIsZero()
:XException(MESSAGE_IS_ZERO)
{}
};
///值小于零异常类
class XELessThanZero : public XException
{
public:
XELessThanZero()
:XException(MESSAGE_LESS_THAN_ZERO)
{}
};
///值大于零异常类
class XEGreatherThanZero : public XException
{
public:
XEGreatherThanZero()
:XException(MESSAGE_GREATER_THAN_ZERO)
{}
};
///不存在异常类
class XENotExists : public XException
{
public:
XENotExists()
:XException(MESSAGE_NOT_EXISTS)
{}
};
///取指定下标的字符
template<class T,class Alloctor>
T XStringBase<T,Alloctor>::at(XInt paramIndex) const ZDH_THROW(XEOutOfRange)
ZDH_THROW(XEOutOfRange)
{
if( !CheckIndex(paramIndex) )
{
throw XEOutOfRange(paramIndex,getLength());
}
return *(((T *)m_Data) + paramIndex);
}
//---------------------------------------------------------------------
///取指定下标的字符引用
template<class T,class Alloctor>
T & XStringBase<T,Alloctor>::at(XInt paramIndex)
ZDH_THROW(XEOutOfRange)
{
if( !CheckIndex(paramIndex) )
{
throw XEOutOfRange(paramIndex,getLength());
}
return *(((T *)m_Data) + paramIndex);
}
///扩展容量
/**
注意:这个函数，并不会做安全检查
@param [in] paramMinimumCapacity 指定的最小容量，这个容量是字符个数
*/
template<class T,class Alloctor>
void XStringBase<T,Alloctor>::expandCapacity(XInt paramMinimumCapacity)
ZDH_THROW(XEOutOfMemory)
{
//ZDH_ASSERT(paramMinimumCapacity>0);
XInt iNowCapacity = getCapacity();
if( iNowCapacity < paramMinimumCapacity)
{
XInt iNewCapacity = paramMinimumCapacity * CHAR_SIZE + HEAD_SIZE; //取得实际所需的字节数
iNowCapacity *= 2;
if( iNewCapacity < iNowCapacity) iNewCapacity = iNowCapacity;
XInt iMod = iNewCapacity % STRING_BLOCK_SIZE;
//确保申请的内存为指定大小的倍数
if( iMod > 0 )
{
iNewCapacity += (STRING_BLOCK_SIZE - iMod);
}
SStringStruct * pData = (SStringStruct *)Alloctor::Alloc(iNewCapacity);
//检查内存是否溢出
if( pData == NULL )
{
throw XEOutOfMemory();
}
//设置基本属性
pData->Capacity = (iNewCapacity - HEAD_SIZE) / CHAR_SIZE;
pData->Length = getLength();
if( pData->Length > 0 ) //复制数据
{
CopyData( (T *)m_Data, (T *)(pData + 1), getLength() );
}
else
{
*((T *)(pData + 1)) = 0;
}
//释放原来的
if( m_Data != NULL )
{
Alloctor::Free(getOriData());
}
//开始替换
m_Data = (T *)(pData+1);
}
}
//-----------------------------------------------------------------------------
///将字符串转换成32位有符号整数
/**
转换失败，将抛出XEConvert异常
*/
template<class T,class Alloctor>
XInt XStringBase<T,Alloctor>::ToInt() const
ZDH_THROW(XEConvert)
{
XInt iRet;
if( !string_utils::TryStringToInt(c_str(),iRet))
{
throw XEConvert();
}
return iRet;
}
///将字符串转换成32位无符号整数
/**
转换失败，将抛出XEConvert异常
*/
template<class T,class Alloctor>
XDWord XStringBase<T,Alloctor>::ToDWord() const
ZDH_THROW(XEConvert)
{
XDWord dwRet;
if( !string_utils::TryStringToDWord(c_str(),dwRet))
{
throw XEConvert();
}
return dwRet;
}
///将字符串转换成64位有符号整数
/**
转换失败，将抛出XEConvert异常
*/
template<class T,class Alloctor>
XLong XStringBase<T,Alloctor>::ToLong() const
ZDH_THROW(XEConvert)
{
XLong lngRet;
if( !string_utils::TryStringToLong(c_str(),lngRet))
{
throw XEConvert();
}
return lngRet;
}
///将字符串转换成64位无符号整数
/**
转换失败，将抛出XEConvert异常
*/
template<class T,class Alloctor>
XDDWord XStringBase<T,Alloctor>::ToDDWord() const
ZDH_THROW(XEConvert)
{
XDDWord ddwRet;
if( !string_utils::TryStringToDDWord(c_str(),ddwRet))
{
throw XEConvert();
}
return ddwRet;
}
///重载ostream的<<运算符
inline std::ostream & operator << (std::ostream & paramOutStream, const XAnsiString & paramStr)
{
return paramOutStream << paramStr.c_str();
}
}
#endif /* X_STRING_H_ */
|